@powerhousedao/codegen 0.36.1 → 0.37.1

package/dist/cli.js

@@ -1,79 +1 @@
 #! /usr/bin/env node
-import { getConfig } from '@powerhousedao/config/powerhouse';
-import { generateEditor, generateProcessor, generateSubgraph, generateFromFile, generate } from './codegen/index.js';
-import { parseConfig, promptDirectories, parseArgs } from './utils/index.js';
-
-function parseCommand(argv) {
-  const args = parseArgs(argv, {
-    "--editor": String,
-    "--subgraph": String,
-    "-e": "--editor",
-    "--processor": String,
-    "--document-types": String,
-    "--processor-type": String,
-    "--file": String
-  });
-  const editorName = args["--editor"];
-  const processorName = args["--processor"];
-  const processorType = args["--processor-type"];
-  const subgraphName = args["--subgraph"];
-  const file = args["--file"];
-  return {
-    processor: !!processorName,
-    processorName,
-    processorType,
-    editor: !!editorName,
-    editorName,
-    documentTypes: args["--document-types"],
-    arg: args._,
-    subgraph: !!subgraphName,
-    subgraphName: subgraphName ?? "example",
-    file
-  };
-}
-async function main() {
-  const argv = process.argv.slice(2);
-  const baseConfig = getConfig();
-  const argsConfig = parseConfig(argv);
-  const config = { ...baseConfig, ...argsConfig };
-  if (config.interactive) {
-    const result = await promptDirectories(config);
-    Object.assign(config, result);
-  }
-  const command = parseCommand(argv);
-  if (command.editor) {
-    if (!command.editorName) {
-      throw new Error("Editor name is required (--editor or -e)");
-    }
-    await generateEditor(
-      command.editorName,
-      command.documentTypes?.split(/[|,;]/g) ?? [],
-      config
-    );
-  } else if (command.processor) {
-    if (!command.processorName) {
-      throw new Error("processor name is required (--processor)");
-    }
-    const type = !command.processorType ? "analytics" : command.processorType;
-    await generateProcessor(
-      command.processorName,
-      type,
-      command.documentTypes?.split(/[|,;]/g) ?? [],
-      config
-    );
-  } else if (command.subgraph) {
-    if (!command.subgraphName) {
-      throw new Error("Subgraph name is required (--subgraph)");
-    }
-    await generateSubgraph(command.subgraphName, command.file || null, config);
-  } else if (command.file || command.arg.length === 2) {
-    await generateFromFile(command.file || command.arg[1], config);
-  } else {
-    await generate(config);
-  }
-}
-main().catch((e) => {
-  throw e;
-});
-//# sourceMappingURL=cli.js.map
-//# sourceMappingURL=cli.js.map

package/dist/create-lib/index.js

@@ -1,8 +1 @@
 #! /usr/bin/env node
-import { initCli } from './init.js';
-
-initCli().catch((e) => {
-  throw e;
-});
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map

package/dist/index.d.ts

@@ -1,6 +1,4 @@
-export { D as DocumentTypesMap, g as generate, b as generateEditor, a as generateFromFile, e as generateImportScript, d as generateProcessor, c as generateSubgraph } from './index-DT1dkT-t.js';
-export { ICreateProjectOptions, configSpec, createProject, createProjectSpec, generateMock, generateMockTypeFn, getPackageManager, parseArgs, parseConfig, parseVersion, promptDirectories } from './utils.js';
-import '@powerhousedao/config/powerhouse';
-import 'document-model/document';
-import 'arg';
-import '@anatine/zod-mock';
+export * from "./src/codegen/index.js";
+export * from "./src/create-lib/index.js";
+export * from "./src/utils/index.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,sBAAsB,CAAC"}

package/dist/index.js

@@ -1,4 +1,3 @@
-export * from './codegen/index.js';
-export * from './utils/index.js';
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map
+export * from "./src/codegen/index.js";
+export * from "./src/create-lib/index.js";
+export * from "./src/utils/index.js";

package/dist/src/codegen/.hygen/templates/powerhouse/generate-document-model/documentModel.esm.t

@@ -0,0 +1,7 @@
+---
+to: "<%= rootDir %>/<%= h.changeCase.param(documentType) %>/gen/document-model.ts"
+force: true
+---
+import type { DocumentModelState } from "document-model";
+
+export const documentModelState: DocumentModelState = <%- documentModel %>;

