refactor: some code restructuring

Author: nodkz

.eslintrc

@@ -34,7 +34,8 @@
     "@typescript-eslint/explicit-member-accessibility": 0,
     "@typescript-eslint/no-explicit-any": 0,
     "@typescript-eslint/no-inferrable-types": 0,
-    "@typescript-eslint/explicit-function-return-type": 0
+    "@typescript-eslint/explicit-function-return-type": 0,
+    "@typescript-eslint/no-use-before-define": 0
   },
   "env": {
     "jasmine": true,

package.json

@@ -10,24 +10,24 @@
     "lib"
   ],
   "peerDependencies": {
-    "graphql-compose": "^7.0.0"
+    "graphql-compose": "^7.6.0"
   },
   "devDependencies": {
     "@types/glob": "7.1.1",
     "@types/jest": "24.0.23",
     "@types/node": "12.12.11",
     "@typescript-eslint/eslint-plugin": "2.8.0",
     "@typescript-eslint/parser": "2.8.0",
-    "apollo-server-express": "^2.4.8",
+    "apollo-server": "^2.9.12",
     "eslint": "6.6.0",
     "eslint-config-prettier": "6.7.0",
     "eslint-plugin-prettier": "3.1.1",
     "graphql": "^14.0.0",
-    "graphql-compose": "^7.4.3",
+    "graphql-compose": "^7.6.0",
     "jest": "24.9.0",
     "prettier": "1.19.1",
     "rimraf": "3.0.0",
-    "ts-jest": "24.1.0",
+    "ts-jest": "24.2.0",
     "typescript": "3.7.2"
   },
   "scripts": {
@@ -37,7 +37,10 @@
     "lint": "eslint 'src/**/*.{js,ts}'",
     "test": "npm run lint && npm run tscheck && npm run coverage",
     "tscheck": "tsc --noEmit",
-    "start-example": "cd ./examples/forTests && yarn install && yarn watch"
+    "start-example1": "cd ./examples/simple && yarn install && yarn watch",
+    "start-example2": "cd ./examples/forTests && yarn install && yarn watch"
   },
-  "dependencies": {}
+  "dependencies": {
+    "dedent": "^0.7.0"
+  }
 }

src/__tests__/__snapshots__/requireToSchema-test.ts.snap renamed to src/__tests__/__snapshots__/requireAstToSchema-test.ts.snap

@@ -1,6 +1,6 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
-exports[`requireToSchema() Schema ../../examples/forTests/schema schema 1`] = `
+exports[`requireAstToSchema() Schema ../../examples/forTests/schema schema 1`] = `
 "# Provides default value for input field.
 directive @default(value: JSON!) on INPUT_FIELD_DEFINITION
 
