@eddeee888/gcg-typescript-resolver-files 0.0.0-pr6-20221024131652

package/.eslintrc.json

@@ -0,0 +1,18 @@
+{
+  "extends": ["../../.eslintrc.json"],
+  "ignorePatterns": ["!**/*"],
+  "overrides": [
+    {
+      "files": ["*.ts", "*.tsx", "*.js", "*.jsx"],
+      "rules": {}
+    },
+    {
+      "files": ["*.ts", "*.tsx"],
+      "rules": {}
+    },
+    {
+      "files": ["*.js", "*.jsx"],
+      "rules": {}
+    }
+  ]
+}

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+# @eddeee888/gcg-typescript-resolver-files
+
+## 0.0.0-pr6-20221024131652
+
+### Patch Changes
+
+- b7eb6e2: Initial publish

package/README.md

@@ -0,0 +1,3 @@
+# @eddeee888/gcg-typescript-resolver-files
+
+This GraphQL Code Generator plugin creates resolvers given GraphQL schema.

package/jest.config.ts

@@ -0,0 +1,16 @@
+/* eslint-disable */
+export default {
+  displayName: 'typescript-resolver-files',
+  preset: '../../jest.preset.js',
+  globals: {
+    'ts-jest': {
+      tsconfig: '<rootDir>/tsconfig.spec.json',
+    },
+  },
+  testEnvironment: 'node',
+  transform: {
+    '^.+\\.[tj]sx?$': 'ts-jest',
+  },
+  moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx'],
+  coverageDirectory: '../../coverage/packages/typescript-resolver-files',
+};

package/package.json

@@ -0,0 +1,4 @@
+{
+  "name": "@eddeee888/gcg-typescript-resolver-files",
+  "version": "0.0.0-pr6-20221024131652"
+}

package/project.json

@@ -0,0 +1,35 @@
+{
+  "name": "typescript-resolver-files",
+  "$schema": "../../node_modules/nx/schemas/project-schema.json",
+  "sourceRoot": "packages/typescript-resolver-files/src",
+  "projectType": "library",
+  "targets": {
+    "build": {
+      "executor": "@nrwl/js:tsc",
+      "outputs": ["{options.outputPath}"],
+      "options": {
+        "outputPath": "dist/packages/typescript-resolver-files",
+        "tsConfig": "packages/typescript-resolver-files/tsconfig.lib.json",
+        "packageJson": "packages/typescript-resolver-files/package.json",
+        "main": "packages/typescript-resolver-files/src/index.ts",
+        "assets": ["packages/typescript-resolver-files/*.md"]
+      }
+    },
+    "lint": {
+      "executor": "@nrwl/linter:eslint",
+      "outputs": ["{options.outputFile}"],
+      "options": {
+        "lintFilePatterns": ["packages/typescript-resolver-files/**/*.ts"]
+      }
+    },
+    "test": {
+      "executor": "@nrwl/jest:jest",
+      "outputs": ["{workspaceRoot}/coverage/{projectRoot}"],
+      "options": {
+        "jestConfig": "packages/typescript-resolver-files/jest.config.ts",
+        "passWithNoTests": true
+      }
+    }
+  },
+  "tags": []
+}

package/src/index.ts

@@ -0,0 +1 @@
+export { plugin } from './plugin';

package/src/plugin.ts

@@ -0,0 +1,46 @@
+import * as path from 'path';
+import { PluginFunction } from '@graphql-codegen/plugin-helpers';
+import { mkdir, writeFile } from 'fs/promises';
+import { run } from './run';
+import { RunResult } from './types';
+
+interface PluginConfig {
+  resolverTypesPath: string;
+}
+
+export const plugin: PluginFunction<PluginConfig> = async (
+  schema,
+  _documents,
+  config,
+  info
+) => {
+  // TODO: check if there's a better way to handle output dir
+  const baseOutputDir = info?.outputFile;
+  if (!baseOutputDir) {
+    throw new Error('Output folder is invalid');
+  }
+  const { resolverTypesPath: relativeResolverTypesPathFromBaseOutputDir } =
+    config;
+  const resolverTypesPath = path.join(
+    baseOutputDir,
+    relativeResolverTypesPathFromBaseOutputDir
+  );
+
+  const result: RunResult = {
+    dirs: [],
+    files: {},
+  };
+  run({ schema, baseOutputDir, resolverTypesPath }, result);
+
+  // Write dirs and files
+  await Promise.all(
+    result.dirs.map(async (dir) => await mkdir(dir, { recursive: true }))
+  );
+  await Promise.all(
+    Object.entries(result.files).map(
+      async ([filePath, file]) => await writeFile(filePath, file.content)
+    )
+  );
+
+  return { content: '' };
+};

