@eddeee888/gcg-typescript-resolver-files 0.18.0 → 0.18.2

package/src/getGraphQLObjectTypeResolversToGenerate/getGraphQLObjectTypeResolversToGenerate.ts

@@ -1,361 +0,0 @@
-import {
-  type InterfaceDeclaration,
-  type TypeAliasDeclaration,
-  type ClassDeclaration,
-  type ExportSpecifier,
-  type SourceFile,
-  type Project,
-  type Identifier,
-  SyntaxKind,
-  Node,
-} from 'ts-morph';
-import type {
-  TypeMapperDetails,
-  TypeMappersMap,
-} from '../parseTypeMappers/index.js';
-import {
-  type NodePropertyMap,
-  getNodePropertyMap,
-} from './getNodePropertyMap.js';
-import type { ParsedGraphQLSchemaMeta } from '../parseGraphQLSchema/index.js';
-import type { GeneratedTypesFileMeta } from '../generateResolverFiles/index.js';
-
-export type GraphQLObjectTypeResolversToGenerate = Record<
-  string,
-  Record<string, { resolverName: string; resolverDeclaration: string }>
->;
-
-export const getGraphQLObjectTypeResolversToGenerate = ({
-  mode,
-  tsMorphProject,
-  typesSourceFile,
-  typeMappersMap,
-  userDefinedSchemaObjectTypeMap,
-  generatedTypesFileMeta,
-}: {
-  mode: 'smart' | 'fast';
-  tsMorphProject: Project;
-  typesSourceFile: SourceFile;
-  typeMappersMap: TypeMappersMap;
-  userDefinedSchemaObjectTypeMap: ParsedGraphQLSchemaMeta['userDefinedSchemaTypeMap']['object'];
-  generatedTypesFileMeta: GeneratedTypesFileMeta;
-}): GraphQLObjectTypeResolversToGenerate => {
-  const typeMappersEntries = Object.entries(typeMappersMap);
-  if (typeMappersEntries.length === 0) {
-    return {};
-  }
-
-  /**
-   * `generatedTypesFileMeta.generatedResolverTypes.userDefined` is `schemaType` -> `generatedResolverTypes`
-   * We will be parsing `types.generated.ts` file for the `generatedResolverTypes`
-   * So, we need to invert `generatedTypesFileMeta.generatedResolverTypes.userDefined` to get `generatedResolverTypes` -> `schemaType`
-   * e.g.
-   *
-   * generatedTypesFileMeta.generatedResolverTypes.userDefined = {
-   *   User: {
-   *     name: 'UserResolvers'
-   *   }
-   * }
-   *
-   * after transformation:
-   *
-   * generatedSchemaTypeNameMap = {
-   *   UserResolvers: 'User'
-   * }
-   */
-  const generatedSchemaTypeNameMap = Object.entries(
-    generatedTypesFileMeta.generatedResolverTypes.userDefined
-  ).reduce<Record<string, string>>(
-    (res, [schemaType, generatedSchemaTypeName]) => {
-      res[generatedSchemaTypeName.name] = schemaType;
-      return res;
-    },
-    {}
-  );
-
-  if (mode === 'fast') {
-    // 1. Get property map of all schema types
-    const resolverTypesMap: Record<
-      string, // Schema type
-      { node: Node; properties: NodePropertyMap }
-    > = {};
-
-    const syntaxList = typesSourceFile.getChildAtIndex(0); // Assumption: There is a root node in this file that contain all exports
-    if (!syntaxList) {
-      throw new Error(
-        `Root node of generated types file doesn't exist. This likely means the file is empty. This shouldn't happen.`
-      );
-    }
-    // Assumption: All resolvers exports are 1 level below root node i.e. we can use syntaxList.getChildren()
-    for (const node of syntaxList.getChildren()) {
-      if (
-        node.isKind(SyntaxKind.TypeAliasDeclaration) ||
-        node.isKind(SyntaxKind.InterfaceDeclaration)
-      ) {
-        const identifierName = node.getNameNode().getText(); // e.g. UserResolvers, BookResolvers
-        const schemaType = generatedSchemaTypeNameMap[identifierName]; // schemaType examples: User, Book
-
-        if (schemaType && typeMappersMap[schemaType]) {
-          resolverTypesMap[schemaType] = {
-            node,
-            properties: getNodePropertyMap({ node }),
-          };
-        }
-      }
-    }
-
-    // 3. Find resolvers to generate and add reason
-    const result: GraphQLObjectTypeResolversToGenerate = {};
-    typeMappersEntries.forEach(([_, { schemaType, mapper }]) => {
-      const resolverType = resolverTypesMap[schemaType];
-      if (!resolverType) {
-        return;
-      }
-
-      const mapperOriginalDeclarationNode =
-        mustGetMapperOriginalDeclarationNode({
-          tsMorphProject,
-          mapper,
-        });
-      const mapperPropsMap = getNodePropertyMap({
-        node: mapperOriginalDeclarationNode,
-      });
-
-      Object.values(resolverType.properties).forEach((resolverTypeProp) => {
-        result[schemaType] = result[schemaType] || {};
-        const resolverTypePropName = resolverTypeProp.name;
-
-        const mapperPropIdentifier = `${mapper.name}.${resolverTypePropName}`;
-        const schemaTypePropIdentifier = `${schemaType}.${resolverTypePropName}`;
-
-        // 1. Generated resolvers types may have one or more of these meta resolvers
-        // A mapper would most likely never have these resolvers, so we skip them
-        // Otherwise, these resolvers will always be generated
-        const metaResolvers: Record<string, boolean> = {
-          __isTypeOf: true,
-          __resolveReference: true,
-        };
-        if (metaResolvers[resolverTypePropName]) {
-          return;
-        }
-
-        const mapperProp = mapperPropsMap[resolverTypePropName];
-        // 2. If mapper does not have a field in resolver type, add missing resolver
-        if (!mapperProp) {
-          result[schemaType][resolverTypePropName] = {
-            resolverName: resolverTypePropName,
-            resolverDeclaration: `async (_parent, _arg, _ctx) => { /* ${schemaTypePropIdentifier} resolver is required because ${schemaTypePropIdentifier} exists but ${mapperPropIdentifier} does not */ }`,
-          };
-          return;
-        }
-
-        // 3. If mapper and resolver props have the same name, compare their types
-        const sourceType = mapperProp.type;
-
-        // A resolver type may look like this:
-        // `book?: Resolver<Maybe<ResolversTypes['Book']>, ParentType, ContextType>;`
-        const targetType = resolverTypeProp.type // type is `Resolver<Maybe<ResolversTypes['Book']>, ParentType, ContextType> | undefined` because book resolver is optional
-          .getNonNullableType() // removing nullable, it becomes `Resolver<Maybe<ResolversTypes['Book']>, ParentType, ContextType>`
-          .getAliasTypeArguments()[0]; // first type argument is `Maybe<ResolversTypes['Book']>`
-
-        if (sourceType.isAssignableTo(targetType)) {
-          return;
-        }
-
-        result[schemaType][resolverTypePropName] = {
-          resolverName: resolverTypePropName,
-          resolverDeclaration: `({ ${resolverTypePropName} }, _arg, _ctx) => {
-                /* ${schemaTypePropIdentifier} resolver is required because ${schemaTypePropIdentifier} and ${mapperPropIdentifier} are not compatible */
-                return ${resolverTypePropName}
-              }`,
-        };
-      });
-    });
-
-    return result;
-  }
-
-  // 1. Get property map of all schema types
-  const schemaResolversTypePropertyMap: Record<string, NodePropertyMap> = {};
-
-  const populateSchemaTypeResolversPropertyMap = (
-    node: TypeAliasDeclaration | InterfaceDeclaration
-  ): void => {
-    const identifier = node.getNameNode();
-    const identifierName = identifier.getText();
-
-    const schemaType = generatedSchemaTypeNameMap[identifierName];
-
-    if (schemaType && userDefinedSchemaObjectTypeMap[schemaType]) {
-      schemaResolversTypePropertyMap[schemaType] = getNodePropertyMap({ node });
-    }
-  };
-  typesSourceFile
-    .getDescendantsOfKind(SyntaxKind.TypeAliasDeclaration)
-    .forEach(populateSchemaTypeResolversPropertyMap);
-
-  typesSourceFile
-    .getDescendantsOfKind(SyntaxKind.InterfaceDeclaration)
-    .forEach(populateSchemaTypeResolversPropertyMap);
-
-  // 3. Find resolvers to generate and add reason
-  const result: GraphQLObjectTypeResolversToGenerate = {};
-  typeMappersEntries.forEach(([_, { schemaType, mapper }]) => {
-    const matchedSchemaTypePropertyMap =
-      schemaResolversTypePropertyMap[schemaType];
-    if (!matchedSchemaTypePropertyMap) {
-      return;
-    }
-
-    const originalDeclarationNode = mustGetMapperOriginalDeclarationNode({
-      tsMorphProject,
-      mapper,
-    });
-    const typeMapperPropertyMap = getNodePropertyMap({
-      node: originalDeclarationNode,
-    });
-
-    Object.values(matchedSchemaTypePropertyMap).forEach(
-      (schemaTypeProperty) => {
-        const typeMapperProperty =
-          typeMapperPropertyMap[schemaTypeProperty.name];
-
-        const typeMapperPropertyIdentifier = `${mapper.name}.${schemaTypeProperty.name}`;
-        const schemaTypePropertyIdentifier = `${schemaType}.${schemaTypeProperty.name}`;
-
-        // Generated resolvers types may have one or more of these meta resolvers
-        // A mapper would most likely never have these resolvers, so we skip them
-        // Otherwise, these resolvers will always be generated
-        const metaResolvers: Record<string, boolean> = {
-          __isTypeOf: true,
-          __resolveReference: true,
-        };
-
-        if (metaResolvers[schemaTypeProperty.name]) {
-          return;
-        }
-
-        result[schemaType] = result[schemaType] || {};
-
-        // If mapper does not have a field in schema type, add missing resolver
-        if (!typeMapperProperty) {
-          result[schemaType][schemaTypeProperty.name] = {
-            resolverName: schemaTypeProperty.name,
-            resolverDeclaration: `async (_parent, _arg, _ctx) => { /* ${schemaTypePropertyIdentifier} resolver is required because ${schemaTypePropertyIdentifier} exists but ${typeMapperPropertyIdentifier} does not */ }`,
-          };
-          return;
-        }
-
-        /**
-         * FIXME: TypeScript's `isTypeAssignableTo` should be used to check if the mapper type vs resolver return type is compatible.
-         * The current challenge is to:
-         * - Switch from using the schema type to resolver return type e.g. `User` -> `UserResolver`
-         * - Take the ReturnType of the resolver function type e.g. `Resolver<ResolversTypes['UserRole'], ParentType, ContextType>`
-         *
-         * For now, the workaround now is to generate all resolvers with matching names,
-         * then use TS diagnostics to see if there's error when trying to merge the two keys.
-         *
-         * Note: this happens only when mappers are used
-         */
-        result[schemaType][schemaTypeProperty.name] = {
-          resolverName: schemaTypeProperty.name,
-          resolverDeclaration: `({ ${schemaTypeProperty.name} }, _arg, _ctx) => {
-                /* ${schemaTypePropertyIdentifier} resolver is required because ${schemaTypePropertyIdentifier} and ${typeMapperPropertyIdentifier} are not compatible */
-                return ${schemaTypeProperty.name}
-              }`,
-        };
-
-        return;
-      }
-    );
-  });
-
-  return result;
-};
-
-const mustGetMapperOriginalDeclarationNode = ({
-  tsMorphProject,
-  mapper,
-}: {
-  tsMorphProject: Project;
-  mapper: TypeMapperDetails['mapper'];
-}): Node => {
-  const typeMapperFile = tsMorphProject.getSourceFile(mapper.filename);
-  if (!typeMapperFile) {
-    throw new Error(
-      `Unable to find ${typeMapperFile} file after parsing. This shouldn't happen.`
-    );
-  }
-
-  /**
-   * Finding `firstDescendantThatIsMapper` here is a bit of the duplicated traversing logic in `collectTypeMappersFromSourceFile`.
-   * However, in `collectTypeMappersFromSourceFile`, we find the mappers details.
-   * And here, we actually do look for the mapper nodes and run analysis on it.
-   *
-   * Previously, we were parsing the node property map in `collectTypeMappersFromSourceFile`
-   * but for some reason `isAssignableTo` has issue comparing types, so we have to move the static analysis here for now.
-   */
-  const firstDescendantThatIsMapper = (():
-    | GetOriginalDeclarationNodeParams
-    | undefined => {
-    for (const descendant of typeMapperFile.getDescendants()) {
-      const typedNode = descendant.isKind(mapper.kind);
-      if (typedNode) {
-        let identifierNode = descendant.getNameNode();
-        if (descendant.isKind(SyntaxKind.ExportSpecifier)) {
-          const aliasNode = descendant.getAliasNode();
-          if (aliasNode) {
-            identifierNode = aliasNode;
-          }
-        }
-
-        if (identifierNode?.getText() === mapper.name) {
-          return {
-            declarationNode: descendant,
-            identifierNode,
-          };
-        }
-      }
-    }
-    return;
-  })();
-
-  if (!firstDescendantThatIsMapper) {
-    throw new Error(
-      `Unable to find ${mapper.name} node after parsing. This shouldn't happen.`
-    );
-  }
-
-  return getOriginalDeclarationNode(firstDescendantThatIsMapper);
-};
-
-interface GetOriginalDeclarationNodeParams {
-  declarationNode:
-    | InterfaceDeclaration
-    | TypeAliasDeclaration
-    | ExportSpecifier
-    | ClassDeclaration;
-  identifierNode: Identifier;
-}
-const getOriginalDeclarationNode = ({
-  declarationNode,
-  identifierNode,
-}: GetOriginalDeclarationNodeParams): Node => {
-  if (
-    declarationNode.isKind(SyntaxKind.ExportSpecifier) ||
-    declarationNode.isKind(SyntaxKind.ClassDeclaration)
-  ) {
-    return identifierNode.getDefinitionNodes()[0];
-  }
-
-  // InterfaceDeclaration
-  if (declarationNode.isKind(SyntaxKind.InterfaceDeclaration)) {
-    return declarationNode;
-  }
-
-  // TypeAliasDeclaration
-  const typeNode = declarationNode.getTypeNodeOrThrow();
-  return Node.isTypeReference(typeNode)
-    ? identifierNode.getDefinitionNodes()[0] // If type alias is a reference, go to definition using `getDefinitionNodes`
-    : declarationNode;
-};

