@cedarjs/internal 0.0.4

package/dist/files.js

@@ -0,0 +1,223 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var files_exports = {};
+__export(files_exports, {
+  findApiDistFunctions: () => findApiDistFunctions,
+  findApiFiles: () => findApiFiles,
+  findApiServerFunctions: () => findApiServerFunctions,
+  findCells: () => findCells,
+  findDirectoryNamedModules: () => findDirectoryNamedModules,
+  findGraphQLSchemas: () => findGraphQLSchemas,
+  findPages: () => findPages,
+  findRouteHooksSrc: () => findRouteHooksSrc,
+  findScripts: () => findScripts,
+  findWebFiles: () => findWebFiles,
+  isApiFunction: () => isApiFunction,
+  isCellFile: () => isCellFile,
+  isDirectoryNamedModuleFile: () => isDirectoryNamedModuleFile,
+  isFileInsideFolder: () => isFileInsideFolder,
+  isGraphQLSchemaFile: () => isGraphQLSchemaFile,
+  isPageFile: () => isPageFile
+});
+module.exports = __toCommonJS(files_exports);
+var import_path = __toESM(require("path"));
+var import_fast_glob = __toESM(require("fast-glob"));
+var import_project_config = require("@cedarjs/project-config");
+var import_ast = require("./ast");
+const findCells = (cwd = (0, import_project_config.getPaths)().web.src) => {
+  const modules = import_fast_glob.default.sync("**/*Cell.{js,jsx,ts,tsx}", {
+    cwd,
+    absolute: true,
+    ignore: ["node_modules"]
+  });
+  return modules.filter(isCellFile);
+};
+const findPages = (cwd = (0, import_project_config.getPaths)().web.pages) => {
+  const modules = import_fast_glob.default.sync("**/*Page.{tsx,js,jsx}", {
+    cwd,
+    absolute: true,
+    ignore: ["node_modules"]
+  });
+  return modules.filter(isPageFile);
+};
+const findDirectoryNamedModules = (cwd = (0, import_project_config.getPaths)().base) => {
+  const modules = import_fast_glob.default.sync("(api|web)/src/**/*.{ts,js,jsx,tsx}", {
+    cwd,
+    absolute: true,
+    ignore: ["node_modules"]
+  });
+  return modules.filter(isDirectoryNamedModuleFile).filter((p) => !isCellFile(p));
+};
+const findGraphQLSchemas = (cwd = (0, import_project_config.getPaths)().api.graphql) => {
+  return import_fast_glob.default.sync("**/*.sdl.{ts,js}", { cwd, absolute: true }).filter(isGraphQLSchemaFile);
+};
+const ignoreApiFiles = [
+  "**/*.test.{js,ts}",
+  "**/*.scenarios.{js,ts}",
+  "**/*.fixtures.{js,ts}",
+  "**/*.d.ts"
+];
+const findApiFiles = (cwd = (0, import_project_config.getPaths)().api.src) => {
+  const files = import_fast_glob.default.sync("**/*.{js,ts,jsx,tsx}", {
+    cwd,
+    absolute: true,
+    ignore: ignoreApiFiles
+  });
+  return files;
+};
+const findWebFiles = (cwd = (0, import_project_config.getPaths)().web.src) => {
+  const files = import_fast_glob.default.sync("**/*.{js,ts,jsx,tsx}", {
+    cwd,
+    absolute: true,
+    ignore: [
+      "**/*.test.{js,ts,tsx,jsx}",
+      "**/*.fixtures.{js,ts,tsx,jsx}",
+      "**/*.mock.{js,ts,tsx,jsx}",
+      "**/*.d.ts"
+    ]
+  });
+  return files;
+};
+const findApiServerFunctions = (cwd = (0, import_project_config.getPaths)().api.functions) => {
+  const files = import_fast_glob.default.sync("**/*.{js,ts}", {
+    cwd,
+    absolute: true,
+    deep: 2,
+    // We don't support deeply nested api functions.
+    ignore: ignoreApiFiles
+  });
+  return files.filter((f) => isApiFunction(f, cwd));
+};
+const findApiDistFunctions = (cwd = (0, import_project_config.getPaths)().api.base) => {
+  return import_fast_glob.default.sync("dist/functions/**/*.{ts,js}", {
+    cwd,
+    deep: 2,
+    // We don't support deeply nested api functions, to maximise compatibility with deployment providers
+    absolute: true
+  });
+};
+const findRouteHooksSrc = (cwd = (0, import_project_config.getPaths)().web.src) => {
+  return import_fast_glob.default.sync("**/*.routeHooks.{js,ts,tsx,jsx}", {
+    absolute: true,
+    cwd
+  });
+};
+const isCellFile = (p) => {
+  const { dir, name } = import_path.default.parse(p);
+  if (!isFileInsideFolder(p, (0, import_project_config.getPaths)().web.src)) {
+    return false;
+  }
+  if (!dir.endsWith(name)) {
+    return false;
+  }
+  const ast = (0, import_ast.fileToAst)(p);
+  if ((0, import_ast.hasDefaultExport)(ast)) {
+    return false;
+  }
+  const exports2 = (0, import_ast.getNamedExports)(ast);
+  const exportedQUERY = exports2.findIndex((v) => v.name === "QUERY") !== -1;
+  const exportedSuccess = exports2.findIndex((v) => v.name === "Success") !== -1;
+  if (!exportedQUERY && !exportedSuccess) {
+    return false;
+  }
+  return true;
+};
+const findScripts = (cwd = (0, import_project_config.getPaths)().scripts) => {
+  return import_fast_glob.default.sync("./**/*.{js,jsx,ts,tsx}", {
+    cwd,
+    absolute: true,
+    ignore: ["node_modules"]
+  });
+};
+const isPageFile = (p) => {
+  const { name } = import_path.default.parse(p);
+  if (!name.endsWith("Page")) {
+    return false;
+  }
+  if (!isFileInsideFolder(p, (0, import_project_config.getPaths)().web.pages)) {
+    return false;
+  }
+  const ast = (0, import_ast.fileToAst)(p);
+  if (!(0, import_ast.hasDefaultExport)(ast)) {
+    return false;
+  }
+  return true;
+};
+const isDirectoryNamedModuleFile = (p) => {
+  const { dir, name } = import_path.default.parse(p);
+  return dir.endsWith(name);
+};
+const isGraphQLSchemaFile = (p) => {
+  if (!p.match(/\.sdl\.(ts|js)$/)?.[0]) {
+    return false;
+  }
+  const ast = (0, import_ast.fileToAst)(p);
+  const exports2 = (0, import_ast.getNamedExports)(ast);
+  return exports2.findIndex((v) => v.name === "schema") !== -1;
+};
+const isApiFunction = (p, functionsPath) => {
+  p = import_path.default.relative(functionsPath, p);
+  const { dir, name } = import_path.default.parse(p);
+  if (dir === name) {
+    return true;
+  } else if (dir === "") {
+    return true;
+  } else if (dir.length && name === "index") {
+    return true;
+  }
+  return false;
+};
+const isFileInsideFolder = (filePath, folderPath) => {
+  const { dir } = import_path.default.parse(filePath);
+  const relativePathFromFolder = import_path.default.relative(folderPath, dir);
+  if (!relativePathFromFolder || relativePathFromFolder.startsWith("..") || import_path.default.isAbsolute(relativePathFromFolder)) {
+    return false;
+  } else {
+    return true;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  findApiDistFunctions,
+  findApiFiles,
+  findApiServerFunctions,
+  findCells,
+  findDirectoryNamedModules,
+  findGraphQLSchemas,
+  findPages,
+  findRouteHooksSrc,
+  findScripts,
+  findWebFiles,
+  isApiFunction,
+  isCellFile,
+  isDirectoryNamedModuleFile,
+  isFileInsideFolder,
+  isGraphQLSchemaFile,
+  isPageFile
+});