package/src/run/addResolversIndexFile.ts

@@ -0,0 +1,98 @@
+import * as path from 'path';
+import type { RootObjectType, RunResult } from '../types';
+import { printImportModule, relativeModulePath } from '../utils';
+
+interface AddResolversIndexFileParams {
+  baseOutputDir: string;
+  resolverTypesPath: string;
+}
+export const addResolversIndexFile = (
+  { baseOutputDir, resolverTypesPath }: AddResolversIndexFileParams,
+  result: RunResult
+): void => {
+  const filename = path.join(baseOutputDir, 'index.ts');
+
+  const relativePathToResolverTypes = relativeModulePath(
+    baseOutputDir,
+    resolverTypesPath
+  );
+  const pathToResolverModule = printImportModule(relativePathToResolverTypes);
+
+  const resolversDetails = Object.entries(result.files).reduce<{
+    importLines: string[];
+    queryFields: string[];
+    mutationFields: string[];
+    subscriptionFields: string[];
+    objectTypes: string[];
+  }>(
+    (res, [filepath, file]) => {
+      if (file.__filetype === 'file') {
+        return res;
+      }
+
+      const pathToModule = printImportModule(
+        relativeModulePath(baseOutputDir, filepath)
+      );
+      res.importLines.push(
+        `import { ${file.mainImportIdentifier} } from '${pathToModule}'`
+      );
+
+      if (!file.meta.belongsToRootObject) {
+        res.objectTypes.push(file.mainImportIdentifier);
+        return res;
+      }
+      const rootObjectMap: Record<RootObjectType, () => void> = {
+        Query: () => res.queryFields.push(file.mainImportIdentifier),
+        Mutation: () => res.mutationFields.push(file.mainImportIdentifier),
+        Subscription: () =>
+          res.subscriptionFields.push(file.mainImportIdentifier),
+      };
+      rootObjectMap[file.meta.belongsToRootObject]();
+
+      return res;
+    },
+    {
+      importLines: [],
+      queryFields: [],
+      mutationFields: [],
+      subscriptionFields: [],
+      objectTypes: [],
+    }
+  );
+
+  const resolversIdentifier = 'resolvers';
+  const resolversTypeName = 'Resolvers'; // Generated type from typescript-resolvers plugin
+
+  const queries =
+    resolversDetails.queryFields.length > 0
+      ? `Query: { ${resolversDetails.queryFields
+          .map((field) => field)
+          .join(',\n')} },`
+      : '';
+  const mutations =
+    resolversDetails.mutationFields.length > 0
+      ? `Mutation: { ${resolversDetails.mutationFields
+          .map((field) => field)
+          .join(',\n')} },`
+      : '';
+  const suscriptions =
+    resolversDetails.subscriptionFields.length > 0
+      ? `Subscription: { ${resolversDetails.subscriptionFields
+          .map((field) => field)
+          .join(',\n')} },`
+      : '';
+
+  result.files[filename] = {
+    __filetype: 'file',
+    content: `/* This file was automatically generated. DO NOT UPDATE MANUALLY. */
+    import type { ${resolversTypeName} } from '${pathToResolverModule}';
+    ${resolversDetails.importLines.map((line) => line).join(';\n')}
+    export const ${resolversIdentifier}: ${resolversTypeName} = {
+      ${queries}
+      ${mutations}
+      ${suscriptions}
+      ${resolversDetails.objectTypes.map((type) => type).join(',\n')}
+    }`,
+    mainImportIdentifier: 'resolvers',
+  };
+};

package/src/run/fixExistingResolvers.ts

