@cedarjs/internal 0.6.1-next.0 → 0.7.0

package/dist/cjs/generate/typeDefinitions.js

@@ -0,0 +1,369 @@
+"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 typeDefinitions_exports = {};
+__export(typeDefinitions_exports, {
+  generateMirrorCell: () => generateMirrorCell,
+  generateMirrorCells: () => generateMirrorCells,
+  generateMirrorDirectoryNamedModule: () => generateMirrorDirectoryNamedModule,
+  generateMirrorDirectoryNamedModules: () => generateMirrorDirectoryNamedModules,
+  generateTypeDefCurrentUser: () => generateTypeDefCurrentUser,
+  generateTypeDefGlobImports: () => generateTypeDefGlobImports,
+  generateTypeDefGlobalContext: () => generateTypeDefGlobalContext,
+  generateTypeDefRouterPages: () => generateTypeDefRouterPages,
+  generateTypeDefRouterRoutes: () => generateTypeDefRouterRoutes,
+  generateTypeDefScenarios: () => generateTypeDefScenarios,
+  generateTypeDefTestMocks: () => generateTypeDefTestMocks,
+  generateTypeDefs: () => generateTypeDefs,
+  generateViteClientTypesDirective: () => generateViteClientTypesDirective,
+  mirrorPathForCell: () => mirrorPathForCell,
+  mirrorPathForDirectoryNamedModules: () => mirrorPathForDirectoryNamedModules
+});
+module.exports = __toCommonJS(typeDefinitions_exports);
+var import_fs = __toESM(require("fs"), 1);
+var import_path = __toESM(require("path"), 1);
+var import_source_map = require("source-map");
+var import_project_config = require("@cedarjs/project-config");
+var import_ast = require("../ast.js");
+var import_files = require("../files.js");
+var import_gql = require("../gql.js");
+var import_jsx = require("../jsx.js");
+var import_graphqlCodeGen = require("./graphqlCodeGen.js");
+var import_templates = require("./templates.js");
+const generateTypeDefs = async () => {
+  const { typeDefFiles: gqlApiTypeDefFiles, errors: apiErrors } = await (0, import_graphqlCodeGen.generateTypeDefGraphQLApi)();
+  const { typeDefFiles: gqlWebTypeDefFiles, errors: webErrors } = await (0, import_graphqlCodeGen.generateTypeDefGraphQLWeb)();
+  return {
+    typeDefFiles: [
+      ...generateMirrorDirectoryNamedModules(),
+      ...generateMirrorCells(),
+      ...generateTypeDefRouterPages(),
+      ...generateTypeDefCurrentUser(),
+      ...generateTypeDefRouterRoutes(),
+      ...generateTypeDefGlobImports(),
+      ...generateTypeDefGlobalContext(),
+      ...generateTypeDefScenarios(),
+      ...generateTypeDefTestMocks(),
+      ...generateStubStorybookTypes(),
+      ...generateViteClientTypesDirective(),
+      ...gqlApiTypeDefFiles,
+      ...gqlWebTypeDefFiles
+    ],
+    errors: [...apiErrors, ...webErrors]
+  };
+};
+const generateMirrorDirectoryNamedModules = () => {
+  const rwjsPaths = (0, import_project_config.getPaths)();
+  return (0, import_files.findDirectoryNamedModules)().map(
+    (p) => generateMirrorDirectoryNamedModule(p, rwjsPaths)
+  );
+};
+const mirrorPathForDirectoryNamedModules = (p, rwjsPaths = (0, import_project_config.getPaths)()) => {
+  return [
+    import_path.default.join(
+      rwjsPaths.generated.types.mirror,
+      import_path.default.relative(rwjsPaths.base, import_path.default.dirname(p))
+    ),
+    "index.d.ts"
+  ];
+};
+const generateMirrorDirectoryNamedModule = (p, rwjsPaths = (0, import_project_config.getPaths)()) => {
+  const [mirrorDir, typeDef] = mirrorPathForDirectoryNamedModules(p, rwjsPaths);
+  import_fs.default.mkdirSync(mirrorDir, { recursive: true });
+  const typeDefPath = import_path.default.join(mirrorDir, typeDef);
+  const { name } = import_path.default.parse(p);
+  (0, import_templates.writeTemplate)(
+    "templates/mirror-directoryNamedModule.d.ts.template",
+    typeDefPath,
+    { name }
+  );
+  if (p.startsWith(rwjsPaths.web.src)) {
+    try {
+      const fileContents = (0, import_ast.fileToAst)(p);
+      const defaultExportLocation = (0, import_ast.getDefaultExportLocation)(fileContents) ?? {
+        line: 1,
+        column: 0
+      };
+      const map = new import_source_map.SourceMapGenerator({
+        file: "index.d.ts"
+      });
+      map.addMapping({
+        generated: {
+          line: 4,
+          column: 0
+        },
+        source: import_path.default.relative(import_path.default.dirname(typeDefPath), p),
+        original: defaultExportLocation
+      });
+      import_fs.default.writeFileSync(
+        `${typeDefPath}.map`,
+        JSON.stringify(map.toJSON(), void 0, 2)
+      );
+    } catch (error) {
+      console.error(
+        "Couldn't generate a definition map for directory named module at path:",
+        p
+      );
+      console.error(error);
+    }
+  }
+  return typeDefPath;
+};
+const generateMirrorCells = () => {
+  const rwjsPaths = (0, import_project_config.getPaths)();
+  return (0, import_files.findCells)().map((p) => generateMirrorCell(p, rwjsPaths));
+};
+const mirrorPathForCell = (p, rwjsPaths = (0, import_project_config.getPaths)()) => {
+  const mirrorDir = import_path.default.join(
+    rwjsPaths.generated.types.mirror,
+    import_path.default.relative(rwjsPaths.base, import_path.default.dirname(p))
+  );
+  import_fs.default.mkdirSync(mirrorDir, { recursive: true });
+  return [mirrorDir, "index.d.ts"];
+};
+const generateMirrorCell = (p, rwjsPaths = (0, import_project_config.getPaths)()) => {
+  const [mirrorDir, typeDef] = mirrorPathForCell(p, rwjsPaths);
+  import_fs.default.mkdirSync(mirrorDir, { recursive: true });
+  const typeDefPath = import_path.default.join(mirrorDir, typeDef);
+  const { name } = import_path.default.parse(p);
+  const fileContents = (0, import_ast.fileToAst)(p);
+  const cellQuery = (0, import_ast.getCellGqlQuery)(fileContents);
+  if (cellQuery) {
+    const gqlDoc = (0, import_gql.parseGqlQueryToAst)(cellQuery)[0];
+    (0, import_templates.writeTemplate)("templates/mirror-cell.d.ts.template", typeDefPath, {
+      name,
+      queryResultType: `${gqlDoc?.name}`,
+      queryVariablesType: `${gqlDoc?.name}Variables`
+    });
+  } else {
+    (0, import_templates.writeTemplate)("templates/mirror-cell.d.ts.template", typeDefPath, {
+      name,
+      queryResultType: "any",
+      queryVariablesType: "any"
+    });
+  }
+  try {
+    const exportedComponents = (0, import_ast.getNamedExports)(fileContents);
+    const successComponent = exportedComponents.find(
+      (x) => x.name === "Success"
+    );
+    if (successComponent === void 0) {
+      throw new Error("No Success component found");
+    }
+    const map = new import_source_map.SourceMapGenerator({
+      file: "index.d.ts"
+    });
+    map.addMapping({
+      generated: {
+        line: 12,
+        column: 0
+      },
+      source: import_path.default.relative(import_path.default.dirname(typeDefPath), p),
+      original: successComponent.location
+    });
+    import_fs.default.writeFileSync(
+      `${typeDefPath}.map`,
+      JSON.stringify(map.toJSON(), void 0, 2)
+    );
+  } catch (error) {
+    console.error("Couldn't generate a definition map for cell at path:", p);
+    console.error(error);
+  }
+  return typeDefPath;
+};
+const writeTypeDefIncludeFile = (template, values = {}) => {
+  const rwjsPaths = (0, import_project_config.getPaths)();
+  const typeDefPath = import_path.default.join(
+    rwjsPaths.generated.types.includes,
+    template.replace(".template", "")
+  );
+  const templateFilename = import_path.default.join("templates", template);
+  (0, import_templates.writeTemplate)(templateFilename, typeDefPath, values);
+  return [typeDefPath];
+};
+const generateTypeDefRouterRoutes = () => {
+  const ast = (0, import_ast.fileToAst)((0, import_project_config.getPaths)().web.routes);
+  let hasRootRoute = false;
+  const routes = (0, import_jsx.getJsxElements)(ast, "Route").filter((x) => {
+    const isValidRoute = typeof x.props?.path !== "undefined" && typeof x.props?.name !== "undefined";
+    if (isValidRoute && x.props.path === "/") {
+      hasRootRoute = true;
+    }
+    return isValidRoute;
+  });
+  try {
+    const typeDefPath = import_path.default.join(
+      (0, import_project_config.getPaths)().generated.types.includes,
+      "web-routerRoutes.d.ts"
+    );
+    const map = new import_source_map.SourceMapGenerator({
+      file: "web-routerRoutes.d.ts"
+    });
+    const startLine = 7;
+    for (let i = 0; i < routes.length; i++) {
+      map.addMapping({
+        generated: {
+          line: startLine + i,
+          column: 4
+        },
+        source: import_path.default.relative(import_path.default.dirname(typeDefPath), (0, import_project_config.getPaths)().web.routes),
+        original: routes[i].location
+      });
+    }
+    import_fs.default.writeFileSync(
+      `${typeDefPath}.map`,
+      JSON.stringify(map.toJSON(), void 0, 2)
+    );
+  } catch (error) {
+    console.error(
+      "Couldn't generate a definition map for web-routerRoutes.d.ts:"
+    );
+    console.error(error);
+  }
+  if (!hasRootRoute) {
+    routes.push({
+      name: "splashPage route",
+      location: { line: -1, column: -1 },
+      props: {
+        path: "/",
+        name: "home"
+      }
+    });
+  }
+  return writeTypeDefIncludeFile("web-routerRoutes.d.ts.template", { routes });
+};
+const generateTypeDefRouterPages = () => {
+  const pages = (0, import_project_config.processPagesDir)();
+  try {
+    const typeDefPath = import_path.default.join(
+      (0, import_project_config.getPaths)().generated.types.includes,
+      "web-routesPages.d.ts"
+    );
+    const map = new import_source_map.SourceMapGenerator({
+      file: "web-routesPages.d.ts"
+    });
+    const startLine = pages.length + 5;
+    for (let i = 0; i < pages.length; i++) {
+      const fileContents = (0, import_ast.fileToAst)(pages[i].path);
+      const defaultExportLocation = (0, import_ast.getDefaultExportLocation)(fileContents) ?? {
+        line: 1,
+        column: 0
+      };
+      map.addMapping({
+        generated: {
+          line: startLine + i,
+          column: 0
+        },
+        source: import_path.default.relative(import_path.default.dirname(typeDefPath), pages[i].path),
+        original: defaultExportLocation
+      });
+    }
+    import_fs.default.writeFileSync(
+      `${typeDefPath}.map`,
+      JSON.stringify(map.toJSON(), void 0, 2)
+    );
+  } catch (error) {
+    console.error(
+      "Couldn't generate a definition map for web-routesPages.d.ts:"
+    );
+    console.error(error);
+  }
+  return writeTypeDefIncludeFile("web-routesPages.d.ts.template", { pages });
+};
+const generateTypeDefCurrentUser = () => {
+  return writeTypeDefIncludeFile("all-currentUser.d.ts.template");
+};
+const generateTypeDefScenarios = () => {
+  return writeTypeDefIncludeFile("api-scenarios.d.ts.template");
+};
+const generateTypeDefTestMocks = () => {
+  return [
+    writeTypeDefIncludeFile("api-test-globals.d.ts.template"),
+    writeTypeDefIncludeFile("web-test-globals.d.ts.template")
+  ].flat();
+};
+const generateTypeDefGlobImports = () => {
+  return writeTypeDefIncludeFile("api-globImports.d.ts.template");
+};
+const generateTypeDefGlobalContext = () => {
+  return writeTypeDefIncludeFile("api-globalContext.d.ts.template");
+};
+const generateViteClientTypesDirective = () => {
+  const viteClientDirective = `/// <reference types="vite/client" />`;
+  const redwoodProjectPaths = (0, import_project_config.getPaths)();
+  const viteClientDirectivePath = import_path.default.join(
+    redwoodProjectPaths.generated.types.includes,
+    "web-vite-client.d.ts"
+  );
+  import_fs.default.writeFileSync(viteClientDirectivePath, viteClientDirective);
+  return [viteClientDirectivePath];
+};
+function generateStubStorybookTypes() {
+  const stubStorybookTypesFileContent = `declare module '@storybook/react' {
+  export type Meta<T = any> = any
+  export type StoryObj<T = any> = any
+}
+`;
+  const redwoodProjectPaths = (0, import_project_config.getPaths)();
+  const packageJson = JSON.parse(
+    import_fs.default.readFileSync(
+      import_path.default.join(redwoodProjectPaths.base, "package.json"),
+      "utf-8"
+    )
+  );
+  const hasCliStorybookVite = Object.keys(
+    packageJson["devDependencies"]
+  ).includes("@cedarjs/cli-storybook-vite");
+  if (hasCliStorybookVite) {
+    return [];
+  }
+  const stubStorybookTypesFilePath = import_path.default.join(
+    redwoodProjectPaths.generated.types.includes,
+    "web-storybook.d.ts"
+  );
+  import_fs.default.writeFileSync(stubStorybookTypesFilePath, stubStorybookTypesFileContent);
+  return [stubStorybookTypesFilePath];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  generateMirrorCell,
+  generateMirrorCells,
+  generateMirrorDirectoryNamedModule,
+  generateMirrorDirectoryNamedModules,
+  generateTypeDefCurrentUser,
+  generateTypeDefGlobImports,
+  generateTypeDefGlobalContext,
+  generateTypeDefRouterPages,
+  generateTypeDefRouterRoutes,
+  generateTypeDefScenarios,
+  generateTypeDefTestMocks,
+  generateTypeDefs,
+  generateViteClientTypesDirective,
+  mirrorPathForCell,
+  mirrorPathForDirectoryNamedModules
+});

