fix: app.reset and make code more portable

relates to graphql-nexus/nexus@1df6d23

src/lib/add-to-context-extractor/extractor.spec.ts

@@ -142,14 +142,14 @@ it('extracts from returned object of referenced primitive value', () => {
   `)
 })
 
-it('can access all default context types', () => {
-  const allTypesExported = DEFAULT_CONTEXT_TYPES.typeImports.every(i => {
+it('all types extracted from the default context data are importable', () => {
+  const allTypesExported = DEFAULT_CONTEXT_TYPES.typeImports.every((i) => {
     const project = new tsm.Project({
       addFilesFromTsConfig: false,
-      skipFileDependencyResolution: true
+      skipFileDependencyResolution: true,
     })
 
-    const sourceFile = project.addSourceFileAtPath(i.modulePath + '.d.ts')
+    const sourceFile = project.addSourceFileAtPath(i.modulePath + '.ts')
 
     return sourceFile.getExportedDeclarations().has(i.name)
   })

src/lib/add-to-context-extractor/typegen.ts

@@ -6,7 +6,7 @@ import { hardWriteFile } from '../fs'
 import * as Layout from '../layout'
 import { rootLogger } from '../nexus-logger'
 import { createTSProject } from '../tsc'
-import { Exception } from '../utils'
+import { Exception, prettyImportPath } from '../utils'
 import { ContribType, extractContextTypes, ExtractedContextTypes } from './extractor'
 
 const log = rootLogger.child('addToContextExtractor')
@@ -22,7 +22,7 @@ export const DEFAULT_CONTEXT_TYPES: ExtractedContextTypes = {
   typeImports: [
     {
       name: 'ContextAdderLens',
-      modulePath: require.resolve('../../../dist/runtime/schema/schema').split('.')[0],
+      modulePath: prettyImportPath(require.resolve('../../runtime/schema/schema')),
       isExported: true,
       isNode: false,
     },

src/lib/utils/index.ts

@@ -492,14 +492,21 @@ export function noop() {}
  * foo/bar -> foo/bar
  * ```
  * ```
+ * foo/bar.js -> foo/bar
+ * ```
+ * ```
  * foo/bar/index.js -> foo/bar
  * ```
  */
 export function prettyImportPath(id: string): string {
-  const { dir, name } = Path.parse(id)
+  const { dir, name, ext } = Path.parse(id)
 
   if (name === 'index') return dir
 
+  if (ext) {
+    return id.replace(ext, '')
+  }
+
   return id
 }
 
@@ -541,4 +548,4 @@ export function indent(str: string, len: number, char: string = ' ') {
     .split('\n')
     .map((s) => char.repeat(len) + s)
     .join('\n')
-}
+}

src/runtime/app.spec.ts

@@ -3,12 +3,17 @@ import * as GraphQL from 'graphql'
 import * as HTTP from 'http'
 import 'jest-extended'
 import * as Lo from 'lodash'
+import { inspect } from 'util'
 import { setReflectionStage, unsetReflectionStage } from '../lib/reflection'
 import * as App from './app'
 import * as Lifecycle from './lifecycle'
 
 let app: App.PrivateApp
 
+function dump(x: any) {
+  return inspect(x, { depth: null })
+}
+
 beforeEach(() => {
   app = App.create() as App.PrivateApp
   // fix once there is a singleton logger
@@ -23,13 +28,19 @@ describe('reset', () => {
       server: { path: '/bar' },
       schema: { connections: { foo: {} } },
     })
-    app.schema.objectType({ name: 'Foo', definition(t) { t.string('ok') } })
+    app.schema.objectType({
+      name: 'Foo',
+      definition(t) {
+        t.string('ok')
+      },
+    })
     app.on.start(() => {})
     app.assemble()
     app.reset()
     expect(app.settings.current.server.path).toEqual(app.settings.original.server.path)
     expect(app.settings.current.schema).toEqual(app.settings.original.schema)
-    expect(app.private.state).toEqual(originalAppState)
+    // must dump because functions are not equal-able
+    expect(dump(app.private.state)).toEqual(dump(originalAppState))
     expect(app.private.state.components.lifecycle).toEqual(Lifecycle.createLazyState())
   })
 
@@ -48,7 +59,12 @@ describe('assemble', () => {
 
   beforeEach(() => {
     // avoid schema check error
-    app.schema.objectType({ name: 'Foo', definition(t) { t.string('ok') } })
+    app.schema.objectType({
+      name: 'Foo',
+      definition(t) {
+        t.string('ok')
+      },
+    })
   })
 
   it('multiple calls is a noop', () => {

src/runtime/app.ts

@@ -139,15 +139,15 @@ export function create(): App {
     server: serverComponent.public,
     on: lifecycleComponent.public,
     reset() {
-      // todo once we have log filtering, make this debug level
-      rootLogger.trace('resetting state')
+      rootLogger.debug('resetting state')
       schemaComponent.private.reset()
       serverComponent.private.reset()
       settingsComponent.private.reset()
       lifecycleComponent.private.reset()
       state.assembled = null
       state.plugins = []
       state.running = false
+      dogfood()
     },
     async start() {
       if (Reflection.isReflection()) return
@@ -207,25 +207,36 @@ export function create(): App {
   }
 
   /**
-   * Setup default log filter
+   * Dogfood the public API to change things.
    */
-  app.settings.change({
-    logger: {
-      filter: 'app:*, nexus:*@info+, *@warn+',
-      pretty: { timeDiff: false },
-    },
-  })
+  function dogfood() {
+    /**
+     * Setup default log filter
+     */
+    app.settings.change({
+      logger: {
+        filter: 'app:*, nexus:*@info+, *@warn+',
+        pretty: { timeDiff: false },
+      },
+    })
+
+    /**
+     * Setup default scalar types
+     */
+    app.schema.importType(builtinScalars.DateTime, 'date')
+    app.schema.importType(builtinScalars.Json, 'json')
+
+    /**
+     * Add `req` and `res` to the context by default
+     */
+    app.schema.addToContext((params) => params)
+  }
 
-  /**
-   * Setup default scalar types
-   */
-  app.schema.importType(builtinScalars.DateTime, 'date')
-  app.schema.importType(builtinScalars.Json, 'json')
+  // HACK dogfood function called eagerly here once and
+  // then within reset method. We should have a better
+  // reset system.
 
-  /**
-   * Add `req` and `res` to the context by default
-   */
-  app.schema.addToContext(params => params)
+  dogfood()
 
   return {
     ...app,