package/src/getGraphQLObjectTypeResolversToGenerate/getNodePropertyMap.spec.ts

@@ -1,115 +0,0 @@
-import { Project, Node } from 'ts-morph';
-import { getNodePropertyMap } from './getNodePropertyMap.js';
-
-describe('getNodePropertyMap', () => {
-  it('correctly resolves property map of a typical types.generated.ts', () => {
-    const project = new Project();
-    const sourceFile = project.createSourceFile(
-      '/path/to/types.generated.ts',
-      `
-      export type Maybe<T> = T | null;
-      export type Scalars = {
-        ID: { input: string; output: string; }
-        String: { input: string; output: string; }
-        Boolean: { input: boolean; output: boolean; }
-        Int: { input: number; output: number; }
-        Float: { input: number; output: number; }
-        DateTime: { input: Date; output: Date | string | number; }
-      };
-      export type User = {
-        __typename: 'User';
-        accountGitHub?: Maybe<Scalars['String']['output']>;
-        accountGoogle?: Maybe<Scalars['String']['output']>;
-        createdAt: Scalars['DateTime']['output'];
-        fullName: Scalars['String']['output'];
-        id: Scalars['ID']['output'];
-        role: UserRole;
-      };
-      export type UserRole = 'ADMIN' | 'USER';`
-    );
-
-    const userDeclarationNode = sourceFile.getFirstDescendant(
-      (node) => Node.isTypeAliasDeclaration(node) && node.getName() === 'User'
-    );
-
-    const nodePropertyMap = getNodePropertyMap({ node: userDeclarationNode });
-
-    expect(nodePropertyMap.__typename.name).toBe('__typename');
-
-    expect(nodePropertyMap.accountGitHub.name).toBe('accountGitHub');
-
-    expect(nodePropertyMap.accountGoogle.name).toBe('accountGoogle');
-
-    expect(nodePropertyMap.createdAt.name).toBe('createdAt');
-
-    expect(nodePropertyMap.fullName.name).toBe('fullName');
-
-    expect(nodePropertyMap.id.name).toBe('id');
-
-    expect(nodePropertyMap.role.name).toBe('role');
-  });
-
-  it('correctly resolves property map a class', () => {
-    const project = new Project();
-    const sourceFile = project.createSourceFile(
-      '/path/to/types.ts',
-      `
-      export type UserRole = 'ADMIN' | 'USER';
-      export class User {
-        #_id: string;
-        private word: string;
-        protected word2: string;
-        
-        name: string;
-        role: UserRole;
-
-        get id(): string {
-          return this.#_id;
-        }
-      }`
-    );
-
-    const userDeclarationNode = sourceFile.getFirstDescendant(
-      (node) => Node.isClassDeclaration(node) && node.getName() === 'User'
-    );
-
-    const nodePropertyMap = getNodePropertyMap({ node: userDeclarationNode });
-
-    expect(nodePropertyMap._id).toBe(undefined);
-    expect(nodePropertyMap.id).toBe(undefined);
-    expect(nodePropertyMap.word).toBe(undefined);
-    expect(nodePropertyMap.word2).toBe(undefined);
-
-    expect(nodePropertyMap.name.name).toBe('name');
-
-    expect(nodePropertyMap.role.name).toBe('role');
-  });
-
-  it('correctly resolves property map a type alias mapper', () => {
-    const project = new Project();
-    const sourceFile = project.createSourceFile(
-      '/path/to/mappers.ts',
-      `
-      type UserRole = 'Admin' | 'User';
-      export type UserMapper = {
-        id: number;
-        name: string;
-        role: UserRole;
-      }`
-    );
-
-    const node = sourceFile.getFirstDescendant(
-      (descendant) =>
-        Node.isTypeAliasDeclaration(descendant) &&
-        descendant.getName() === 'UserMapper'
-    );
-
-    const nodePropertyMap = getNodePropertyMap({ node });
-
-    expect(nodePropertyMap.id.name).toBe('id');
-
-    expect(nodePropertyMap.name.name).toBe('name');
-
-    expect(nodePropertyMap.role.name).toBe('role');
-  });
-});