package/dist/generate/clientPreset.d.ts

@@ -0,0 +1,17 @@
+export declare const shouldGenerateTrustedDocuments: () => boolean;
+export declare const generateClientPreset: () => Promise<{
+    clientPresetFiles: string[];
+    trustedDocumentsStoreFile: never[];
+    errors: {
+        message: string;
+        error: unknown;
+    }[];
+} | {
+    clientPresetFiles: string[];
+    trustedDocumentsStoreFile: string;
+    errors: {
+        message: string;
+        error: unknown;
+    }[];
+}>;
+//# sourceMappingURL=clientPreset.d.ts.map

package/dist/generate/clientPreset.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clientPreset.d.ts","sourceRoot":"","sources":["../../src/generate/clientPreset.ts"],"names":[],"mappings":"AAYA,eAAO,MAAM,8BAA8B,QAAO,OAIjD,CAAA;AAED,eAAO,MAAM,oBAAoB;;;;iBAIN,MAAM;eAAS,OAAO;;;;;;iBAAtB,MAAM;eAAS,OAAO;;EAoDhD,CAAA"}

package/dist/generate/clientPreset.js

@@ -0,0 +1,85 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var clientPreset_exports = {};
+__export(clientPreset_exports, {
+  generateClientPreset: () => generateClientPreset,
+  shouldGenerateTrustedDocuments: () => shouldGenerateTrustedDocuments
+});
+module.exports = __toCommonJS(clientPreset_exports);
+var import_cli = require("@graphql-codegen/cli");
+var import_client_preset = require("@graphql-codegen/client-preset");
+var import_project_config = require("@cedarjs/project-config");
+var import_trustedDocuments = require("./trustedDocuments");
+const shouldGenerateTrustedDocuments = () => {
+  const config = (0, import_project_config.getConfig)();
+  return config.graphql.trustedDocuments;
+};
+const generateClientPreset = async () => {
+  let generatedFiles = [];
+  let clientPresetFiles = [];
+  const errors = [];
+  if (!shouldGenerateTrustedDocuments()) {
+    return { clientPresetFiles, trustedDocumentsStoreFile: [], errors };
+  }
+  const documentsGlob = `${(0, import_project_config.getPaths)().web.src}/**/!(*.d).{ts,tsx,js,jsx}`;
+  const config = {
+    schema: (0, import_project_config.getPaths)().generated.schema,
+    documents: documentsGlob,
+    silent: true,
+    // Plays nicely with cli task output
+    generates: {
+      [`${(0, import_project_config.getPaths)().web.src}/graphql/`]: {
+        preset: "client",
+        presetConfig: {
+          persistedDocuments: true
+        },
+        documentTransforms: [import_client_preset.addTypenameSelectionDocumentTransform],
+        config: {
+          // DO NOT USE documentMode: 'string',
+        }
+      }
+    }
+  };
+  try {
+    generatedFiles = await (0, import_cli.generate)(config, true);
+    clientPresetFiles = generatedFiles.map((f) => f.filename);
+    const trustedDocumentsStoreFile = await (0, import_trustedDocuments.trustedDocumentsStore)(generatedFiles);
+    (0, import_trustedDocuments.replaceGqlTagWithTrustedDocumentGraphql)(generatedFiles);
+    return {
+      clientPresetFiles,
+      trustedDocumentsStoreFile,
+      errors
+    };
+  } catch (e) {
+    errors.push({
+      message: "Error: Could not generate GraphQL client preset",
+      error: e
+    });
+    return {
+      clientPresetFiles,
+      trustedDocumentsStoreFile: [],
+      errors
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  generateClientPreset,
+  shouldGenerateTrustedDocuments
+});

package/dist/generate/generate.d.ts

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+export declare const generate: () => Promise<{
+    files: string[];
+    errors: {
+        message: string;
+        error: unknown;
+    }[];
+}>;
+export declare const run: () => Promise<void>;
+//# sourceMappingURL=generate.d.ts.map

package/dist/generate/generate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../../src/generate/generate.ts"],"names":[],"mappings":";AASA,eAAO,MAAM,QAAQ;;;;;;EAsCpB,CAAA;AAED,eAAO,MAAM,GAAG,qBA4Bf,CAAA"}

package/dist/generate/generate.js

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var generate_exports = {};
+__export(generate_exports, {
+  generate: () => generate,
+  run: () => run
+});
+module.exports = __toCommonJS(generate_exports);
+var import_project_config = require("@cedarjs/project-config");
+var import_clientPreset = require("./clientPreset");
+var import_graphqlSchema = require("./graphqlSchema");
+var import_possibleTypes = require("./possibleTypes");
+var import_typeDefinitions = require("./typeDefinitions");
+const generate = async () => {
+  const config = (0, import_project_config.getConfig)();
+  const { schemaPath, errors: generateGraphQLSchemaErrors } = await (0, import_graphqlSchema.generateGraphQLSchema)();
+  const { typeDefFiles, errors: generateTypeDefsErrors } = await (0, import_typeDefinitions.generateTypeDefs)();
+  const clientPresetFiles = [];
+  const { possibleTypesFiles, errors: generatePossibleTypesErrors } = await (0, import_possibleTypes.generatePossibleTypes)();
+  if (config.graphql.trustedDocuments) {
+    const preset = await (0, import_clientPreset.generateClientPreset)();
+    clientPresetFiles.push(...preset.clientPresetFiles);
+  }
+  let files = [];
+  if (schemaPath !== "") {
+    files.push(schemaPath);
+  }
+  files = [
+    ...files,
+    ...typeDefFiles,
+    ...clientPresetFiles,
+    ...possibleTypesFiles
+  ].filter((x) => typeof x === "string");
+  return {
+    files,
+    errors: [
+      ...generateGraphQLSchemaErrors,
+      ...generateTypeDefsErrors,
+      ...generatePossibleTypesErrors
+    ]
+  };
+};
+const run = async () => {
+  console.log("Generating...");
+  console.log();
+  const { files, errors } = await generate();
+  const rwjsPaths = (0, import_project_config.getPaths)();
+  for (const f of files) {
+    console.log("-", f.replace(rwjsPaths.base + "/", ""));
+  }
+  console.log();
+  if (errors.length === 0) {
+    console.log("... done.");
+    console.log();
+    return;
+  }
+  process.exitCode ||= 1;
+  console.log("... done with errors.");
+  console.log();
+  for (const { message, error } of errors) {
+    console.error(message);
+    console.log();
+    console.error(error);
+    console.log();
+  }
+};
+if (require.main === module) {
+  run();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  generate,
+  run
+});