package/dist/{codegen → src/codegen}/.hygen/templates/powerhouse/generate-import-script/index.esm.t

@@ -3,7 +3,7 @@ to: "<%= rootDir %>/<%= h.changeCase.param(name) %>/index.ts"
 force: true
 ---
 import { IBaseDocumentDriveServer } from "document-drive";
-import { actions } from "document-model/document-model";
+import { actions } from "document-model";
 import {
   addDocument,
   addFolder,

package/dist/{codegen → src/codegen}/.hygen/templates/powerhouse/generate-import-script/utils.esm.t

@@ -10,7 +10,7 @@ import {
 } from "document-model-libs/document-drive";
 import * as DocumentModelsLibs from "document-model-libs/document-models";
 import { DocumentModel } from "document-model/document";
-import { module as DocumentModelLib } from "document-model/document-model";
+import { module as DocumentModelLib } from "document-model";
 import * as LocalDocumentModels from "../../document-models";
 
 export const addFolder = (

package/dist/src/codegen/graphql.d.ts

@@ -0,0 +1,16 @@
+import { plugin } from "@acaldas/graphql-codegen-typescript-validation-schema";
+import { type CodegenConfig } from "@graphql-codegen/cli";
+import { TypeScriptPluginConfig } from "@graphql-codegen/typescript";
+export declare const tsConfig: TypeScriptPluginConfig;
+export type ValidationSchemaConfigType = Parameters<typeof plugin>[2];
+export declare const validationConfig: ValidationSchemaConfigType;
+export declare function schemaConfig(name: string, dir: string): CodegenConfig["generates"];
+export declare const generateSchema: (model: string, dir: string, { watch, skipFormat }?: {
+    watch?: boolean | undefined;
+    skipFormat?: boolean | undefined;
+}) => Promise<any>;
+export declare const generateSchemas: (dir: string, { watch, skipFormat }?: {
+    watch?: boolean | undefined;
+    skipFormat?: boolean | undefined;
+}) => Promise<any>;
+//# sourceMappingURL=graphql.d.ts.map

package/dist/src/codegen/graphql.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphql.d.ts","sourceRoot":"","sources":["../../../src/codegen/graphql.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,uDAAuD,CAAC;AAC/E,OAAO,EAAE,KAAK,aAAa,EAAY,MAAM,sBAAsB,CAAC;AACpE,OAAO,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AAUrE,eAAO,MAAM,QAAQ,EAAE,sBAiBtB,CAAC;AAEF,MAAM,MAAM,0BAA0B,GAAG,UAAU,CAAC,OAAO,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;AAEtE,eAAO,MAAM,gBAAgB,EAAE,0BAkB9B,CAAC;AAEF,wBAAgB,YAAY,CAC1B,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,MAAM,GACV,aAAa,CAAC,WAAW,CAAC,CAmB5B;AAED,eAAO,MAAM,cAAc,UAClB,MAAM,OACR,MAAM;;;kBAcZ,CAAC;AAEF,eAAO,MAAM,eAAe,QACrB,MAAM;;;kBAqBZ,CAAC"}

package/dist/src/codegen/graphql.js

@@ -0,0 +1,91 @@
+import { generate } from "@graphql-codegen/cli";
+import { generatorTypeDefs, validationSchema } from "@powerhousedao/scalars";
+import { readdirSync } from "node:fs";
+import { formatWithPrettierBeforeWrite } from "./utils.js";
+const getDirectories = (source) => readdirSync(source, { withFileTypes: true })
+    .filter((dirent) => dirent.isDirectory())
+    .map((dirent) => dirent.name);
+export const tsConfig = {
+    strictScalars: true,
+    scalars: {
+        Unknown: "unknown",
+        DateTime: "string",
+        Attachment: "string",
+        Address: "`${string}:0x${string}`",
+        ...generatorTypeDefs,
+    },
+    enumsAsTypes: true,
+    allowEnumStringTypes: true,
+    avoidOptionals: {
+        field: true,
+    },
+    skipTypename: true,
+    // maybeValue: "T | null | undefined",
+    inputMaybeValue: "T | null | undefined",
+};
+export const validationConfig = {
+    importFrom: `./types.js`,
+    schema: "zod",
+    ...tsConfig,
+    scalarSchemas: {
+        Unknown: "z.unknown()",
+        DateTime: "z.string().datetime()",
+        Attachment: "z.string()",
+        Address: "z.custom<`${string}:0x${string}`>((val) => /^[a-zA-Z0-9]+:0x[a-fA-F0-9]{40}$/.test(val as string))",
+        ...validationSchema,
+    },
+    directives: {
+        equals: {
+            value: ["regex", "/^$1$/"],
+        },
+    },
+    withObjectType: true,
+};
+export function schemaConfig(name, dir) {
+    return {
+        [`${dir}/${name}/gen/schema/types.ts`]: {
+            schema: [
+                {
+                    [`${dir}/${name}/schema.graphql`]: {
+                        skipGraphQLImport: false,
+                    },
+                },
+            ],
+            plugins: ["typescript"],
+            config: tsConfig,
+        },
+        [`${dir}/${name}/gen/schema/zod.ts`]: {
+            schema: `${dir}/${name}/schema.graphql`,
+            plugins: ["@acaldas/graphql-codegen-typescript-validation-schema"],
+            config: validationConfig,
+        },
+    };
+}
+export const generateSchema = (model, dir, { watch = false, skipFormat = false } = {}) => {
+    const documentModelConfig = schemaConfig(model, dir);
+    const config = {
+        overwrite: true,
+        generates: documentModelConfig,
+        watch,
+        hooks: {
+            beforeOneFileWrite: skipFormat ? [] : [formatWithPrettierBeforeWrite],
+        },
+    };
+    return generate(config, true);
+};
+export const generateSchemas = (dir, { watch = false, skipFormat = false } = {}) => {
+    const documentModels = getDirectories(dir);
+    const documentModelConfigs = documentModels.reduce((obj, model) => ({
+        ...obj,
+        ...schemaConfig(model, dir),
+    }), {});
+    const config = {
+        overwrite: true,
+        generates: documentModelConfigs,
+        watch,
+        hooks: {
+            beforeOneFileWrite: skipFormat ? [] : [formatWithPrettierBeforeWrite],
+        },
+    };
+    return generate(config, true);
+};

package/dist/src/codegen/hygen.d.ts

@@ -0,0 +1,23 @@
+import { DocumentModelState } from "document-model";
+import { DocumentTypesMap } from "./index.js";
+export declare function generateAll(dir: string, { watch, skipFormat }?: {
+    watch?: boolean | undefined;
+    skipFormat?: boolean | undefined;
+}): Promise<void>;
+export declare function generateDocumentModel(documentModelState: DocumentModelState, dir: string, { watch, skipFormat }?: {
+    watch?: boolean | undefined;
+    skipFormat?: boolean | undefined;
+}): Promise<void>;
+export declare function generateEditor(name: string, documentTypes: string[], documentTypesMap: DocumentTypesMap, dir: string, documentModelsDir: string, { skipFormat }?: {
+    skipFormat?: boolean | undefined;
+}): Promise<void>;
+export declare function generateProcessor(name: string, documentTypes: string[], documentTypesMap: DocumentTypesMap, dir: string, documentModelsDir: string, type?: string, { skipFormat }?: {
+    skipFormat?: boolean | undefined;
+}): Promise<void>;
+export declare function generateSubgraph(name: string, documentModel: DocumentModelState | null, dir: string, { skipFormat }?: {
+    skipFormat?: boolean | undefined;
+}): Promise<void>;
+export declare function generateImportScript(name: string, dir: string, { skipFormat }?: {
+    skipFormat?: boolean | undefined;
+}): Promise<void>;
+//# sourceMappingURL=hygen.d.ts.map

package/dist/src/codegen/hygen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hygen.d.ts","sourceRoot":"","sources":["../../../src/codegen/hygen.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AAMpD,OAAO,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AA6C9C,wBAAsB,WAAW,CAC/B,GAAG,EAAE,MAAM,EACX,EAAE,KAAa,EAAE,UAAkB,EAAE;;;CAAK,iBAoB3C;AAED,wBAAsB,qBAAqB,CACzC,kBAAkB,EAAE,kBAAkB,EACtC,GAAG,EAAE,MAAM,EACX,EAAE,KAAa,EAAE,UAAkB,EAAE;;;CAAK,iBAoC3C;AAED,wBAAsB,cAAc,CAClC,IAAI,EAAE,MAAM,EACZ,aAAa,EAAE,MAAM,EAAE,EACvB,gBAAgB,EAAE,gBAAgB,EAClC,GAAG,EAAE,MAAM,EACX,iBAAiB,EAAE,MAAM,EACzB,EAAE,UAAkB,EAAE;;CAAK,iBAoB5B;AAED,wBAAsB,iBAAiB,CACrC,IAAI,EAAE,MAAM,EACZ,aAAa,EAAE,MAAM,EAAE,EACvB,gBAAgB,EAAE,gBAAgB,EAClC,GAAG,EAAE,MAAM,EACX,iBAAiB,EAAE,MAAM,EACzB,IAAI,SAAc,EAClB,EAAE,UAAkB,EAAE;;CAAK,iBAuB5B;AAED,wBAAsB,gBAAgB,CACpC,IAAI,EAAE,MAAM,EACZ,aAAa,EAAE,kBAAkB,GAAG,IAAI,EACxC,GAAG,EAAE,MAAM,EACX,EAAE,UAAkB,EAAE;;CAAK,iBAoC5B;AAED,wBAAsB,oBAAoB,CACxC,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,MAAM,EACX,EAAE,UAAkB,EAAE;;CAAK,iBAgB5B"}

package/dist/src/codegen/hygen.js

@@ -0,0 +1,162 @@
+import { pascalCase } from "change-case";
+import { Logger, runner } from "hygen";
+import fs from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { loadDocumentModel } from "./utils.js";
+const require = createRequire(import.meta.url);
+const __dirname = import.meta.dirname || path.dirname(fileURLToPath(import.meta.url));
+const logger = new Logger(console.log.bind(console));
+const defaultTemplates = path.join(__dirname, ".hygen", "templates");
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+async function run(args, { watch = false, skipFormat = false } = {}) {
+    const result = await runner(args, {
+        templates: defaultTemplates,
+        cwd: process.cwd(),
+        logger,
+        createPrompter: () => {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+            return require("enquirer");
+        },
+        exec: (action, body) => {
+            const opts = body && body.length > 0 ? { input: body } : {};
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+            return require("execa").shell(action, opts);
+        },
+        debug: !!process.env.DEBUG,
+    });
+    if (!skipFormat) {
+        const execa = await import("execa");
+        const actions = result.actions;
+        actions
+            .filter((action) => ["added", "inject"].includes(action.status))
+            .forEach((action) => {
+            execa.$ `prettier --ignore-path --write ${action.subject.replace(".", process.cwd())}`.catch((err) => {
+                console.log(err);
+            });
+        });
+    }
+    return result;
+}
+export async function generateAll(dir, { watch = false, skipFormat = false } = {}) {
+    const files = fs.readdirSync(dir, { withFileTypes: true });
+    for (const directory of files.filter((f) => f.isDirectory())) {
+        const documentModelPath = path.join(dir, directory.name, `${directory.name}.json`);
+        if (!fs.existsSync(documentModelPath)) {
+            continue;
+        }
+        try {
+            const documentModel = await loadDocumentModel(documentModelPath);
+            await generateDocumentModel(documentModel, dir, { watch, skipFormat });
+        }
+        catch (error) {
+            console.error(directory.name, error);
+        }
+    }
+}
+export async function generateDocumentModel(documentModelState, dir, { watch = false, skipFormat = false } = {}) {
+    // Generate the singular files for the document model logic
+    await run([
+        "powerhouse",
+        "generate-document-model",
+        "--document-model",
+        JSON.stringify(documentModelState),
+        "--root-dir",
+        dir,
+    ], { watch, skipFormat });
+    const latestSpec = documentModelState.specifications[documentModelState.specifications.length - 1];
+    // Generate the module-specific files for the document model logic
+    for (const module of latestSpec.modules) {
+        await run([
+            "powerhouse",
+            "generate-document-model-module",
+            "--document-model",
+            JSON.stringify(documentModelState),
+            "--root-dir",
+            dir,
+            "--module",
+            module.name,
+        ], { watch, skipFormat });
+    }
+}
+export async function generateEditor(name, documentTypes, documentTypesMap, dir, documentModelsDir, { skipFormat = false } = {}) {
+    // Generate the singular files for the document model logic
+    await run([
+        "powerhouse",
+        "generate-editor",
+        "--name",
+        name,
+        "--root-dir",
+        dir,
+        "--document-types",
+        documentTypes.join(","),
+        "--document-types-map",
+        JSON.stringify(documentTypesMap),
+        "--document-models-dir",
+        documentModelsDir,
+    ], { skipFormat });
+}
+export async function generateProcessor(name, documentTypes, documentTypesMap, dir, documentModelsDir, type = "analytics", { skipFormat = false } = {}) {
+    // Generate the singular files for the document model logic
+    const processorType = type === "operational" ? "operational" : "analytics";
+    await run([
+        "powerhouse",
+        `generate-processor-${processorType}`,
+        "--name",
+        name,
+        "--pascalName",
+        pascalCase(name),
+        "--root-dir",
+        dir,
+        "--document-types",
+        documentTypes.join(","),
+        "--document-types-map",
+        JSON.stringify(documentTypesMap),
+        "--document-models-dir",
+        documentModelsDir,
+    ], { skipFormat });
+}
+export async function generateSubgraph(name, documentModel, dir, { skipFormat = false } = {}) {
+    const params = [
+        "powerhouse",
+        `generate-subgraph`,
+        "--name",
+        name,
+        "--pascalName",
+        pascalCase(name),
+        "--root-dir",
+        dir,
+    ];
+    if (documentModel) {
+        params.push("--loadFromFile", "1");
+    }
+    // Generate the singular files for the document model logic
+    await run(params, { skipFormat });
+    if (documentModel) {
+        // Generate the GraphQL mutation schemas
+        await run([
+            "powerhouse",
+            "generate-document-model-mutations",
+            "--subgraph",
+            name,
+            "--document-model",
+            JSON.stringify(documentModel),
+            "--root-dir",
+            dir,
+        ], { skipFormat });
+    }
+}
+export async function generateImportScript(name, dir, { skipFormat = false } = {}) {
+    // Generate the singular files for the document model logic
+    await run([
+        "powerhouse",
+        `generate-import-script`,
+        "--name",
+        name,
+        "--pascalName",
+        pascalCase(name),
+        "--root-dir",
+        dir,
+    ], { skipFormat });
+}

package/dist/src/codegen/index.d.ts

@@ -0,0 +1,12 @@
+import { PowerhouseConfig } from "@powerhousedao/config/powerhouse";
+export type DocumentTypesMap = Record<string, {
+    name: string;
+    importPath: string;
+}>;
+export declare function generate(config: PowerhouseConfig): Promise<void>;
+export declare function generateFromFile(path: string, config: PowerhouseConfig): Promise<void>;
+export declare function generateEditor(name: string, documentTypes: string[], config: PowerhouseConfig): Promise<void>;
+export declare function generateSubgraph(name: string, file: string | null, config: PowerhouseConfig): Promise<void>;
+export declare function generateProcessor(name: string, type: "analytics" | "operational", documentTypes: string[], config: PowerhouseConfig): Promise<void>;
+export declare function generateImportScript(name: string, config: PowerhouseConfig): Promise<void>;
+//# sourceMappingURL=index.d.ts.map

package/dist/src/codegen/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/codegen/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AA4CpE,MAAM,MAAM,gBAAgB,GAAG,MAAM,CACnC,MAAM,EACN;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,CACrC,CAAC;AAyDF,wBAAsB,QAAQ,CAAC,MAAM,EAAE,gBAAgB,iBAItD;AAED,wBAAsB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,gBAAgB,iBA4B5E;AAED,wBAAsB,cAAc,CAClC,IAAI,EAAE,MAAM,EACZ,aAAa,EAAE,MAAM,EAAE,EACvB,MAAM,EAAE,gBAAgB,iBAwBzB;AAED,wBAAsB,gBAAgB,CACpC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,GAAG,IAAI,EACnB,MAAM,EAAE,gBAAgB,iBAQzB;AAED,wBAAsB,iBAAiB,CACrC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,WAAW,GAAG,aAAa,EACjC,aAAa,EAAE,MAAM,EAAE,EACvB,MAAM,EAAE,gBAAgB,iBAqBzB;AAED,wBAAsB,oBAAoB,CACxC,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,gBAAgB,iBAGzB"}

package/dist/src/codegen/index.js

@@ -0,0 +1,122 @@
+import { typeDefs } from "@powerhousedao/scalars";
+import { paramCase, pascalCase } from "change-case";
+import fs from "node:fs";
+import { join, resolve } from "path";
+import { generateSchema, generateSchemas } from "./graphql.js";
+import { generateEditor as _generateEditor, generateImportScript as _generateImportScript, generateProcessor as _generateProcessor, generateSubgraph as _generateSubgraph, generateAll, generateDocumentModel, } from "./hygen.js";
+import { loadDocumentModel } from "./utils.js";
+function generateGraphqlSchema(documentModel) {
+    const spec = documentModel.specifications[documentModel.specifications.length - 1];
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (!spec) {
+        throw new Error(`No spec found for ${documentModel.id}`);
+    }
+    const { modules, state: { global, local }, } = spec;
+    const schemas = [
+        global.schema,
+        local.schema,
+        ...modules
+            .map((module) => [
+            `# ${module.name}`,
+            ...module.operations.map((op) => op.schema),
+        ])
+            .flat()
+            .filter((schema) => schema && schema.length > 0),
+    ];
+    return schemas.join("\n\n");
+}
+// returns map of document model id to document model name in pascal case and import path
+async function getDocumentTypesMap(dir, pathOrigin = "../../../") {
+    const documentTypesMap = {};
+    // add document types from provided dir
+    if (fs.existsSync(dir)) {
+        fs.readdirSync(dir, { withFileTypes: true })
+            .filter((dirent) => dirent.isDirectory())
+            .map((dirent) => dirent.name)
+            .forEach((name) => {
+            const specPath = resolve(dir, name, `${name}.json`);
+            if (!fs.existsSync(specPath)) {
+                return;
+            }
+            const specRaw = fs.readFileSync(specPath, "utf-8");
+            try {
+                const spec = JSON.parse(specRaw);
+                if (spec.id) {
+                    documentTypesMap[spec.id] = {
+                        name: pascalCase(name),
+                        importPath: join(pathOrigin, dir, name),
+                    };
+                }
+            }
+            catch {
+                console.error(`Failed to parse ${specPath}`);
+            }
+        });
+    }
+    // add documents from document-model-libs if lib is installed
+    try {
+        /* eslint-disable */
+        // @ts-ignore-error TS2307 this import is expected to fail if document-model-libs is not available
+        const documentModels = await import("document-model-libs/document-models");
+        Object.keys(documentModels).forEach((name) => {
+            const documentModel = documentModels[name];
+            documentTypesMap[documentModel.documentModel.id] = {
+                name,
+                importPath: `document-model-libs/${paramCase(name)}`,
+            };
+        });
+        /* eslint-enable */
+    }
+    catch {
+        /* document-model-libs is not available */
+    }
+    return documentTypesMap;
+}
+export async function generate(config) {
+    const { skipFormat, watch } = config;
+    await generateSchemas(config.documentModelsDir, { skipFormat, watch });
+    await generateAll(config.documentModelsDir, { skipFormat, watch });
+}
+export async function generateFromFile(path, config) {
+    // load document model spec from file
+    const documentModel = await loadDocumentModel(path);
+    const name = paramCase(documentModel.name);
+    // create document model folder and spec as json
+    fs.mkdirSync(join(config.documentModelsDir, name), { recursive: true });
+    fs.writeFileSync(join(config.documentModelsDir, name, `${name}.json`), JSON.stringify(documentModel, null, 4));
+    // bundle graphql schemas together
+    const schemaStr = [
+        typeDefs.join("\n"), // inject ph scalars
+        generateGraphqlSchema(documentModel),
+    ].join("\n");
+    if (schemaStr) {
+        fs.writeFileSync(join(config.documentModelsDir, name, `schema.graphql`), schemaStr);
+    }
+    await generateSchema(name, config.documentModelsDir, config);
+    await generateDocumentModel(documentModel, config.documentModelsDir, config);
+}
+export async function generateEditor(name, documentTypes, config) {
+    const pathOrigin = "../../";
+    const { documentModelsDir, skipFormat } = config;
+    const documentTypesMap = await getDocumentTypesMap(documentModelsDir, pathOrigin);
+    const invalidType = documentTypes.find((type) => !Object.keys(documentTypesMap).includes(type));
+    if (invalidType) {
+        throw new Error(`Document model for ${invalidType} not found`);
+    }
+    return _generateEditor(name, documentTypes, documentTypesMap, config.editorsDir, config.documentModelsDir, { skipFormat });
+}
+export async function generateSubgraph(name, file, config) {
+    return _generateSubgraph(name, file !== null ? await loadDocumentModel(file) : null, config.subgraphsDir, config);
+}
+export async function generateProcessor(name, type, documentTypes, config) {
+    const { documentModelsDir, skipFormat } = config;
+    const documentTypesMap = await getDocumentTypesMap(documentModelsDir);
+    const invalidType = documentTypes.find((type) => !Object.keys(documentTypesMap).includes(type));
+    if (invalidType) {
+        throw new Error(`Document model for ${invalidType} not found`);
+    }
+    return _generateProcessor(name, documentTypes, documentTypesMap, config.processorsDir, config.documentModelsDir, type, { skipFormat });
+}
+export async function generateImportScript(name, config) {
+    return _generateImportScript(name, config.importScriptsDir, config);
+}

package/dist/src/codegen/utils.d.ts

@@ -0,0 +1,4 @@
+import { type DocumentModelState } from "document-model";
+export declare function loadDocumentModel(path: string): Promise<DocumentModelState>;
+export declare function formatWithPrettierBeforeWrite(outputFile: string, content: string): Promise<string>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/src/codegen/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/codegen/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,kBAAkB,EACxB,MAAM,gBAAgB,CAAC;AAIxB,wBAAsB,iBAAiB,CACrC,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,kBAAkB,CAAC,CA2B7B;AAED,wBAAsB,6BAA6B,CACjD,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,MAAM,mBAMhB"}

package/dist/src/codegen/utils.js

@@ -0,0 +1,40 @@
+import { documentModelLoadFromFile, } from "document-model";
+import fs from "node:fs";
+import { format } from "prettier";
+export async function loadDocumentModel(path) {
+    let documentModel;
+    try {
+        if (!path) {
+            throw new Error("Document model file not specified");
+        }
+        else if (path.endsWith(".zip")) {
+            const file = await documentModelLoadFromFile(path);
+            documentModel = file.state.global;
+        }
+        else if (path.endsWith(".json")) {
+            const data = fs.readFileSync(path, "utf-8");
+            const parsedData = JSON.parse(data);
+            if ("state" in parsedData) {
+                documentModel = parsedData.state.global;
+            }
+            else {
+                documentModel = parsedData;
+            }
+        }
+        else {
+            throw new Error("File type not supported. Must be zip or json.");
+        }
+        return documentModel;
+    }
+    catch (error) {
+        throw error.code === "MODULE_NOT_FOUND"
+            ? new Error(`Document model not found.`)
+            : error;
+    }
+}
+export async function formatWithPrettierBeforeWrite(outputFile, content) {
+    const modifiedContent = await format(content, {
+        parser: "typescript",
+    });
+    return modifiedContent;
+}

package/dist/src/create-lib/create-project.d.ts

@@ -0,0 +1,25 @@
+export declare const createCommandSpec: {
+    readonly "--name": StringConstructor;
+    readonly "--project-name": "--name";
+    readonly "--version": StringConstructor;
+    readonly "--interactive": BooleanConstructor;
+    readonly "--dev": BooleanConstructor;
+    readonly "--staging": BooleanConstructor;
+    readonly "-p": "--name";
+    readonly "-v": "--version";
+    readonly "--package-manager": StringConstructor;
+};
+export interface ICreateProjectOptions {
+    name: string | undefined;
+    version: string;
+    interactive: boolean;
+    packageManager?: string;
+}
+export declare function parseVersion(args: {
+    version?: string;
+    dev?: boolean;
+    staging?: boolean;
+}): string;
+export declare function initCli(): Promise<void>;
+export declare function createProject(options: ICreateProjectOptions): Promise<void>;
+//# sourceMappingURL=create-project.d.ts.map