package/src/getGraphQLObjectTypeResolversToGenerate/getNodePropertyMap.ts

@@ -1,88 +0,0 @@
-import {
-  type ClassDeclaration,
-  type Node,
-  type Type,
-  SyntaxKind,
-} from 'ts-morph';
-
-type NodePropertyMapValue = {
-  name: string;
-  type: Type;
-};
-export type NodePropertyMap = Record<string, NodePropertyMapValue>;
-
-/**
- * Function to get properties of a Node in a map
- * If unable to find, returns empty object
- */
-export const getNodePropertyMap = ({
-  node,
-}: {
-  node: Node | undefined;
-}): NodePropertyMap => {
-  if (!node) {
-    return {};
-  }
-
-  const properties = ((): NodePropertyMapValue[] => {
-    if (node.isKind(SyntaxKind.ClassDeclaration)) {
-      const result: NodePropertyMapValue[] = [];
-      collectClassNodeProperties(node, result);
-      return result;
-    }
-
-    return node
-      .getType()
-      .getProperties()
-      .map((prop) => {
-        return {
-          name: prop.getName(),
-          type: prop.getTypeAtLocation(node),
-        };
-      });
-  })();
-
-  const nodePropertyMap = properties.reduce<NodePropertyMap>(
-    (res, { name, type }) => {
-      res[name] = {
-        name,
-        type,
-      };
-      return res;
-    },
-    {}
-  );
-
-  return nodePropertyMap;
-};
-
-const collectClassNodeProperties = (
-  classNode: ClassDeclaration,
-  result: NodePropertyMapValue[]
-): void => {
-  const baseClass = classNode.getBaseClass();
-  if (baseClass) {
-    collectClassNodeProperties(baseClass, result);
-  }
-
-  classNode.getInstanceProperties().forEach((prop) => {
-    if (
-      prop.hasModifier(SyntaxKind.PrivateKeyword) ||
-      prop.hasModifier(SyntaxKind.ProtectedKeyword)
-    ) {
-      return;
-    }
-    if (prop.getName().startsWith('#')) {
-      // ecma script private field is skipped
-      return;
-    }
-    if (classNode.getGetAccessor(prop.getName())) {
-      // getter is skipped
-      return;
-    }
-    result.push({
-      name: prop.getName(),
-      type: prop.getType(),
-    });
-  });
-};