package/dist/generate/graphqlCodeGen.d.ts

@@ -0,0 +1,16 @@
+import type { LoadTypedefsOptions } from '@graphql-tools/load';
+type TypeDefResult = {
+    typeDefFiles: string[];
+    errors: {
+        message: string;
+        error: unknown;
+    }[];
+};
+export declare const generateTypeDefGraphQLApi: () => Promise<TypeDefResult>;
+export declare const generateTypeDefGraphQLWeb: () => Promise<TypeDefResult>;
+export declare function getLoadDocumentsOptions(filename: string): LoadTypedefsOptions<{
+    cwd: string;
+}>;
+export declare const getResolverFnType: () => "(\n      args: TArgs,\n      obj?: { root: TParent; context: TContext; info: GraphQLResolveInfo }\n    ) => TResult | Promise<TResult>" | "(\n      args?: TArgs,\n      obj?: { root: TParent; context: TContext; info: GraphQLResolveInfo }\n    ) => TResult | Promise<TResult>";
+export {};
+//# sourceMappingURL=graphqlCodeGen.d.ts.map

package/dist/generate/graphqlCodeGen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphqlCodeGen.d.ts","sourceRoot":"","sources":["../../src/generate/graphqlCodeGen.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAA;AAc9D,KAAK,aAAa,GAAG;IACnB,YAAY,EAAE,MAAM,EAAE,CAAA;IACtB,MAAM,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,OAAO,CAAA;KAAE,EAAE,CAAA;CAC9C,CAAA;AAED,eAAO,MAAM,yBAAyB,QAAa,OAAO,CAAC,aAAa,CAgFvE,CAAA;AAED,eAAO,MAAM,yBAAyB,QAAa,OAAO,CAAC,aAAa,CAwDvE,CAAA;AAiCD,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,MAAM;SACD,MAAM;GAQ5D;AA+GD,eAAO,MAAM,iBAAiB,4RAe7B,CAAA"}