package/dist/cjs/generate/types.d.ts

@@ -0,0 +1,6 @@
+export interface GeneratedFile {
+    filename: string;
+    content: string;
+    hooks: string;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/generate/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,EAAE,MAAM,CAAA;CACd"}

package/dist/cjs/generate/types.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/cjs/generate/watch.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=watch.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"watch.d.ts","sourceRoot":"","sources":["../../../src/generate/watch.ts"],"names":[],"mappings":""}

package/dist/cjs/generate/watch.js

@@ -0,0 +1,124 @@
+#!/usr/bin/env node
+"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 __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 import_fs = __toESM(require("fs"), 1);
+var import_path = __toESM(require("path"), 1);
+var import_ansis = __toESM(require("ansis"), 1);
+var import_chokidar = __toESM(require("chokidar"), 1);
+var import_project_config = require("@cedarjs/project-config");
+var import_cliLogger = require("../cliLogger.js");
+var import_files = require("../files.js");
+var import_routes = require("../routes.js");
+var import_clientPreset = require("./clientPreset.js");
+var import_generate = require("./generate.js");
+var import_graphqlCodeGen = require("./graphqlCodeGen.js");
+var import_graphqlSchema = require("./graphqlSchema.js");
+var import_typeDefinitions = require("./typeDefinitions.js");
+const rwjsPaths = (0, import_project_config.getPaths)();
+const watcher = import_chokidar.default.watch("(web|api)/src/**/*.{ts,js,jsx,tsx}", {
+  persistent: true,
+  ignored: ["node_modules", ".redwood"],
+  ignoreInitial: true,
+  cwd: rwjsPaths.base,
+  awaitWriteFinish: true
+});
+const action = {
+  add: "Created",
+  unlink: "Deleted",
+  change: "Modified"
+};
+let routesWarningMessage = "";
+process.stdin.on("data", async (data) => {
+  const str = data.toString().trim().toLowerCase();
+  if (str === "g" || str === "rs") {
+    (0, import_cliLogger.cliLogger)("Re-creating TypeScript definitions and GraphQL schemas");
+    await (0, import_generate.generate)();
+  }
+});
+watcher.on("ready", async () => {
+  const start = Date.now();
+  (0, import_cliLogger.cliLogger)("Generating full TypeScript definitions and GraphQL schemas");
+  const { files, errors } = await (0, import_generate.generate)();
+  (0, import_cliLogger.cliLogger)(`Done.`);
+  import_cliLogger.cliLogger.debug(`
+Created ${files.length} in ${Date.now() - start} ms`);
+  if (errors.length > 0) {
+    for (const { message, error } of errors) {
+      console.error(message);
+      console.error(error);
+      console.log();
+    }
+  }
+  routesWarningMessage = (0, import_routes.warningForDuplicateRoutes)();
+  if (routesWarningMessage) {
+    console.warn(routesWarningMessage);
+  }
+}).on("all", async (eventName, p) => {
+  import_cliLogger.cliLogger.trace(
+    `File system change: ${import_ansis.default.magenta(eventName)} ${import_ansis.default.dim(p)}`
+  );
+  if (!["add", "change", "unlink"].includes(eventName)) {
+    return;
+  }
+  const eventTigger = eventName;
+  const absPath = import_path.default.join(rwjsPaths.base, p);
+  const start = Date.now();
+  const finished = (type) => import_cliLogger.cliLogger.debug(
+    action[eventTigger],
+    type + ":",
+    import_ansis.default.dim(p),
+    import_ansis.default.dim.italic(Date.now() - start + " ms")
+  );
+  if (absPath.includes("Cell") && (0, import_files.isCellFile)(absPath)) {
+    await (0, import_graphqlCodeGen.generateTypeDefGraphQLWeb)();
+    await (0, import_clientPreset.generateClientPreset)();
+    if (eventName === "unlink") {
+      import_fs.default.unlinkSync((0, import_typeDefinitions.mirrorPathForCell)(absPath, rwjsPaths)[0]);
+    } else {
+      (0, import_typeDefinitions.generateMirrorCell)(absPath, rwjsPaths);
+    }
+    finished("Cell");
+  } else if (absPath === rwjsPaths.web.routes) {
+    (0, import_typeDefinitions.generateTypeDefRouterRoutes)();
+    routesWarningMessage = (0, import_routes.warningForDuplicateRoutes)();
+    finished("Routes");
+  } else if (absPath.includes("Page") && (0, import_files.isPageFile)(absPath)) {
+    (0, import_typeDefinitions.generateTypeDefRouterPages)();
+    finished("Page");
+  } else if ((0, import_files.isDirectoryNamedModuleFile)(absPath)) {
+    if (eventName === "unlink") {
+      import_fs.default.unlinkSync((0, import_typeDefinitions.mirrorPathForDirectoryNamedModules)(absPath, rwjsPaths)[0]);
+    } else {
+      (0, import_typeDefinitions.generateMirrorDirectoryNamedModule)(absPath, rwjsPaths);
+    }
+    finished("Directory named module");
+  } else if ((0, import_files.isGraphQLSchemaFile)(absPath)) {
+    await (0, import_graphqlSchema.generateGraphQLSchema)();
+    await (0, import_graphqlCodeGen.generateTypeDefGraphQLApi)();
+    finished("GraphQL Schema");
+  }
+  if (routesWarningMessage) {
+    console.warn(routesWarningMessage);
+  }
+});