@@ -0,0 +1,84 @@
+import { existsSync } from 'fs';
+import { Project } from 'ts-morph';
+import * as path from 'path';
+import type { ResolverFile, RunResult } from '../types';
+
+export const fixExistingResolvers = (result: RunResult) => {
+  const existingResolverFiles = Object.entries(result.files).reduce<
+    Record<string, ResolverFile>
+  >((res, [filePath, file]) => {
+    if (existsSync(filePath) && file.__filetype === 'resolver') {
+      res[filePath] = file;
+    }
+    return res;
+  }, {});
+
+  const project = new Project();
+  project.addSourceFilesAtPaths(Object.keys(existingResolverFiles));
+  const sourceFiles = project.getSourceFiles();
+  sourceFiles.forEach((sourceFile) => {
+    const normalisedRelativePath = path.relative(
+      process.cwd(),
+      sourceFile.getFilePath()
+    );
+    const file = existingResolverFiles[normalisedRelativePath];
+    if (!file) {
+      throw new Error(
+        `Unable to find resolver file: ${normalisedRelativePath}`
+      );
+    }
+
+    // TODO: Check missing import
+    // ...
+
+    // Check expected identifier
+    let isExpectedIdentifierExportedInVariableStatement = false;
+    const variableStatementWithExpectedIdentifier =
+      sourceFile.getVariableStatement((statement) => {
+        let hasExpectedIdentifier = false;
+        statement
+          .getDeclarationList()
+          .getDeclarations()
+          .forEach((declarationNode) => {
+            if (declarationNode.getName() === file.mainImportIdentifier) {
+              hasExpectedIdentifier = true;
+              if (statement.isExported()) {
+                isExpectedIdentifierExportedInVariableStatement = true;
+              }
+            }
+          });
+
+        if (!hasExpectedIdentifier) {
+          return false;
+        }
+        return true;
+      });
+
+    if (!variableStatementWithExpectedIdentifier) {
+      // Did not find variable statement with expected identifier, add it to the end with a warning
+      sourceFile.addStatements(
+        '/* WARNING: The following resolver was missing from this file. Make sure it is properly implemented or there could be runtime errors. */'
+      );
+      sourceFile.addStatements(file.meta.resolverVariableStatement);
+    } else if (
+      variableStatementWithExpectedIdentifier &&
+      !isExpectedIdentifierExportedInVariableStatement
+    ) {
+      // If has identifier but not exported
+      // Add export keyword to statement
+      const isExpectedIdentifierExported = Boolean(
+        sourceFile.getExportedDeclarations().get(file.mainImportIdentifier)
+      );
+      if (!isExpectedIdentifierExported) {
+        variableStatementWithExpectedIdentifier.setIsExported(true);
+      }
+      // else, if identifier's been exported do nothing
+    }
+
+    // Overwrite existing files with fixes
+    result.files[normalisedRelativePath] = {
+      ...file,
+      content: sourceFile.getText(),
+    };
+  });
+};

package/src/run/handleGraphQLObjectType.ts

@@ -0,0 +1,37 @@
+import * as path from 'path';
+import type { GraphQLObjectType } from 'graphql';
+import type { HandleGraphQLType } from '../types';
+import { printImportModule, relativeModulePath } from '../utils';
+
+export const handleGraphQLObjectType: HandleGraphQLType<GraphQLObjectType> = (
+  type,
+  { baseOutputDir, resolverTypesPath },
+  result
+) => {
+  const fieldFilePath = path.join(baseOutputDir, `${type.name}.ts`);
+  if (result.files[fieldFilePath]) {
+    throw new Error(
+      `Unexpected duplication in field filename. Type: ${type.name}, file: ${fieldFilePath}`
+    );
+  }
+
+  const resolverTypeName = `${type.name}Resolvers`; // Generated type from typescript-resolvers plugin
+  const relativePathToResolverTypes = relativeModulePath(
+    baseOutputDir,
+    resolverTypesPath
+  );
+  const pathToResolverModule = printImportModule(relativePathToResolverTypes);
+  const resolverVariableStatement = `export const ${type.name}: ${resolverTypeName} = { 
+  /* Implement ${type.name} resolver logic here */ 
+};`;
+  result.files[fieldFilePath] = {
+    __filetype: 'resolver',
+    content: `import type { ${resolverTypeName} } from '${pathToResolverModule}';
+    ${resolverVariableStatement}`,
+    mainImportIdentifier: type.name,
+    meta: {
+      belongsToRootObject: null,
+      resolverVariableStatement,
+    },
+  };
+};

