refactor: settings lib (#1275)

Author: Jason Kuhrt

package.json

@@ -61,6 +61,7 @@
     "prismjs": "^1.20.0",
     "prompts": "^2.3.0",
     "rxjs": "^6.5.4",
+    "setset": "^0.0.3",
     "simple-git": "^2.0.0",
     "slash": "^3.0.0",
     "source-map-support": "^0.5.19",
@@ -121,7 +122,7 @@
     "postpublish": "yarn clean",
     "postinstall": "node scripts/postinstall",
     "prepublishOnly": "yarn build",
-    "test": "cross-env FORCE_COLOR=3 LOG_PRETTY=true DEBUG=true jest --verbose --testTimeout 1200000 --forceExit",
+    "test": "cross-env FORCE_COLOR=3 LOG_PRETTY=true DEBUG=true jest --testTimeout 1200000 --forceExit",
     "test:unit": "yarn test src",
     "dev:test": "yarn test --watch src",
     "dev": "yarn clean && node scripts/build-module-facades && tsc -b tsconfig.cjs.json -w"

src/lib/utils/index.ts

@@ -21,6 +21,10 @@ export type Param3<F> = F extends (p1: any, p2: any, p3: infer P3, ...args: any[
 
 /**
  * Represents a POJO. Prevents from allowing arrays and functions
+ *
+ * @remarks
+ *
+ * TypeScript interfaces will not be considered sub-types.
  */
 export type PlainObject = {
   [x: string]: Primitive | object
@@ -92,12 +96,13 @@ export declare type DeepRequired<T> = T extends (...args: any[]) => any
   ? DeepRequiredObject<T>
   : T
 
-export interface DeepRequiredArray<T> extends Array<DeepRequired<NonUndefined<T>>> {}
+export type ExcludeUndefined<A> = A extends undefined ? never : A
+
+export interface DeepRequiredArray<T> extends Array<DeepRequired<ExcludeUndefined<T>>> {}
 
 export declare type DeepRequiredObject<T> = {
-  [P in keyof T]-?: DeepRequired<NonUndefined<T[P]>>
+  [K in keyof T]-?: DeepRequired<ExcludeUndefined<T[K]>>
 }
-export declare type NonUndefined<A> = A extends undefined ? never : A
 
 /**
  * Guarantee the length of a given string, padding before or after with the

src/runtime/schema/settings-mapper.ts

@@ -32,7 +32,7 @@ export function mapSettingsAndPluginsToNexusSchemaConfig(
 
   baseConfig.plugins!.push(...mapConnectionsSettingsToNexusSchemaConfig(settings))
 
-  if (settings.authorization !== false) {
+  if (settings.authorization.enabled) {
     baseConfig.plugins!.push(NexusSchema.fieldAuthorizePlugin(settings.authorization))
   }
 
@@ -51,24 +51,7 @@ export function mapSettingsAndPluginsToNexusSchemaConfig(
  * Specialized mapping for the complexity of relay connections plugins.
  */
 function mapConnectionsSettingsToNexusSchemaConfig(settings: SettingsData): NexusSchema.core.NexusPlugin[] {
-  const instances: NexusSchema.core.NexusPlugin[] = []
-
-  const { default: defaultTypeConfig, ...customTypesConfig } = settings.connections
-
-  for (const [name, config] of Object.entries(customTypesConfig)) {
-    if (config) {
-      instances.push(
-        NexusSchema.connectionPlugin({
-          nexusFieldName: name,
-          ...config,
-        })
-      )
-    }
-  }
-
-  if (defaultTypeConfig) {
-    instances.push(NexusSchema.connectionPlugin(defaultTypeConfig))
-  }
-
-  return instances
+  return Object.values(settings.connections).map((config) => {
+    return NexusSchema.connectionPlugin(config)
+  })
 }

src/runtime/schema/settings.spec.ts

@@ -11,10 +11,12 @@ it('has defaults', () => {
   expect(sm.data).toMatchInlineSnapshot(`
     Object {
       "authorization": Object {
+        "enabled": true,
         "formatError": [Function],
       },
       "connections": Object {
         "default": Object {
+          "enabled": true,
           "nexusFieldName": "connection",
           "nexusSchemaImportId": "nexus/components/schema",
         },
@@ -40,23 +42,26 @@ describe('connctions', () => {
     expect(sm.data.connections).toMatchInlineSnapshot(`
       Object {
         "a": Object {
-          "nexusFieldName": "connection",
+          "enabled": true,
+          "nexusFieldName": "a",
           "nexusSchemaImportId": "nexus/components/schema",
         },
         "default": Object {
+          "enabled": true,
           "nexusFieldName": "connection",
           "nexusSchemaImportId": "nexus/components/schema",
         },
       }
     `)
   })
   it('existing custom types can be changed, preserving its core settings', () => {
-    sm.change({ connections: { a: {} } }) // test above says this has the core settings
+    // sm.change({ connections: { a: {} } }) // test above says this has the core settings
     sm.change({ connections: { a: { disableForwardPagination: true } } })
     expect(sm.data.connections.a).toMatchInlineSnapshot(`
       Object {
         "disableForwardPagination": true,
-        "nexusFieldName": "connection",
+        "enabled": true,
+        "nexusFieldName": "a",
         "nexusSchemaImportId": "nexus/components/schema",
       }
     `)
@@ -66,6 +71,7 @@ describe('connctions', () => {
     expect(sm.data.connections.default).toMatchInlineSnapshot(`
       Object {
         "disableForwardPagination": true,
+        "enabled": true,
         "nexusFieldName": "connection",
         "nexusSchemaImportId": "nexus/components/schema",
       }

src/runtime/schema/settings.ts

@@ -1,27 +1,27 @@
 import * as NexusSchema from '@nexus/schema'
-import * as Lo from 'lodash'
+import * as Setset from 'setset'
 import { Param1 } from '../../lib/utils'
 
 // todo export type from @nexus/schema
 type ConnectionPluginConfig = NonNullable<Param1<typeof NexusSchema.connectionPlugin>>
 
 type ConnectionPluginConfigPropsManagedByNexus = 'nexusFieldName' | 'nexusSchemaImportId'
 
-const connectionPluginConfigManagedByNexus: Pick<
-  ConnectionPluginConfig,
-  ConnectionPluginConfigPropsManagedByNexus
-> = {
-  nexusSchemaImportId: 'nexus/components/schema',
-  /**
-   * The name of the relay connection field builder. This is not configurable by users.
-   */
-  nexusFieldName: 'connection',
-}
+type ConnectionPluginConfigManagedByNexus = Required<
+  Pick<ConnectionPluginConfig, ConnectionPluginConfigPropsManagedByNexus>
+>
 
 /**
  * Relay connection field builder settings for users.
  */
-export type ConnectionSettings = Omit<ConnectionPluginConfig, ConnectionPluginConfigPropsManagedByNexus>
+export type ConnectionSettings = Omit<ConnectionPluginConfig, ConnectionPluginConfigPropsManagedByNexus> & {
+  enabled?: boolean
+}
+
+export type ConnectionSettingsData = ConnectionSettings &
+  ConnectionPluginConfigManagedByNexus & {
+    enabled: boolean
+  }
 
 /**
  * The schema settings users can control.
@@ -51,16 +51,16 @@ export type SettingsInput = {
     /**
      * todo
      */
-    default?: ConnectionSettings | false
+    default?: false | ConnectionSettings
     // Extra undefined below is forced by it being above, forced via `?:`.
     // This is a TS limitation, cannot express void vs missing semantics,
     // being tracked here: https://github.com/microsoft/TypeScript/issues/13195
-    [connectionTypeName: string]: ConnectionSettings | undefined | false
+    [connectionTypeName: string]: false | undefined | ConnectionSettings
   }
   /**
    * Disable or configure the authorization plugin
    */
-  authorization?: false | NexusSchema.core.FieldAuthorizePluginConfig
+  authorization?: false | (NexusSchema.core.FieldAuthorizePluginConfig & { enabled?: boolean })
   /**
    * Should a [GraphQL SDL file](https://www.prisma.io/blog/graphql-sdl-schema-definition-language-6755bcb9ce51) be generated when the app is built and to where?
    *
@@ -118,99 +118,86 @@ export type SettingsInput = {
 /**
  * Internal representation of settings data.
  */
-export type SettingsData = {
-  nullable: NonNullable<Required<SettingsInput['nullable']>>
+export type SettingsData = Omit<Setset.InferDataFromInput<SettingsInput>, 'connections'> & {
   connections: {
-    default: false | ConnectionPluginConfig
-    [connectionTypeName: string]: false | ConnectionPluginConfig
-  }
-  generateGraphQLSDLFile: NonNullable<SettingsInput['generateGraphQLSDLFile']>
-  rootTypingsGlobPattern: NonNullable<SettingsInput['rootTypingsGlobPattern']>
-  authorization: NonNullable<SettingsInput['authorization']>
-}
-
-/**
- * Mutate the settings data with new settings input.
- */
-export function changeSettings(state: SettingsData, newSettings: SettingsInput): void {
-  if (newSettings.nullable !== undefined) {
-    Lo.merge(state.nullable, newSettings.nullable)
+    default: ConnectionSettingsData
+    [connectionTypeName: string]: ConnectionSettingsData
   }
-
-  if (newSettings.generateGraphQLSDLFile !== undefined) {
-    state.generateGraphQLSDLFile = newSettings.generateGraphQLSDLFile
-  }
-
-  if (newSettings.rootTypingsGlobPattern !== undefined) {
-    state.rootTypingsGlobPattern = newSettings.rootTypingsGlobPattern
-  }
-
-  if (newSettings.authorization !== undefined) {
-    state.authorization = newSettings.authorization
-  }
-
-  if (newSettings.connections !== undefined) {
-    Object.keys(newSettings.connections)
-      // must already have the defaults
-      .filter((key) => state.connections[key] === undefined)
-      .forEach((key) => {
-        state.connections[key] = Lo.merge(state.connections[key], connectionPluginConfigManagedByNexus)
-      })
-    Lo.merge(state.connections, newSettings.connections)
-  }
-}
-
-function defaultAuthorizationErrorFormatter(config: NexusSchema.core.FieldAuthorizePluginErrorConfig) {
-  return config.error
 }
 
 /**
- * Get the default settings.
+ * Create a schema settings manager.
  */
-function defaultSettings(): SettingsData {
-  const data: SettingsData = {
-    nullable: {
-      inputs: true,
-      outputs: true,
-    },
-    generateGraphQLSDLFile: 'api.graphql',
-    rootTypingsGlobPattern: './**/*.ts',
-    connections: {
-      // there is another level of defaults that will be applied by Nexus Schema Relay Connections plugin
-      default: {
-        ...connectionPluginConfigManagedByNexus,
+export const createSchemaSettingsManager = () =>
+  Setset.create<SettingsInput, SettingsData>({
+    fields: {
+      nullable: {
+        fields: {
+          inputs: {
+            initial() {
+              return true
+            },
+          },
+          outputs: {
+            initial() {
+              return true
+            },
+          },
+        },
+      },
+      generateGraphQLSDLFile: {
+        initial() {
+          return 'api.graphql'
+        },
+      },
+      rootTypingsGlobPattern: {
+        initial() {
+          return './**/*.ts'
+        },
+      },
+      authorization: {
+        shorthand(enabled) {
+          return { enabled }
+        },
+        fields: {
+          enabled: {
+            initial: () => true,
+          },
+          formatError: {
+            initial: () => defaultAuthorizationErrorFormatter,
+          },
+        },
+      },
+      connections: {
+        initial() {
+          return {
+            default: {},
+          }
+        },
+        entry: {
+          map(input, ctx) {
+            return {
+              nexusSchemaImportId: 'nexus/components/schema',
+              nexusFieldName: ctx.key === 'default' ? 'connection' : ctx.key,
+            }
+          },
+          shorthand(disabled) {
+            return { enabled: disabled }
+          },
+          fields: {
+            enabled: {
+              initial() {
+                return true
+              },
+            },
+          }, // all data is optional, see type
+        },
       },
     },
-    authorization: {
-      formatError: defaultAuthorizationErrorFormatter,
-    },
-  }
-
-  return data
-}
+  })
 
-/**
- * Create a schema settings manager.
- */
-export function createSchemaSettingsManager() {
-  const data = defaultSettings()
-
-  function change(newSettings: SettingsInput) {
-    return changeSettings(data, newSettings)
-  }
-
-  function reset() {
-    for (const k of Object.keys(data)) {
-      delete (data as any)[k]
-    }
-    Object.assign(data, defaultSettings())
-  }
-
-  return {
-    change,
-    reset,
-    data,
-  }
+function defaultAuthorizationErrorFormatter(config: NexusSchema.core.FieldAuthorizePluginErrorConfig) {
+  return config.error
 }
 
 export type SchemaSettingsManager = ReturnType<typeof createSchemaSettingsManager>

src/runtime/server/handler-graphql.ts

@@ -3,11 +3,11 @@ import { ContextAdder } from '../schema'
 import { ApolloServerless } from './apollo-server'
 import { log } from './logger'
 import { NexusRequestHandler } from './server'
-import { PlaygroundInput } from './settings'
+import { PlaygroundLonghandInput } from './settings'
 
 type Settings = {
   introspection: boolean
-  playground: false | PlaygroundInput
+  playground: false | PlaygroundLonghandInput // todo why not use data? why input?
   path: string
   errorFormatterFn(graphqlError: GraphQLError): GraphQLFormattedError
 }