package/src/getGraphQLObjectTypeResolversToGenerate/index.ts

@@ -1 +0,0 @@
-export * from './getGraphQLObjectTypeResolversToGenerate.js';

package/src/index.ts

@@ -1,3 +0,0 @@
-export { defineConfig as defineServerConfig } from '@eddeee888/gcg-server-config';
-export { preset } from './preset.js';
-export { defineConfig } from './defineConfig.js';

package/src/normalizeAddConfigPath/index.ts

@@ -1 +0,0 @@
-export * from './normalizeAddConfigPath.js';

package/src/normalizeAddConfigPath/normalizeAddConfigPath.ts

@@ -1,29 +0,0 @@
-import * as path from 'path';
-import type { AddPluginConfig } from '@graphql-codegen/add';
-
-/**
- * normalizeAddConfigPath
- *
- * Function to turn the add config keys into normalized path a.k.a. path from baseOutputDir
- * This helps us detects targeted file being given in different formats e.g. './types.generated.ts' vs 'types.generated.ts'
- */
-export const normalizeAddConfigPath = ({
-  add,
-  baseOutputDir,
-}: {
-  add?: Record<string, AddPluginConfig>;
-  baseOutputDir: string;
-}): Record<string, AddPluginConfig> | undefined => {
-  if (!add) {
-    return undefined;
-  }
-
-  const normalizedPathAdd = Object.entries(add).reduce<
-    Record<string, AddPluginConfig>
-  >((res, [originalFilePath, config]) => {
-    res[path.posix.join(baseOutputDir, originalFilePath)] = config;
-    return res;
-  }, {});
-
-  return normalizedPathAdd;
-};

package/src/parseGraphQLSchema/index.ts

@@ -1,2 +0,0 @@
-export * from './parseGraphQLSchema.js';
-export type { NormalizedResolverName } from './normalizeResolverName.js';

package/src/parseGraphQLSchema/normalizeResolverName.ts

@@ -1,28 +0,0 @@
-import type { RootObjectType } from '../utils/index.js';
-
-export interface NormalizedResolverName {
-  base: string;
-  withModule: string;
-}
-
-/**
- * Function to get format resolver name based on its definition in the schema
- * - Root object type resolver e.g Query.me, Mutation.updateUser
- * - Object type e.g. User, Profile
- *
- * Returns an object with 2 key/value pairs:
- *   - base: resolver name without module. This is used by to match up with config.externalResolvers.
- *   - withModule: resolver name with module. This is used to identify the resolver INTERNAL unique path used in main resolver files.
- */
-export const normalizeResolverName = (
-  moduleName: string,
-  name: string,
-  rootObject: RootObjectType | null
-): NormalizedResolverName => {
-  const baseResolverName = !rootObject ? name : `${rootObject}.${name}`;
-
-  return {
-    base: baseResolverName,
-    withModule: `${moduleName}.${baseResolverName}`,
-  };
-};