package/src/run/handleGraphQLRootObjectType.ts

@@ -0,0 +1,52 @@
+import * as path from 'path';
+import type { GraphQLObjectType } from 'graphql';
+import type { HandleGraphQLType } from '../types';
+import {
+  isRootObjectType,
+  printImportModule,
+  relativeModulePath,
+} from '../utils';
+
+export const handleGraphQLRootObjectType: HandleGraphQLType<
+  GraphQLObjectType
+> = (type, { baseOutputDir, resolverTypesPath }, result) => {
+  const typeName = type.name;
+  if (!isRootObjectType(typeName)) {
+    return;
+  }
+
+  const fields = type.getFields();
+  const outputDir = path.join(baseOutputDir, typeName);
+
+  result.dirs.push(outputDir);
+
+  Object.keys(fields).forEach((fieldName) => {
+    const fieldFilePath = path.join(outputDir, `${fieldName}.ts`);
+    if (result.files[fieldFilePath]) {
+      throw new Error(
+        `Unexpected duplication in field filename. Type: ${typeName}, file: ${fieldFilePath}`
+      );
+    }
+
+    const resolverTypeName = `${typeName}Resolvers`; // Generated type from typescript-resolvers plugin
+    const relativePathToResolverTypes = relativeModulePath(
+      outputDir,
+      resolverTypesPath
+    );
+    const pathToResolverModule = printImportModule(relativePathToResolverTypes);
+    const resolverVariableStatement = `export const ${fieldName}: ${resolverTypeName}['${fieldName}'] = async (_parent, _arg, _ctx) => {
+      /* Implement ${typeName}.${fieldName} resolver logic here */
+    };`;
+
+    result.files[fieldFilePath] = {
+      __filetype: 'resolver',
+      content: `import type { ${resolverTypeName} } from '${pathToResolverModule}';
+      ${resolverVariableStatement}`,
+      mainImportIdentifier: fieldName,
+      meta: {
+        belongsToRootObject: typeName,
+        resolverVariableStatement,
+      },
+    };
+  });
+};

package/src/run/handleGraphQLUninionType.ts

@@ -0,0 +1,36 @@
+import * as path from 'path';
+import type { GraphQLUnionType } from 'graphql';
+import type { HandleGraphQLType } from '../types';
+import { printImportModule, relativeModulePath } from '../utils';
+
+export const handleGraphQLUninionType: HandleGraphQLType<GraphQLUnionType> = (
+  type,
+  { baseOutputDir, resolverTypesPath },
+  result
+) => {
+  const typeName = type.name;
+  const fieldFilePath = path.join(baseOutputDir, `${typeName}.ts`);
+  if (result.files[fieldFilePath]) {
+    throw new Error(
+      `Unexpected duplication in field filename. Type: ${typeName}, file: ${fieldFilePath}`
+    );
+  }
+
+  const resolverTypeName = `${typeName}Resolvers`; // Generated type from typescript-resolvers plugin
+  const relativePathToResolverTypes = relativeModulePath(
+    baseOutputDir,
+    resolverTypesPath
+  );
+  const pathToResolverModule = printImportModule(relativePathToResolverTypes);
+  const resolverVariableStatement = `export const ${typeName}: ${resolverTypeName} = { __resolveType: (parent) => parent.__typename };`;
+  result.files[fieldFilePath] = {
+    __filetype: 'resolver',
+    content: `import type { ${resolverTypeName} } from '${pathToResolverModule}';
+    ${resolverVariableStatement}`,
+    mainImportIdentifier: typeName,
+    meta: {
+      belongsToRootObject: null,
+      resolverVariableStatement,
+    },
+  };
+};

package/src/run/index.ts

@@ -0,0 +1 @@
+export { run } from './run';

package/src/run/run.ts