@@ -43,6 +43,26 @@ type MutationUser {
 
 type Query {
   me: MeType
+  some: QuerySome
+  user: UserAwesomeType
+}
+
+type QuerySome {
+  type: SomeIndexFileType
+}
+
+type SomeIndexFileType {
+  awesomeValue: String
+}
+
+type UserAwesomeType {
+  firstName: String
+  lastName: String
+  extendedData: UserExtendedData
+}
+
+type UserExtendedData {
+  starsCount: Int
 }
 "
 `;

src/__tests__/__snapshots__/requireSchemaDirectory-test.ts.snap

@@ -81,6 +81,16 @@ Object {
       "kind": "dir",
       "name": "me",
     },
+    "some.type.index": Any<Object>,
+    "user": Object {
+      "absPath": Any<String>,
+      "children": Object {
+        "extendedData": Any<Object>,
+        "index": Any<Object>,
+      },
+      "kind": "dir",
+      "name": "user",
+    },
   },
   "kind": "rootType",
   "name": "query",

src/__tests__/requireToSchema-test.ts renamed to src/__tests__/requireAstToSchema-test.ts

@@ -1,12 +1,12 @@
 import { requireSchemaDirectory } from '../requireSchemaDirectory';
-import { requireToSchema } from '../requireToSchema';
+import { requireAstToSchema } from '../requireAstToSchema';
 import { SchemaComposer } from 'graphql-compose';
 import { printSchema } from 'graphql/utilities';
 
-describe('requireToSchema()', () => {
+describe('requireAstToSchema()', () => {
   describe('Schema ../../examples/forTests/schema', () => {
     const ast = requireSchemaDirectory(module, '../../examples/forTests/schema');
-    const sc = requireToSchema(ast);
+    const sc = requireAstToSchema(ast);
 
     it('should return schema composer', () => {
       expect(sc).toBeInstanceOf(SchemaComposer);

src/__tests__/requireSchemaDirectory-test.ts

@@ -29,6 +29,14 @@ describe('requireSchemaDirectory()', () => {
             },
           },
           index: { kind: 'file', absPath: expect.any(String), code: expect.any(Object) },
+          'some.type.index': expect.any(Object),
+          user: {
+            absPath: expect.any(String),
+            children: {
+              extendedData: expect.any(Object),
+              index: expect.any(Object),
+            },
+          },
         },
       });
     });

src/index.ts

@@ -1 +1,14 @@
-export { requireSchemaDirectory } from './requireSchemaDirectory';
+import { requireSchemaDirectory } from './requireSchemaDirectory';
+import { requireAstToSchema } from './requireAstToSchema';
+
+export function buildSchema(module: NodeModule) {
+  return loadSchemaComposer(module).buildSchema();
+}
+
+export function loadSchemaComposer(module: NodeModule) {
+  const ast = requireSchemaDirectory(module);
+  const sc = requireAstToSchema(ast);
+  return sc;
+}
+
+export { requireSchemaDirectory, requireAstToSchema };

src/requireAstToSchema.ts

@@ -0,0 +1,206 @@
+import {
+  SchemaComposer,
+  ObjectTypeComposer,
+  upperFirst,
+  ObjectTypeComposerFieldConfig,
+  isOutputTypeDefinitionString,
+  isTypeNameString,
+  isComposeOutputType,
+  isSomeOutputTypeDefinitionString,
+  inspect,
+} from 'graphql-compose';
+import {
+  RequireAstResult,
+  RequireAstRootTypeNode,
+  RequireAstDirNode,
+  RequireAstFileNode,
+} from './requireSchemaDirectory';
+import dedent from 'dedent';
+import { GraphQLObjectType } from 'graphql';
+
+export function requireAstToSchema<TContext = any>(
+  ast: RequireAstResult,
+  schemaComposer?: SchemaComposer<TContext>
+): SchemaComposer<TContext> {
+  const sc = schemaComposer || new SchemaComposer<TContext>();
+
+  if (ast.query) populateRoot(sc, 'Query', ast.query);
+  if (ast.mutation) populateRoot(sc, 'Mutation', ast.mutation);
+  if (ast.subscription) populateRoot(sc, 'Subscription', ast.subscription);
+
+  return sc;
+}
+
+function populateRoot(
+  sc: SchemaComposer<any>,
+  rootName: 'Query' | 'Mutation' | 'Subscription',
+  astRootNode: RequireAstRootTypeNode
+) {
+  const tc = sc[rootName];
+  Object.keys(astRootNode.children).forEach((key) => {
+    createFields(sc, astRootNode.children[key], rootName, tc);
+  });
+}
+
+function createFields(
+  sc: SchemaComposer<any>,
+  ast: RequireAstDirNode | RequireAstFileNode,
+  prefix: string,
+  parent: ObjectTypeComposer
+): void {
+  const name = ast.name;
+  if (!/^[._a-zA-Z0-9]+$/.test(name)) {
+    throw new Error(
+      `You provide incorrect field name '${name}'. It should meet RegExp([._a-zA-Z0-9]+) for '${ast.absPath}'`
+    );
+  }
+  const typename = getTypename(ast);
+
+  if (ast.kind === 'file') {
+    if (name !== 'index') {
+      if (name.endsWith('.index')) {
+        const fieldName = name.slice(0, -6); // remove ".index" from field name
+        parent.addNestedFields({
+          [fieldName]: prepareNamespaceFieldConfig(sc, ast, prefix, typename),
+        });
+      } else {
+        parent.addNestedFields({
+          [name]: prepareFieldConfig(sc, ast),
+        });
+      }
+    }
+    return;
+  }
+
+  if (ast.kind === 'dir') {
+    let fc: ObjectTypeComposerFieldConfig<any, any>;
+    if (ast.children['index'] && ast.children['index'].kind === 'file') {
+      fc = prepareNamespaceFieldConfig(sc, ast.children['index'], prefix, typename);
+    } else {
+      fc = { type: sc.createObjectTC(`${prefix}${typename}`) };
+    }
+
+    parent.addNestedFields({
+      [name]: {
+        resolve: () => ({}),
+        ...fc,
+      },
+    });
+
+    Object.keys(ast.children).forEach((key) => {
+      createFields(sc, ast.children[key], name, fc.type as any);
+    });
+  }
+}
+
+function getTypename(ast: RequireAstDirNode | RequireAstFileNode): string {
+  const name = ast.name;
+
+  if (name.indexOf('.') !== -1) {
+    const namesArray = name.split('.');
+
+    if (namesArray.some((n) => !n)) {
+      throw new Error(
+        `Field name '${ast.name}' contains dots in the wrong place for '${ast.absPath}'!`
+      );
+    }
+
+    return namesArray.reduce((prev, current) => {
+      return prev + upperFirst(current);
+    }, '');
+  } else {
+    return upperFirst(name);
+  }
+}
+
+function prepareNamespaceFieldConfig(
+  sc: SchemaComposer<any>,
+  ast: RequireAstFileNode,
+  prefix: string,
+  typename: string
+): ObjectTypeComposerFieldConfig<any, any> {
+  if (!ast.code.default) {
+    throw new Error(dedent`
+      NamespaceModule MUST return FieldConfig as default export in '${ast.absPath}'. 
+      Eg:
+        export default {
+          type: 'SomeObjectTypeName',
+          resolve: () => Date.now(),
+        };
+    `);
+  }
+
+  const fc: any = ast.code.default;
+
+  if (!fc.type) {
+    fc.type = sc.createObjectTC(`${prefix}${typename}`);
+  } else {
+    if (typeof fc.type === 'string') {
+      if (!isOutputTypeDefinitionString(fc.type) && !isTypeNameString(fc.type)) {
+        throw new Error(dedent`
+          You provide incorrect output type definition:
+            ${fc.type}
+          It must be valid TypeName or output type SDL definition:
+          
+          Eg.
+            type Payload { me: String }
+          OR
+            Payload
+        `);
+      }
+    } else if (
+      !(fc.type instanceof ObjectTypeComposer) &&
+      !(fc.type instanceof GraphQLObjectType)
+    ) {
+      throw new Error(dedent`
+        You provide some strange value as 'type':
+          ${inspect(fc.type)}
+      `);
+    }
+    fc.type = sc.createObjectTC(fc.type);
+  }
+
+  if (!fc.resolve) {
+    fc.resolve = () => ({});
+  }
+
+  return fc;
+}
+
+function prepareFieldConfig(
+  sc: SchemaComposer<any>,
+  ast: RequireAstFileNode
+): ObjectTypeComposerFieldConfig<any, any> {
+  const fc = ast.code.default as any;
+
+  if (!fc) {
+    throw new Error(dedent`
+      Module MUST return FieldConfig as default export in '${ast.absPath}'. 
+      Eg:
+        export default {
+          type: 'String',
+          resolve: () => Date.now(),
+        };
+    `);
+  }
+
+  if (!fc.type || !isSomeOutputTypeDefinition(fc.type)) {
+    throw new Error(dedent`
+      Module MUST return FieldConfig with TYPE property in '${ast.absPath}'. 
+      Eg:
+        export default {
+          type: 'String'
+        };
+    `);
+  }
+
+  return fc;
+}
+
+function isSomeOutputTypeDefinition(type: any): boolean {
+  return (
+    (typeof type === 'string' &&
+      (isSomeOutputTypeDefinitionString(type) || isTypeNameString(type))) ||
+    isComposeOutputType(type)
+  );
+}

src/requireSchemaDirectory.ts

@@ -32,7 +32,7 @@ export interface RequireAstDirNode extends RequireAstBaseNode {
 export interface RequireAstFileNode extends RequireAstBaseNode {
   kind: 'file';
   code: {
-    default?: Object;
+    default?: any;
   };
 }
 
@@ -48,7 +48,7 @@ export const defaultOptions = {
 
 export function requireSchemaDirectory(
   m: NodeModule,
-  path: string,
+  path?: string,
   options: Options = defaultOptions
 ): RequireAstResult {
   // if no path was passed in, assume the equivelant of __dirname from caller