@baeta/plugin-graphql 0.1.0 → 0.1.2

package/dist/index.js

@@ -8,6 +8,7 @@ var __export = (target, all) => {
 import { createPluginV1, isMatch } from "@baeta/generator-sdk";
 
 // lib/codegen.ts
+import { join as join2 } from "@baeta/util-path";
 import { codegen as gqlCodegen } from "@graphql-codegen/core";
 import { normalizeConfig, normalizeInstanceOrArray } from "@graphql-codegen/plugin-helpers";
 import * as typescriptPlugin from "@graphql-codegen/typescript";
@@ -29,17 +30,10 @@ function createCache() {
 
 // utils/load.ts
 import { getCachedDocumentNodeFromSchema as getCachedDocumentNodeFromSchema2 } from "@graphql-codegen/plugin-helpers";
-import { ApolloEngineLoader } from "@graphql-tools/apollo-engine-loader";
-import { CodeFileLoader } from "@graphql-tools/code-file-loader";
-import { GitLoader } from "@graphql-tools/git-loader";
-import { GithubLoader } from "@graphql-tools/github-loader";
 import { GraphQLFileLoader } from "@graphql-tools/graphql-file-loader";
-import { JsonFileLoader } from "@graphql-tools/json-file-loader";
 import {
   loadSchema as loadSchemaToolkit
 } from "@graphql-tools/load";
-import { PrismaLoader } from "@graphql-tools/prisma-loader";
-import { UrlLoader } from "@graphql-tools/url-loader";
 import { validateSchema } from "graphql";
 
 // utils/hash.ts
@@ -54,18 +48,9 @@ function hashSchema(schema) {
 }
 
 // utils/load.ts
-async function loadSchema(schemaPointerMap, cwd) {
+async function loadSchema(schemaPointerMap, cwd, extraLoaders = []) {
   const outputSchemaAst = await loadSchemaToolkit(schemaPointerMap, {
-    loaders: [
-      new CodeFileLoader(),
-      new GitLoader(),
-      new GithubLoader(),
-      new GraphQLFileLoader(),
-      new JsonFileLoader(),
-      new UrlLoader(),
-      new ApolloEngineLoader(),
-      new PrismaLoader()
-    ],
+    loaders: [new GraphQLFileLoader(), ...extraLoaders],
     cwd,
     includeSources: true
   });
@@ -80,23 +65,52 @@ ${messages}`);
   if (!outputSchemaAst.extensions) {
     outputSchemaAst.extensions = {};
   }
-  outputSchemaAst.extensions["hash"] = hashSchema(outputSchemaAst);
+  outputSchemaAst.extensions.hash = hashSchema(outputSchemaAst);
   return {
     outputSchemaAst,
     outputSchema: getCachedDocumentNodeFromSchema2(outputSchemaAst)
   };
 }
 
+// utils/scalars.ts
+import { dirname, isAbsolute, joinSafe, relative } from "@baeta/util-path";
+import { parseMapper } from "@graphql-codegen/visitor-plugin-common";
+function buildScalarMap(map, cwd, typesPath) {
+  if (!map) {
+    return {};
+  }
+  const fixedMap = {};
+  for (const key in map) {
+    const mapped = parseMapper(map[key]);
+    if (!mapped.isExternal) {
+      fixedMap[key] = map[key];
+      continue;
+    }
+    if (isAbsolute(mapped.source)) {
+      fixedMap[key] = map[key];
+      continue;
+    }
+    const scalarPath = joinSafe(cwd, mapped.source);
+    const relativePath = relative(dirname(typesPath), scalarPath);
+    if (mapped.default) {
+      fixedMap[key] = `${relativePath}#default`;
+      continue;
+    }
+    fixedMap[key] = `${relativePath}#${mapped.import}`;
+  }
+  return fixedMap;
+}
+
 // lib/context/index.ts
 var context_exports = {};
 __export(context_exports, {
   default: () => context_default,
   plugin: () => plugin
 });
-import { buildMapperImport, parseMapper } from "@graphql-codegen/visitor-plugin-common";
+import { buildMapperImport, parseMapper as parseMapper2 } from "@graphql-codegen/visitor-plugin-common";
 var plugin = async (schema, documents, config) => {
   const prepend = [];
-  const mapper = parseMapper(config.contextType || "any");
+  const mapper = parseMapper2(config.contextType || "any");
   if (mapper.isExternal && mapper.source) {
     const identifier = mapper.default ? "ContextType" : `${mapper.import} as ContextType`;
     const result = buildMapperImport(
@@ -124,7 +138,7 @@ var plugin = async (schema, documents, config) => {
 var context_default = { plugin };
 
 // lib/modules/index.ts
-import { join, relative, resolve } from "@baeta/util-path";
+import { basename, join, relative as relative2, resolve } from "@baeta/util-path";
 import { BaseVisitor, getConfigValue } from "@graphql-codegen/visitor-plugin-common";
 import {
   concatAST,
@@ -134,19 +148,61 @@ import {
 // lib/modules/builder.ts
 import { pascalCase } from "change-case-all";
 import {
-  Kind as Kind2,
+  Kind as Kind3,
   isInterfaceType,
   isScalarType,
   isUnionType,
   visit
 } from "graphql";
 
+// lib/modules/hashes.ts
+import {
+  Kind
+} from "graphql";
+import hash from "murmurhash";
+function getObjectTypeHash(node) {
+  const fieldNames = buildFieldsNames(node.fields);
+  const typeFields = fieldNames.map(([fieldName, fieldType]) => `${fieldName}:${fieldType}`).join(",");
+  const fieldMap = {};
+  for (const [fieldName, fieldType] of fieldNames) {
+    fieldMap[fieldName] = hash.v3(fieldType).toString(36);
+  }
+  return {
+    hash: hash.v3(typeFields).toString(36),
+    fieldsHashes: fieldMap
+  };
+}
+function buildFieldsNames(fields = []) {
+  if (fields.length === 0) {
+    return [];
+  }
+  const fieldsNames = [];
+  for (const field of fields) {
+    const fieldName = field.name.value;
+    const fieldType = buildTypeName(field.type);
+    fieldsNames.push([fieldName, fieldType]);
+  }
+  return fieldsNames.sort(([a], [b]) => a.localeCompare(b));
+}
+function buildTypeName(node) {
+  if (node.kind === Kind.NAMED_TYPE) {
+    return node.name.value;
+  }
+  if (node.kind === Kind.LIST_TYPE) {
+    return `[${buildTypeName(node.type)}]`;
+  }
+  if (node.kind === Kind.NON_NULL_TYPE) {
+    return `${buildTypeName(node.type)}!`;
+  }
+  return "";
+}
+
 // lib/modules/utils.ts
 import { platform } from "node:os";
 import { getBaseType } from "@graphql-codegen/plugin-helpers";
 import { DEFAULT_SCALARS, wrapTypeWithModifiers } from "@graphql-codegen/visitor-plugin-common";
 import {
-  Kind
+  Kind as Kind2
 } from "graphql";
 import parse from "parse-filepath";
 var sep = "/";
@@ -159,7 +215,7 @@ function collectUsedTypes(doc) {
     pushUnique(used, type);
   }
   function findRelated(node) {
-    if (node.kind === Kind.OBJECT_TYPE_DEFINITION || node.kind === Kind.OBJECT_TYPE_EXTENSION) {
+    if (node.kind === Kind2.OBJECT_TYPE_DEFINITION || node.kind === Kind2.OBJECT_TYPE_EXTENSION) {
       markAsUsed(node.name.value);
       if (node.fields) {
         for (const field of node.fields) {
@@ -171,14 +227,14 @@ function collectUsedTypes(doc) {
           findRelated(_interface);
         }
       }
-    } else if (node.kind === Kind.INPUT_OBJECT_TYPE_DEFINITION || node.kind === Kind.INPUT_OBJECT_TYPE_EXTENSION) {
+    } else if (node.kind === Kind2.INPUT_OBJECT_TYPE_DEFINITION || node.kind === Kind2.INPUT_OBJECT_TYPE_EXTENSION) {
       markAsUsed(node.name.value);
       if (node.fields) {
         for (const field of node.fields) {
           findRelated(field);
         }
       }
-    } else if (node.kind === Kind.INTERFACE_TYPE_DEFINITION || node.kind === Kind.INTERFACE_TYPE_EXTENSION) {
+    } else if (node.kind === Kind2.INTERFACE_TYPE_DEFINITION || node.kind === Kind2.INTERFACE_TYPE_EXTENSION) {
       markAsUsed(node.name.value);
       if (node.fields) {
         for (const field of node.fields) {
@@ -190,29 +246,29 @@ function collectUsedTypes(doc) {
           findRelated(_interface);
         }
       }
-    } else if (node.kind === Kind.UNION_TYPE_DEFINITION || node.kind === Kind.UNION_TYPE_EXTENSION) {
+    } else if (node.kind === Kind2.UNION_TYPE_DEFINITION || node.kind === Kind2.UNION_TYPE_EXTENSION) {
       markAsUsed(node.name.value);
       if (node.types) {
         for (const type of node.types) {
           findRelated(type);
         }
       }
-    } else if (node.kind === Kind.ENUM_TYPE_DEFINITION || node.kind === Kind.ENUM_TYPE_EXTENSION) {
+    } else if (node.kind === Kind2.ENUM_TYPE_DEFINITION || node.kind === Kind2.ENUM_TYPE_EXTENSION) {
       markAsUsed(node.name.value);
-    } else if (node.kind === Kind.SCALAR_TYPE_DEFINITION || node.kind === Kind.SCALAR_TYPE_EXTENSION) {
+    } else if (node.kind === Kind2.SCALAR_TYPE_DEFINITION || node.kind === Kind2.SCALAR_TYPE_EXTENSION) {
       if (!isGraphQLPrimitive(node.name.value)) {
         markAsUsed(node.name.value);
       }
-    } else if (node.kind === Kind.INPUT_VALUE_DEFINITION) {
+    } else if (node.kind === Kind2.INPUT_VALUE_DEFINITION) {
       findRelated(resolveTypeNode(node.type));
-    } else if (node.kind === Kind.FIELD_DEFINITION) {
+    } else if (node.kind === Kind2.FIELD_DEFINITION) {
       findRelated(resolveTypeNode(node.type));
       if (node.arguments) {
         for (const argument of node.arguments) {
           findRelated(argument);
         }
       }
-    } else if (node.kind === Kind.NAMED_TYPE && // Named type
+    } else if (node.kind === Kind2.NAMED_TYPE && // Named type
     !isGraphQLPrimitive(node.name.value)) {
       markAsUsed(node.name.value);
     }
@@ -256,7 +312,7 @@ function collectObjectFieldTypesAndArguments(schema) {
   }
   const schemaTypes = schema.getTypeMap();
   for (const type of Object.values(schemaTypes)) {
-    if (type.astNode?.kind !== Kind.OBJECT_TYPE_DEFINITION) {
+    if (type.astNode?.kind !== Kind2.OBJECT_TYPE_DEFINITION) {
       continue;
     }
     const schemaType = schemaTypes[type.name];
@@ -269,10 +325,10 @@ function collectObjectFieldTypesAndArguments(schema) {
   return { fieldTypes, fieldArguments };
 }
 function resolveTypeNode(node) {
-  if (node.kind === Kind.LIST_TYPE) {
+  if (node.kind === Kind2.LIST_TYPE) {
     return resolveTypeNode(node.type);
   }
-  if (node.kind === Kind.NON_NULL_TYPE) {
+  if (node.kind === Kind2.NON_NULL_TYPE) {
     return resolveTypeNode(node.type);
   }
   return node;
@@ -392,6 +448,7 @@ function buildModule(name, doc, {
   );
   const defined = createObject(registryKeys, () => []);
   const extended = createObject(registryKeys, () => []);
+  const hashes = {};
   const usedTypes = collectUsedTypes(doc);
   visit(doc, {
     ObjectTypeDefinition(node) {
@@ -438,7 +495,7 @@ function buildModule(name, doc, {
   );
   const imports = [
     `import * as ${importNamespace} from "${importPath}";`,
-    'import { DocumentNode } from "graphql";',
+    'import type { DocumentNode } from "graphql";',
     'import * as Baeta from "@baeta/core/sdk";'
   ];
   if (extensionsPath) {
@@ -472,6 +529,7 @@ ${shouldDeclare ? `${indent(2)(imports.join("\n"))}
     return `export namespace ModuleMetadata {
   export const id = '${name}';
   export const dirname = './${name}';
+  export const hashes = ${JSON.stringify(hashes)};
   export const typedef = ${JSON.stringify(doc)} as unknown as DocumentNode;
   ${printBaetaManager()}
 }`;
@@ -716,31 +774,32 @@ ${body}
   function collectTypeDefinition(node) {
     const name2 = node.name.value;
     switch (node.kind) {
-      case Kind2.OBJECT_TYPE_DEFINITION: {
+      case Kind3.OBJECT_TYPE_DEFINITION: {
         defined.objects.push(name2);
         collectFields(node, picks.objects);
+        hashes[name2] = getObjectTypeHash(node);
         break;
       }
-      case Kind2.ENUM_TYPE_DEFINITION: {
+      case Kind3.ENUM_TYPE_DEFINITION: {
         defined.enums.push(name2);
         collectValuesFromEnum(node);
         break;
       }
-      case Kind2.INPUT_OBJECT_TYPE_DEFINITION: {
+      case Kind3.INPUT_OBJECT_TYPE_DEFINITION: {
         defined.inputs.push(name2);
         collectFields(node, picks.inputs);
         break;
       }
-      case Kind2.SCALAR_TYPE_DEFINITION: {
+      case Kind3.SCALAR_TYPE_DEFINITION: {
         defined.scalars.push(name2);
         break;
       }
-      case Kind2.INTERFACE_TYPE_DEFINITION: {
+      case Kind3.INTERFACE_TYPE_DEFINITION: {
         defined.interfaces.push(name2);
         collectFields(node, picks.interfaces);
         break;
       }
-      case Kind2.UNION_TYPE_DEFINITION: {
+      case Kind3.UNION_TYPE_DEFINITION: {
         defined.unions.push(name2);
         collectUnionTypes(node);
         break;
@@ -750,8 +809,9 @@ ${body}
   function collectTypeExtension(node) {
     const name2 = node.name.value;
     switch (node.kind) {
-      case Kind2.OBJECT_TYPE_EXTENSION: {
+      case Kind3.OBJECT_TYPE_EXTENSION: {
         collectFields(node, picks.objects);
+        hashes[name2] = getObjectTypeHash(node);
         if (rootTypes.includes(name2)) {
           pushUnique(defined.objects, name2);
           return;
@@ -759,22 +819,22 @@ ${body}
         pushUnique(extended.objects, name2);
         break;
       }
-      case Kind2.ENUM_TYPE_EXTENSION: {
+      case Kind3.ENUM_TYPE_EXTENSION: {
         collectValuesFromEnum(node);
         pushUnique(extended.enums, name2);
         break;
       }
-      case Kind2.INPUT_OBJECT_TYPE_EXTENSION: {
+      case Kind3.INPUT_OBJECT_TYPE_EXTENSION: {
         collectFields(node, picks.inputs);
         pushUnique(extended.inputs, name2);
         break;
       }
-      case Kind2.INTERFACE_TYPE_EXTENSION: {
+      case Kind3.INTERFACE_TYPE_EXTENSION: {
         collectFields(node, picks.interfaces);
         pushUnique(extended.interfaces, name2);
         break;
       }
-      case Kind2.UNION_TYPE_EXTENSION: {
+      case Kind3.UNION_TYPE_EXTENSION: {
         pushUnique(extended.unions, name2);
         break;
       }
@@ -782,17 +842,17 @@ ${body}
   }
   function getParentType(type) {
     if (["Query", "Mutation", "Subscription"].includes(type)) {
-      return "{}";
+      return "{ }";
     }
     return type;
   }
   function getResultType(type, field) {
-    return fieldTypes?.[type]?.[field] || "{}";
+    return fieldTypes?.[type]?.[field] || "{ }";
   }
   function getArgsType(type, field) {
     const hasArgs = fieldArguments?.[type]?.[field] ?? false;
     if (!hasArgs) {
-      return "{}";
+      return "{ }";
     }
     const fieldUpper = field[0].toUpperCase() + field.slice(1);
     return `Types.${type}${fieldUpper}Args`;
@@ -806,7 +866,7 @@ ${body}
 var preset = {
   buildGeneratesSection: (options) => {
     const { baseOutputDir } = options;
-    const { baseTypesPath, extensionsPath, encapsulateModuleTypes } = options.presetConfig;
+    const { baseTypesPath, extensionsPath, encapsulateModuleTypes, importExtension } = options.presetConfig;
     const requireRootResolvers = getConfigValue(options?.presetConfig.requireRootResolvers, false);
     const cwd = resolve(options.presetConfig.cwd || process.cwd());
     const importTypesNamespace = options.presetConfig.importTypesNamespace || "Types";
@@ -973,12 +1033,12 @@ ${result}
       },
       schemaAst: options.schemaAst
     };
-    const baseTypesFilename = baseTypesPath.replace(/\.(js|ts|d.ts)$/, "");
+    const baseTypesFilename = basename(baseTypesPath).replace(/\.(js|ts|d.ts)$/, "") + (importExtension || "");
     const baseTypesDir = stripFilename(baseOutput.filename);
     const outputs = modules.map((moduleName) => {
       const filename = resolve(cwd, baseOutputDir, moduleName, options.presetConfig.filename);
       const dirpath = stripFilename(filename);
-      const relativePath = relative(dirpath, baseTypesDir);
+      const relativePath = relative2(dirpath, baseTypesDir);
       const importPath = options.presetConfig.importBaseTypesFrom || normalize(join(relativePath, baseTypesFilename));
       const sources2 = sourcesByModuleMap[moduleName];
       const documents = sources2.map((source) => source.document);
@@ -1049,9 +1109,9 @@ async function generate(options) {
       Object.assign(schemaPointerMap, ptr);
     }
   }
-  const hash = JSON.stringify(schemaPointerMap);
-  const result = await cache("schema", hash, async () => {
-    return loadSchema(schemaPointerMap, options.cwd);
+  const hash2 = JSON.stringify(schemaPointerMap);
+  const result = await cache("schema", hash2, async () => {
+    return loadSchema(schemaPointerMap, options.cwd, options.loaders);
   });
   const outputs = await preset.buildGeneratesSection({
     baseOutputDir: options.modulesDir,
@@ -1059,7 +1119,8 @@ async function generate(options) {
       baseTypesPath: rootConfig.baseTypesPath,
       filename: rootConfig.moduleDefinitionName,
       encapsulateModuleTypes: "none",
-      extensionsPath: options.extensions
+      extensionsPath: options.extensions,
+      importExtension: options.importExtension
     },
     schema: result.outputSchema,
     schemaAst: result.outputSchemaAst,
@@ -1070,9 +1131,11 @@ async function generate(options) {
       inputMaybeValue: "T | undefined",
       contextType: rootConfig.contextType,
       useTypeImports: true,
-      scalars: {
-        ...rootConfig.scalars
-      }
+      scalars: buildScalarMap(
+        rootConfig.scalars,
+        options.cwd,
+        join2(options.modulesDir, options.baseTypesPath)
+      )
     }
   });
   const promises = outputs.map(async (output) => {