@@ -0,0 +1,28 @@
+import { isObjectType, isUnionType } from 'graphql';
+import type { RunConfig, RunResult } from '../types';
+import { isRootObjectType } from '../utils';
+import { handleGraphQLRootObjectType } from './handleGraphQLRootObjectType';
+import { handleGraphQLObjectType } from './handleGraphQLObjectType';
+import { handleGraphQLUninionType } from './handleGraphQLUninionType';
+import { addResolversIndexFile } from './addResolversIndexFile';
+import { fixExistingResolvers } from './fixExistingResolvers';
+
+export const run = (config: RunConfig, result: RunResult): void => {
+  Object.entries(config.schema.getTypeMap())
+    .filter(([schemaType]) => !schemaType.startsWith('__')) // There are a few internal types with `__` prefixes. We don't want them.
+    .forEach(([schemaType, namedType]) => {
+      if (isObjectType(namedType) && isRootObjectType(schemaType)) {
+        handleGraphQLRootObjectType(namedType, config, result);
+      } else if (isObjectType(namedType) && !isRootObjectType(schemaType)) {
+        handleGraphQLObjectType(namedType, config, result);
+      } else if (isUnionType(namedType)) {
+        handleGraphQLUninionType(namedType, config, result);
+      }
+    });
+
+  // Check to see which resolver file exists already
+  fixExistingResolvers(result);
+
+  // Put all resolvers into a barrel file
+  addResolversIndexFile(config, result);
+};

package/src/types.ts

@@ -0,0 +1,38 @@
+import type { GraphQLSchema } from 'graphql';
+
+interface BaseVirtualFile {
+  __filetype: string;
+  content: string;
+  mainImportIdentifier: string;
+}
+
+export interface StandardFile extends BaseVirtualFile {
+  __filetype: 'file';
+}
+
+export interface ResolverFile extends BaseVirtualFile {
+  __filetype: 'resolver';
+  meta: {
+    belongsToRootObject: RootObjectType | null;
+    resolverVariableStatement: string;
+  };
+}
+
+export interface RunConfig {
+  baseOutputDir: string;
+  resolverTypesPath: string;
+  schema: GraphQLSchema;
+}
+
+export interface RunResult {
+  dirs: string[];
+  files: Record<string, StandardFile | ResolverFile>;
+}
+
+export type RootObjectType = 'Query' | 'Mutation' | 'Subscription';
+
+export type HandleGraphQLType<T> = (
+  type: T,
+  params: RunConfig,
+  result: RunResult
+) => void;

package/src/utils.ts

@@ -0,0 +1,26 @@
+import * as path from 'path';
+import type { RootObjectType } from './types';
+
+export const printImportModule = (moduleName: string) => {
+  if (moduleName.endsWith('.ts')) {
+    return moduleName.split('.').slice(0, -1).join('.');
+  }
+  return moduleName;
+};
+
+export const isRootObjectType = (
+  typeName: string
+): typeName is RootObjectType =>
+  typeName === 'Query' ||
+  typeName === 'Mutation' ||
+  typeName === 'Subscription';
+
+export const relativeModulePath = (from: string, to: string) => {
+  const rawPath = path.relative(from, to);
+
+  if (!rawPath.startsWith('../') || !rawPath.startsWith('./')) {
+    return `./${rawPath}`;
+  }
+
+  return rawPath;
+};

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "files": [],
+  "include": [],
+  "references": [
+    {
+      "path": "./tsconfig.lib.json"
+    },
+    {
+      "path": "./tsconfig.spec.json"
+    }
+  ],
+  "compilerOptions": {
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true
+  }
+}

package/tsconfig.lib.json

@@ -0,0 +1,11 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "module": "commonjs",
+    "outDir": "../../dist/out-tsc",
+    "declaration": true,
+    "types": ["node"]
+  },
+  "exclude": ["jest.config.ts", "**/*.spec.ts", "**/*.test.ts"],
+  "include": ["**/*.ts"]
+}

package/tsconfig.spec.json

@@ -0,0 +1,20 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../dist/out-tsc",
+    "module": "commonjs",
+    "types": ["jest", "node"]
+  },
+  "include": [
+    "jest.config.ts",
+    "**/*.test.ts",
+    "**/*.spec.ts",
+    "**/*.test.tsx",
+    "**/*.spec.tsx",
+    "**/*.test.js",
+    "**/*.spec.js",
+    "**/*.test.jsx",
+    "**/*.spec.jsx",
+    "**/*.d.ts"
+  ]
+}