package/dist/cjs/gql.d.ts

@@ -0,0 +1,14 @@
+import type { DocumentNode, OperationTypeNode } from 'graphql';
+interface Operation {
+    operation: OperationTypeNode;
+    name: string | undefined;
+    fields: (string | Field)[];
+}
+interface Field {
+    string: (string | Field)[];
+}
+export declare const parseGqlQueryToAst: (gqlQuery: string) => Operation[];
+export declare const parseDocumentAST: (document: DocumentNode) => Operation[];
+export declare const listQueryTypeFieldsInProject: () => Promise<string[]>;
+export {};
+//# sourceMappingURL=gql.d.ts.map

package/dist/cjs/gql.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gql.d.ts","sourceRoot":"","sources":["../../src/gql.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,YAAY,EAIZ,iBAAiB,EAClB,MAAM,SAAS,CAAA;AAMhB,UAAU,SAAS;IACjB,SAAS,EAAE,iBAAiB,CAAA;IAC5B,IAAI,EAAE,MAAM,GAAG,SAAS,CAAA;IACxB,MAAM,EAAE,CAAC,MAAM,GAAG,KAAK,CAAC,EAAE,CAAA;CAC3B;AAED,UAAU,KAAK;IACb,MAAM,EAAE,CAAC,MAAM,GAAG,KAAK,CAAC,EAAE,CAAA;CAC3B;AAED,eAAO,MAAM,kBAAkB,aAAc,MAAM,gBAGlD,CAAA;AAED,eAAO,MAAM,gBAAgB,aAAc,YAAY,gBAoBtD,CAAA;AAgCD,eAAO,MAAM,4BAA4B,yBA8BxC,CAAA"}

