@baeta/plugin-graphql 0.0.34 → 0.1.1

package/dist/index.js

@@ -29,21 +29,16 @@ 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 {
+  loadSchema as loadSchemaToolkit
+} from "@graphql-tools/load";
 import { validateSchema } from "graphql";
 
 // utils/hash.ts
+import { createHash } from "node:crypto";
 import { getCachedDocumentNodeFromSchema } from "@graphql-codegen/plugin-helpers";
 import { print } from "graphql";
-import { createHash } from "node:crypto";
 function hashContent(content) {
   return createHash("sha256").update(content).digest("hex");
 }
@@ -52,18 +47,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
   });
@@ -78,7 +64,7 @@ ${messages}`);
   if (!outputSchemaAst.extensions) {
     outputSchemaAst.extensions = {};
   }
-  outputSchemaAst.extensions["hash"] = hashSchema(outputSchemaAst);
+  outputSchemaAst.extensions.hash = hashSchema(outputSchemaAst);
   return {
     outputSchemaAst,
     outputSchema: getCachedDocumentNodeFromSchema2(outputSchemaAst)
@@ -132,20 +118,62 @@ import {
 // lib/modules/builder.ts
 import { pascalCase } from "change-case-all";
 import {
+  Kind as Kind3,
   isInterfaceType,
   isScalarType,
   isUnionType,
-  Kind as Kind2,
   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 { platform } from "node:os";
 import parse from "parse-filepath";
 var sep = "/";
 function collectUsedTypes(doc) {
@@ -157,7 +185,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) {
@@ -169,14 +197,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) {
@@ -188,29 +216,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);
     }
@@ -254,7 +282,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];
@@ -267,10 +295,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;
@@ -390,6 +418,7 @@ function buildModule(name, doc, {
   );
   const defined = createObject(registryKeys, () => []);
   const extended = createObject(registryKeys, () => []);
+  const hashes = {};
   const usedTypes = collectUsedTypes(doc);
   visit(doc, {
     ObjectTypeDefinition(node) {
@@ -436,7 +465,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) {
@@ -470,6 +499,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()}
 }`;
@@ -714,31 +744,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;
@@ -748,8 +779,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;
@@ -757,22 +789,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;
       }
@@ -780,17 +812,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`;
@@ -804,7 +836,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";
@@ -971,7 +1003,7 @@ ${result}
       },
       schemaAst: options.schemaAst
     };
-    const baseTypesFilename = baseTypesPath.replace(/\.(js|ts|d.ts)$/, "");
+    const baseTypesFilename = 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);
@@ -1047,9 +1079,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,
@@ -1057,7 +1089,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,