package/dist/cjs/gql.js

@@ -0,0 +1,108 @@
+"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 gql_exports = {};
+__export(gql_exports, {
+  listQueryTypeFieldsInProject: () => listQueryTypeFieldsInProject,
+  parseDocumentAST: () => parseDocumentAST,
+  parseGqlQueryToAst: () => parseGqlQueryToAst
+});
+module.exports = __toCommonJS(gql_exports);
+var import_code_file_loader = require("@graphql-tools/code-file-loader");
+var import_load = require("@graphql-tools/load");
+var import_graphql = require("graphql");
+var import_graphql_server = require("@cedarjs/graphql-server");
+var import_project_config = require("@cedarjs/project-config");
+const parseGqlQueryToAst = (gqlQuery) => {
+  const ast = (0, import_graphql.parse)(gqlQuery);
+  return parseDocumentAST(ast);
+};
+const parseDocumentAST = (document) => {
+  const operations = [];
+  (0, import_graphql.visit)(document, {
+    OperationDefinition(node) {
+      const fields = [];
+      node.selectionSet.selections.forEach((field) => {
+        fields.push(getFields(field));
+      });
+      operations.push({
+        operation: node.operation,
+        name: node.name?.value,
+        fields
+      });
+    }
+  });
+  return operations;
+};
+const getFields = (field) => {
+  if (!field.selectionSet) {
+    return field.name.value;
+  } else {
+    const obj = {
+      [field.name.value]: []
+    };
+    const lookAtFieldNode = (node) => {
+      node.selectionSet?.selections.forEach((subField) => {
+        switch (subField.kind) {
+          case import_graphql.Kind.FIELD:
+            obj[field.name.value].push(getFields(subField));
+            break;
+          case import_graphql.Kind.FRAGMENT_SPREAD:
+            break;
+          case import_graphql.Kind.INLINE_FRAGMENT:
+            lookAtFieldNode(subField);
+        }
+      });
+    };
+    lookAtFieldNode(field);
+    return obj;
+  }
+};
+const listQueryTypeFieldsInProject = async () => {
+  try {
+    const schemaPointerMap = {
+      [(0, import_graphql.print)(import_graphql_server.rootSchema.schema)]: {},
+      "graphql/**/*.sdl.{js,ts}": {},
+      "directives/**/*.{js,ts}": {},
+      "subscriptions/**/*.{js,ts}": {}
+    };
+    const mergedSchema = await (0, import_load.loadSchema)(schemaPointerMap, {
+      loaders: [
+        new import_code_file_loader.CodeFileLoader({
+          noRequire: true,
+          pluckConfig: {
+            globalGqlIdentifierName: "gql"
+          }
+        })
+      ],
+      cwd: (0, import_project_config.getPaths)().api.src,
+      assumeValidSDL: true
+    });
+    const queryTypeFields = mergedSchema.getQueryType()?.getFields();
+    return Object.keys(queryTypeFields ?? {});
+  } catch (e) {
+    console.error(e);
+    return [];
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  listQueryTypeFieldsInProject,
+  parseDocumentAST,
+  parseGqlQueryToAst
+});

package/dist/cjs/index.d.ts

@@ -0,0 +1,11 @@
+export * from '@cedarjs/project-config';
+export * from './ts2js.js';
+export * from './dev.js';
+export * from './routes.js';
+export * from './files.js';
+export { generate } from './generate/generate.js';
+export { buildApi } from './build/api.js';
+export * from './validateSchema.js';
+export * from '@cedarjs/babel-config';
+export { listQueryTypeFieldsInProject } from './gql.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAA;AAEvC,cAAc,YAAY,CAAA;AAC1B,cAAc,UAAU,CAAA;AACxB,cAAc,aAAa,CAAA;AAE3B,cAAc,YAAY,CAAA;AAC1B,OAAO,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAA;AACjD,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AAEzC,cAAc,qBAAqB,CAAA;AAGnC,cAAc,uBAAuB,CAAA;AAErC,OAAO,EAAE,4BAA4B,EAAE,MAAM,UAAU,CAAA"}