@powerhousedao/codegen 6.0.0-dev.19 → 6.0.0-dev.191

package/dist/index.mjs

@@ -0,0 +1,802 @@
+import { $ as tsConfigTemplate, At as claudeSettingsLocalTemplate, Dt as dockerfileTemplate, Et as nginxConfTemplate, Ht as ts$1, Ot as connectEntrypointTemplate, St as editorsTemplate, Tt as switchboardEntrypointTemplate, Z as vitestConfigTemplate, _t as gitIgnoreTemplate, at as buildPowerhouseConfigTemplate, bt as eslintConfigTemplate, dt as mcpTemplate, f as processorsIndexTemplate, ft as mainTsxTemplate, gt as indexHtmlTemplate, it as ManifestTemplate, jt as agentsTemplate, kt as cursorMcpTemplate, m as factoryBuildersTemplate, mt as indexTsTemplate, nt as styleTemplate, p as processorsFactoryTemplate, pt as licenseTemplate, rt as readmeTemplate, ut as npmrcTemplate, vt as syncAndPublishWorkflowTemplate, wt as documentModelsTemplate, yt as geminiSettingsTemplate } from "./templates-BbNsigQX.mjs";
+import { configSpec, parseArgs, parseConfig, runPrettier, validateDocumentModelState } from "./src/utils/index.mjs";
+import { a as generateDocumentModelZodSchemas, c as scalars, g as tsMorphGenerateApp, h as buildBoilerplatePackageJson, i as tsMorphGenerateDocumentModel, l as scalarsValidation, n as tsMorphGenerateSubgraph, o as generateSchemas, r as tsMorphGenerateProcessor, s as generateTypesAndZodSchemasFromGraphql, t as makeSubgraphsIndexFile, u as tsMorphGenerateDocumentEditor } from "./file-builders-BV9wDPPZ.mjs";
+import { createRequire } from "node:module";
+import { fileExists } from "@powerhousedao/shared/clis";
+import { camelCase, kebabCase, pascalCase } from "change-case";
+import path from "path";
+import { Project, SyntaxKind, VariableDeclarationKind } from "ts-morph";
+import { format } from "prettier";
+import path$1, { dirname, join, resolve } from "node:path";
+import { mkdir, readFile, readdir, writeFile } from "node:fs/promises";
+import "get-tsconfig";
+import fs$1, { existsSync } from "node:fs";
+import { readPackage } from "read-pkg";
+import semver from "semver";
+import "write-package";
+import { documentModelReducer } from "@powerhousedao/shared/document-model";
+import { baseLoadFromFile } from "document-model/node";
+import { spawn } from "node:child_process";
+import { execSync } from "child_process";
+import chalk from "chalk";
+import fs$2 from "fs/promises";
+//#region src/codegen/utils.ts
+async function loadDocumentModel(path) {
+	let documentModel;
+	try {
+		if (!path) throw new Error("Document model file not specified");
+		else if (path.endsWith(".zip") || path.endsWith(".phd")) documentModel = (await baseLoadFromFile(path, documentModelReducer)).state.global;
+		else if (path.endsWith(".json")) {
+			const data = await readFile(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, phd, or json.");
+		return documentModel;
+	} catch (error) {
+		throw error.code === "MODULE_NOT_FOUND" ? /* @__PURE__ */ new Error(`Document model not found.`) : error;
+	}
+}
+async function formatWithPrettierBeforeWrite(outputFile, content) {
+	return await format(content, { parser: "typescript" });
+}
+/** returns map of document model id to document model name in pascal case and import path */
+function getDocumentTypesMap(dir, pathOrigin = "../../") {
+	const documentTypesMap = { "powerhouse/document-model": {
+		name: "DocumentModel",
+		importPath: `document-model`
+	} };
+	if (fs$1.existsSync(dir)) fs$1.readdirSync(dir, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name).forEach((name) => {
+		const specPath = resolve(dir, name, `${name}.json`);
+		if (!fs$1.existsSync(specPath)) return;
+		const specRaw = fs$1.readFileSync(specPath, "utf-8");
+		try {
+			const spec = JSON.parse(specRaw);
+			if (spec.id) documentTypesMap[spec.id] = {
+				name: pascalCase(name),
+				importPath: join(pathOrigin, dir, name, "index.js")
+			};
+		} catch {
+			console.error(`Failed to parse ${specPath}`);
+		}
+	});
+	return documentTypesMap;
+}
+//#endregion
+//#region src/codegen/generate.ts
+async function generateAll(args) {
+	const { dir, useVersioning, migrateLegacy = false, watch = false, skipFormat = false, verbose = true, force = true } = args;
+	const files = await readdir(dir, { withFileTypes: true });
+	const documentModelStates = [];
+	for (const directory of files.filter((f) => f.isDirectory())) {
+		const documentModelPath = path$1.join(dir, directory.name, `${directory.name}.json`);
+		if (!await fileExists(documentModelPath)) continue;
+		try {
+			const documentModelState = await loadDocumentModel(documentModelPath);
+			documentModelStates.push(documentModelState);
+			await generateDocumentModel({
+				dir,
+				documentModelState,
+				watch,
+				skipFormat,
+				verbose,
+				force,
+				useVersioning,
+				migrateLegacy
+			});
+		} catch (error) {
+			if (verbose) console.error(directory.name, error);
+		}
+	}
+}
+async function generate(config, useVersioning, migrateLegacy = false) {
+	const { skipFormat, watch } = config;
+	await generateSchemas(config.documentModelsDir, {
+		skipFormat,
+		watch
+	});
+	await generateAll({
+		dir: config.documentModelsDir,
+		useVersioning,
+		migrateLegacy,
+		skipFormat,
+		watch
+	});
+}
+async function generateFromFile(args) {
+	const { path, config, useVersioning, migrateLegacy, options } = args;
+	await generateFromDocumentModel({
+		documentModelState: await loadDocumentModel(path),
+		config,
+		useVersioning,
+		migrateLegacy,
+		options
+	});
+}
+/**
+* Generates code from a DocumentModelGlobalState object directly.
+*
+* @remarks
+* This function performs the same code generation as generateFromFile but takes
+* a DocumentModelGlobalState object directly instead of loading from a file. This allows for
+* programmatic code generation without file I/O.
+*
+* @param documentModelDocument - The DocumentModelGlobalState object containing the document model
+* @param config - The PowerhouseConfig configuration object
+* @param options - Optional configuration for generation behavior (verbose logging, etc.)
+* @returns A promise that resolves when code generation is complete
+*/
+async function generateFromDocument(args) {
+	await generateFromDocumentModel(args);
+}
+async function generateDocumentModel(args) {
+	const { dir, documentModelState, useVersioning, migrateLegacy } = args;
+	ensureZodVersionIsSufficient(findZodDependencyInPackageJson(await readPackage()));
+	await tsMorphGenerateDocumentModel({
+		projectDir: path$1.dirname(dir),
+		documentModelState,
+		useVersioning,
+		migrateLegacy
+	});
+}
+function findZodDependencyInPackageJson(packageJson) {
+	return {
+		...packageJson.dependencies,
+		...packageJson.devDependencies
+	}["zod"];
+}
+function ensureZodVersionIsSufficient(zodSemverString) {
+	if (!zodSemverString) return;
+	const cleaned = semver.clean(zodSemverString);
+	if (!cleaned) return;
+	if (!semver.gte(cleaned, "4.0.0")) throw new Error(`Your version of zod "${zodSemverString}" is out of date. Please install zod version 4.x to continue.`);
+}
+async function generateEditor(args) {
+	const { editorName, documentTypes, editorId: editorIdArg, editorDirName } = args;
+	const projectDir = path$1.dirname("editors");
+	if (documentTypes.length > 1) throw new Error("Multiple document types are not supported yet");
+	const documentModelId = documentTypes[0];
+	const editorId = editorIdArg || kebabCase(editorName);
+	await tsMorphGenerateDocumentEditor({
+		projectDir,
+		editorDir: editorDirName || kebabCase(editorName),
+		documentModelId,
+		editorName,
+		editorId
+	});
+}
+async function generateApp(options) {
+	const { appName, appId, allowedDocumentTypes, isDragAndDropEnabled, appDirName } = options;
+	await tsMorphGenerateApp({
+		projectDir: path$1.dirname("editors"),
+		editorDir: appDirName || kebabCase(appName),
+		editorName: appName,
+		editorId: appId ?? kebabCase(appName),
+		allowedDocumentModelIds: allowedDocumentTypes ?? [],
+		isDragAndDropEnabled: isDragAndDropEnabled ?? true
+	});
+}
+async function generateSubgraphFromDocumentModel(name, documentModel, config) {
+	await tsMorphGenerateSubgraph({
+		subgraphsDir: config.subgraphsDir,
+		subgraphName: name,
+		documentModel
+	});
+	await makeSubgraphsIndexFile({ projectDir: path$1.dirname(config.subgraphsDir) });
+}
+async function generateSubgraph(name, file, config) {
+	const documentModelState = file !== null ? await loadDocumentModel(file) : null;
+	await tsMorphGenerateSubgraph({
+		subgraphsDir: config.subgraphsDir,
+		subgraphName: name,
+		documentModel: documentModelState
+	});
+	await makeSubgraphsIndexFile({ projectDir: path$1.dirname(config.subgraphsDir) });
+}
+async function generateProcessor(args) {
+	const { rootDir = process.cwd() } = args;
+	return await tsMorphGenerateProcessor({
+		rootDir,
+		...args
+	});
+}
+async function generateImportScript(_name, _config) {
+	throw new Error("Import script generation has been removed. The document-drive server APIs it depended on have been deprecated.");
+}
+const defaultManifest = {
+	name: "",
+	description: "",
+	category: "",
+	publisher: {
+		name: "",
+		url: ""
+	},
+	documentModels: [],
+	editors: [],
+	apps: [],
+	subgraphs: [],
+	processors: []
+};
+function generateManifest(manifestData, projectRoot) {
+	const manifestPath = join(projectRoot || process.cwd(), "powerhouse.manifest.json");
+	let existingManifest = defaultManifest;
+	if (fs$1.existsSync(manifestPath)) try {
+		const existingData = fs$1.readFileSync(manifestPath, "utf-8");
+		existingManifest = JSON.parse(existingData);
+	} catch (error) {
+		console.warn(`Failed to parse existing manifest: ${String(error)}`);
+		existingManifest = defaultManifest;
+	}
+	const mergeArrayById = (existingArray, newArray) => {
+		if (!newArray) return existingArray;
+		const result = [...existingArray];
+		newArray.forEach((newItem) => {
+			const existingIndex = result.findIndex((item) => item.id === newItem.id);
+			if (existingIndex !== -1) result[existingIndex] = newItem;
+			else result.push(newItem);
+		});
+		return result;
+	};
+	const mergeConfigByName = (existingArray, newArray) => {
+		if (!newArray) return existingArray;
+		const result = [...existingArray];
+		newArray.forEach((newItem) => {
+			const existingIndex = result.findIndex((item) => item.name === newItem.name);
+			if (existingIndex !== -1) result[existingIndex] = newItem;
+			else result.push(newItem);
+		});
+		return result;
+	};
+	const updatedManifest = {
+		...existingManifest,
+		...manifestData,
+		publisher: {
+			...existingManifest.publisher,
+			...manifestData.publisher || {}
+		},
+		documentModels: mergeArrayById(existingManifest.documentModels ?? [], manifestData.documentModels),
+		editors: mergeArrayById(existingManifest.editors ?? [], manifestData.editors),
+		apps: mergeArrayById(existingManifest.apps ?? [], manifestData.apps),
+		subgraphs: mergeArrayById(existingManifest.subgraphs ?? [], manifestData.subgraphs),
+		config: mergeConfigByName(existingManifest.config ?? [], manifestData.config)
+	};
+	fs$1.writeFileSync(manifestPath, JSON.stringify(updatedManifest, null, 4));
+	return manifestPath;
+}
+/**
+* Generates code from a DocumentModelGlobalState.
+*
+* @remarks
+* This is the core generation function that both generateFromFile and generateFromDocument
+* use internally. It handles the actual code generation from a DocumentModelGlobalState object.
+*
+* @param documentModel - The DocumentModelGlobalState containing the document model specification
+* @param config - The PowerhouseConfig configuration object
+* @param options - Optional configuration for generation behavior
+* @returns A promise that resolves when code generation is complete
+*/
+async function generateFromDocumentModel(args) {
+	const { documentModelState, config, useVersioning, migrateLegacy, options = {} } = args;
+	const { verbose = config.logLevel === "verbose" || config.logLevel === "debug" || config.logLevel === "info", force = false } = options;
+	const name = kebabCase(documentModelState.name);
+	const documentModelDir = join(config.documentModelsDir, name);
+	fs$1.mkdirSync(documentModelDir, { recursive: true });
+	fs$1.writeFileSync(join(documentModelDir, `${name}.json`), JSON.stringify(documentModelState, null, 2));
+	await generateDocumentModel({
+		dir: config.documentModelsDir,
+		documentModelState,
+		watch: config.watch,
+		skipFormat: config.skipFormat,
+		verbose,
+		force,
+		useVersioning,
+		migrateLegacy
+	});
+}
+//#endregion
+//#region src/codegen/kysely.ts
+function getKyselyPgLiteBin() {
+	const paths = createRequire(import.meta.url).resolve.paths("kysely-pglite");
+	if (paths) for (const basePath of paths) {
+		const binPath = join(join(basePath, "kysely-pglite"), "bin/run.js");
+		if (existsSync(binPath)) return binPath;
+	}
+	throw new Error("Could not find kysely-pglite/bin/run.js");
+}
+function runCommand(command, args, cwd) {
+	return new Promise((resolve, reject) => {
+		const child = spawn(command, args, {
+			cwd,
+			stdio: "inherit",
+			shell: true
+		});
+		child.on("close", (code) => {
+			if (code === 0) resolve();
+			else reject(/* @__PURE__ */ new Error(`Command failed with exit code ${code}`));
+		});
+		child.on("error", (error) => {
+			reject(error);
+		});
+	});
+}
+async function generateDBSchema({ migrationFile, schemaFile }) {
+	const outFile = schemaFile ?? resolve(migrationFile, "../schema.ts");
+	try {
+		await runCommand("node", [
+			getKyselyPgLiteBin(),
+			migrationFile,
+			"--outFile",
+			outFile
+		], process.cwd());
+		console.log(`Schema types generated at ${outFile}`);
+	} catch (error) {
+		console.error("Error running migration:", error);
+	}
+}
+//#endregion
+//#region src/create-lib/utils.ts
+const packageManagers = [
+	"npm",
+	"yarn",
+	"pnpm",
+	"bun"
+];
+const defaultPackageManager = "npm";
+function getPackageManager(userAgent) {
+	if (!userAgent) return defaultPackageManager;
+	const name = userAgent.split(" ")[0].split("/")[0];
+	if (packageManagers.includes(name)) return name;
+	else return defaultPackageManager;
+}
+getPackageManager(process.env.npm_config_user_agent);
+function runCmd(command) {
+	try {
+		execSync(command, { stdio: "inherit" });
+	} catch (error) {
+		console.log("\x1B[31m", error, "\x1B[0m");
+		throw error;
+	}
+}
+async function writeFileEnsuringDir(filePath, contents) {
+	await mkdir(dirname(filePath), { recursive: true });
+	await writeFile(filePath, contents, { encoding: "utf-8" });
+}
+//#endregion
+//#region src/create-lib/checkout-project.ts
+/**
+* Clones a git repository and returns the path to the cloned project.
+* @param repositoryUrl - The URL of the git repository to clone
+* @returns The absolute path to the cloned project directory
+*/
+function cloneRepository(repositoryUrl) {
+	try {
+		console.log("\x1B[33m", `Cloning repository from ${repositoryUrl}...`, "\x1B[0m");
+		runCmd(`git clone ${repositoryUrl}`);
+		const repoName = repositoryUrl.split("/").pop()?.replace(/\.git$/, "");
+		if (!repoName) throw new Error("Could not determine project name from repository URL");
+		return path$1.join(process.cwd(), repoName);
+	} catch (error) {
+		console.log(error);
+		throw error;
+	}
+}
+/**
+* Installs dependencies in a project directory using the specified package manager.
+* @param projectPath - The absolute path to the project directory
+* @param packageManager - The package manager to use (npm, pnpm, yarn, bun)
+*/
+function installDependencies(projectPath, packageManager) {
+	try {
+		process.chdir(projectPath);
+		console.log("\x1B[34m", `Installing dependencies with ${packageManager}...`, "\x1B[0m");
+		runCmd(`${packageManager} install --loglevel error`);
+		console.log("\x1B[32m", "Dependencies installed successfully!", "\x1B[0m");
+		console.log();
+	} catch (error) {
+		console.log(error);
+		throw error;
+	}
+}
+//#endregion
+//#region src/templates/boilerplate/document-models/upgrade-manifests.ts
+const upgradeManifestsTemplate = ts$1`
+import type { UpgradeManifest } from "document-model";
+
+export const upgradeManifests: UpgradeManifest<readonly number[]>[] = [];
+`.raw;
+//#endregion
+//#region src/create-lib/create-project.ts
+async function createProject({ name, packageManager, tag, version, remoteDrive, skipGitInit, skipInstall }) {
+	const appPath = path.join(process.cwd(), name);
+	try {
+		fs$1.mkdirSync(appPath);
+	} catch (err) {
+		if (err.code === "EEXIST") console.error(`⛔ The folder "${name}" already exists in the current directory, please give it another name.`);
+		else console.error(err);
+		process.exit(1);
+	}
+	try {
+		console.log(chalk.blue(`▶️ Creating directory for project "${name}"...\n`));
+		const appPath = path.join(process.cwd(), name);
+		process.chdir(appPath);
+		console.log(chalk.green(`✅ Project directory created\n`));
+		await writeFileEnsuringDir(".gitignore", gitIgnoreTemplate);
+		if (!skipGitInit) {
+			console.log(chalk.blue(`▶️ Initializing git repository...\n`));
+			runCmd(`git init`);
+			console.log(chalk.green(`\n✅ Git repository initialized\n`));
+		}
+		console.log(chalk.blue(`▶️ Creating project boilerplate files...\n`));
+		await writeProjectRootFiles({
+			name,
+			tag,
+			version,
+			remoteDrive
+		});
+		await writeModuleFiles();
+		await writeAiConfigFiles();
+		await writeCIFiles();
+		console.log(chalk.green(`✅ Project boilerplate files created\n`));
+		if (!skipInstall) {
+			console.log(chalk.blue(`▶️ Installing project dependencies with ${packageManager}...\n`));
+			runCmd(`${packageManager} install`);
+			console.log(chalk.green(`\n✅ Project dependencies installed\n`));
+		}
+		console.log(chalk.blue(`▶️ Formatting boilerplate project files...\n`));
+		await runPrettier();
+		console.log(chalk.green(`✅ Boilerplate files formatted\n`));
+		console.log(chalk.bold(`🎉 Successfully created project "${name}" 🎉\n`));
+	} catch (error) {
+		console.error(error);
+		process.exit(1);
+	}
+}
+async function writeProjectRootFiles(args) {
+	const { name, tag, version, remoteDrive } = args;
+	await writeFileEnsuringDir("LICENSE", licenseTemplate);
+	await writeFileEnsuringDir("README.md", readmeTemplate);
+	await writeFileEnsuringDir(".npmrc", npmrcTemplate);
+	const packageJson = await buildBoilerplatePackageJson({
+		name,
+		tag,
+		version
+	});
+	await writeFileEnsuringDir("powerhouse.manifest.json", ManifestTemplate(name));
+	await writeFileEnsuringDir("powerhouse.config.json", await buildPowerhouseConfigTemplate({
+		tag,
+		version,
+		remoteDrive
+	}));
+	await writeFileEnsuringDir("package.json", packageJson);
+	await writeFileEnsuringDir("tsconfig.json", tsConfigTemplate);
+	await writeFileEnsuringDir("index.html", indexHtmlTemplate);
+	await writeFileEnsuringDir("main.tsx", mainTsxTemplate);
+	await writeFileEnsuringDir("eslint.config.js", eslintConfigTemplate);
+	await writeFileEnsuringDir("index.ts", indexTsTemplate);
+	await writeFileEnsuringDir("style.css", styleTemplate);
+	await writeFileEnsuringDir("vitest.config.ts", vitestConfigTemplate);
+}
+async function writeModuleFiles() {
+	await writeFileEnsuringDir("document-models/document-models.ts", documentModelsTemplate);
+	await writeFileEnsuringDir("document-models/index.ts", "");
+	await writeFileEnsuringDir("document-models/upgrade-manifests.ts", upgradeManifestsTemplate);
+	await writeFileEnsuringDir("editors/editors.ts", editorsTemplate);
+	await writeFileEnsuringDir("editors/index.ts", "");
+	await writeFileEnsuringDir("processors/factory.ts", processorsFactoryTemplate);
+	await writeFileEnsuringDir("processors/index.ts", processorsIndexTemplate);
+	await writeFileEnsuringDir("processors/connect.ts", factoryBuildersTemplate);
+	await writeFileEnsuringDir("processors/switchboard.ts", factoryBuildersTemplate);
+	await writeFileEnsuringDir("subgraphs/index.ts", "");
+	await writeFileEnsuringDir("processors/index.ts", processorsIndexTemplate);
+}
+async function writeAiConfigFiles() {
+	await writeFileEnsuringDir("CLAUDE.md", agentsTemplate);
+	await writeFileEnsuringDir("AGENTS.md", agentsTemplate);
+	await writeFileEnsuringDir(".mcp.json", mcpTemplate);
+	await writeFileEnsuringDir(".gemini/settings.json", geminiSettingsTemplate);
+	await writeFileEnsuringDir(".cursor/mcp.json", cursorMcpTemplate);
+	await writeFileEnsuringDir(".claude/settings.local.json", claudeSettingsLocalTemplate);
+}
+async function writeCIFiles() {
+	await writeFileEnsuringDir(".github/workflows/sync-and-publish.yml", syncAndPublishWorkflowTemplate);
+	await writeFileEnsuringDir("Dockerfile", dockerfileTemplate);
+	await writeFileEnsuringDir("docker/nginx.conf", nginxConfTemplate);
+	await writeFileEnsuringDir("docker/connect-entrypoint.sh", connectEntrypointTemplate);
+	await writeFileEnsuringDir("docker/switchboard-entrypoint.sh", switchboardEntrypointTemplate);
+}
+//#endregion
+//#region src/ts-morph-generator/core/FileGenerator.ts
+var FileGenerator = class {
+	constructor(importManager, directoryManager, declarationManager) {
+		this.importManager = importManager;
+		this.directoryManager = directoryManager;
+		this.declarationManager = declarationManager;
+	}
+};
+//#endregion
+//#region src/ts-morph-generator/core/ReducerGenerator.ts
+var ReducerGenerator = class ReducerGenerator extends FileGenerator {
+	async generate(context) {
+		if (context.operations.length === 0) return;
+		const filePath = this.getOutputPath(context);
+		const sourceFile = await this.directoryManager.createSourceFile(context.project, filePath);
+		const packageName = context.packageName;
+		const typeImportName = `${pascalCase(context.docModel.name)}${pascalCase(context.module.name)}Operations`;
+		const typeImportPath = `${packageName}/document-models/${kebabCase(context.docModel.name)}`;
+		this.importManager.replaceImportByName(sourceFile, typeImportName, typeImportPath, true);
+		this.createReducerObject(sourceFile, typeImportName, context);
+		this.addErrorImports(sourceFile, context);
+		await sourceFile.save();
+	}
+	static getDefaultReducerCode(methodName) {
+		return [`// TODO: Implement "${methodName}" reducer`, `throw new Error('Reducer "${methodName}" not yet implemented');`];
+	}
+	addErrorImports(sourceFile, context) {
+		const allErrors = [];
+		context.operations.forEach((operation) => {
+			if (Array.isArray(operation.errors)) operation.errors.filter((error) => error.name).forEach((error) => {
+				if (!allErrors.find((e) => e.name === error.name)) allErrors.push(error);
+			});
+		});
+		if (allErrors.length === 0) return;
+		const sourceFileContent = sourceFile.getFullText();
+		const usedErrors = /* @__PURE__ */ new Set();
+		allErrors.forEach((error) => {
+			if (new RegExp(`\\b${error.name}\\b`, "g").test(sourceFileContent)) usedErrors.add(error.name);
+		});
+		if (usedErrors.size > 0) {
+			const errorImportPath = `../../gen/${kebabCase(context.module.name)}/error.js`;
+			const errorClassNames = Array.from(usedErrors);
+			const existingErrorImport = sourceFile.getImportDeclarations().find((importDecl) => importDecl.getModuleSpecifierValue() === errorImportPath);
+			if (existingErrorImport) {
+				const existingNamedImports = existingErrorImport.getNamedImports().map((namedImport) => namedImport.getName());
+				const newErrorsToImport = errorClassNames.filter((errorName) => !existingNamedImports.includes(errorName));
+				if (newErrorsToImport.length > 0) existingErrorImport.addNamedImports(newErrorsToImport);
+			} else this.importManager.addNamedImports(sourceFile, errorClassNames, errorImportPath);
+		}
+	}
+	getOutputPath(context) {
+		return this.directoryManager.getReducerPath(context.rootDir, context.docModel.name, context.module.name);
+	}
+	createReducerObject(sourceFile, typeName, context) {
+		const { operations, forceUpdate } = context;
+		const operationHandlersObjectName = `${camelCase(context.docModel.name)}${pascalCase(context.module.name)}Operations`;
+		if (sourceFile.getVariableDeclaration("reducer")) this.declarationManager.renameVariable(sourceFile, "reducer", operationHandlersObjectName);
+		let reducerVar = sourceFile.getVariableDeclaration(operationHandlersObjectName);
+		if (!reducerVar) {
+			sourceFile.addVariableStatement({
+				declarationKind: VariableDeclarationKind.Const,
+				isExported: true,
+				declarations: [{
+					name: operationHandlersObjectName,
+					type: typeName,
+					initializer: "{}"
+				}]
+			});
+			reducerVar = sourceFile.getVariableDeclarationOrThrow(operationHandlersObjectName);
+		} else {
+			const typeNode = reducerVar.getTypeNode();
+			if (!typeNode || typeNode.getText() !== typeName) reducerVar.setType(typeName);
+		}
+		const initializer = reducerVar.getInitializerIfKindOrThrow(SyntaxKind.ObjectLiteralExpression);
+		for (const operation of operations) this.addReducerMethod(initializer, operation, forceUpdate);
+	}
+	addReducerMethod(objectLiteral, operation, forceUpdate = false) {
+		const actionName = camelCase(operation.name ?? "");
+		if (!actionName) return;
+		const methodName = `${actionName}Operation`;
+		const reducerCode = operation.reducer?.trim();
+		const existingReducer = objectLiteral.getProperty(methodName)?.asKind(SyntaxKind.MethodDeclaration);
+		if (existingReducer) {
+			if (forceUpdate && reducerCode) {
+				existingReducer.setBodyText("");
+				this.setReducerMethodCode(existingReducer, reducerCode);
+			}
+			return;
+		}
+		const method = objectLiteral.addMethod({
+			name: methodName,
+			parameters: [{ name: "state" }, { name: "action" }]
+		});
+		this.setReducerMethodCode(method, reducerCode);
+	}
+	setReducerMethodCode(reducer, code) {
+		reducer.addStatements(code ? [code] : ReducerGenerator.getDefaultReducerCode(reducer.getName()));
+	}
+};
+//#endregion
+//#region src/ts-morph-generator/utilities/DeclarationManager.ts
+var DeclarationManager = class {
+	renameVariable(sourceFile, oldName, newName) {
+		const variable = sourceFile.getVariableDeclaration(oldName);
+		if (variable) {
+			variable.getNameNode().replaceWithText(newName);
+			sourceFile.saveSync();
+		}
+	}
+};
+//#endregion
+//#region src/ts-morph-generator/utilities/DirectoryManager.ts
+var DirectoryManager = class {
+	directories = {
+		documentModelDir: "document-model",
+		editorsDir: "editors",
+		processorsDir: "processors",
+		subgraphsDir: "subgraphs"
+	};
+	constructor(directories = {}) {
+		this.directories = {
+			...this.directories,
+			...directories
+		};
+	}
+	async ensureExists(dirPath) {
+		try {
+			await fs$2.mkdir(dirPath, { recursive: true });
+		} catch (err) {
+			console.error(`Failed to create directory: ${dirPath}`, err);
+			throw err;
+		}
+	}
+	getReducerPath(rootDir, docModelName, moduleName) {
+		return path.join(rootDir, this.directories.documentModelDir, kebabCase(docModelName), "src", "reducers", `${kebabCase(moduleName)}.ts`);
+	}
+	getActionsPath(rootDir, docModelName, moduleName) {
+		return path.join(rootDir, this.directories.documentModelDir, kebabCase(docModelName), "src", "actions", `${kebabCase(moduleName)}.ts`);
+	}
+	getComponentPath(rootDir, docModelName, componentName) {
+		return path.join(rootDir, this.directories.documentModelDir, kebabCase(docModelName), "src", "components", `${pascalCase(componentName)}.tsx`);
+	}
+	getTypesPath(rootDir, docModelName) {
+		return path.join(rootDir, this.directories.documentModelDir, kebabCase(docModelName), "src", "types.ts");
+	}
+	async createSourceFile(project, filePath) {
+		await this.ensureExists(path.dirname(filePath));
+		return project.addSourceFileAtPathIfExists(filePath) ?? project.createSourceFile(filePath, "", { overwrite: false });
+	}
+};
+//#endregion
+//#region src/ts-morph-generator/utilities/ImportManager.ts
+var ImportManager = class {
+	addImport(sourceFile, spec) {
+		const existing = sourceFile.getImportDeclaration((imp) => imp.getFullText() === spec.moduleSpecifier);
+		if (existing) this.mergeImports(existing, spec);
+		else sourceFile.addImportDeclaration(spec);
+	}
+	addTypeImport(sourceFile, typeName, path) {
+		this.addImport(sourceFile, {
+			moduleSpecifier: path,
+			namedImports: [typeName],
+			isTypeOnly: true
+		});
+	}
+	addNamedImports(sourceFile, imports, path) {
+		this.addImport(sourceFile, {
+			moduleSpecifier: path,
+			namedImports: imports
+		});
+	}
+	mergeImports(existingImport, newSpec) {
+		if (newSpec.namedImports) {
+			const existingNames = existingImport.getNamedImports().map((ni) => ni.getName());
+			const newNames = newSpec.namedImports.filter((name) => !existingNames.includes(name));
+			if (newNames.length > 0) existingImport.addNamedImports(newNames);
+		}
+	}
+	replaceImportByName(sourceFile, name, path, isTypeOnly = false) {
+		sourceFile.getImportDeclarations().filter((imp) => imp.getNamedImports().find((ni) => ni.getName() === name)).forEach((imp) => imp.remove());
+		sourceFile.addImportDeclaration({
+			moduleSpecifier: path,
+			namedImports: [name],
+			isTypeOnly
+		});
+		sourceFile.saveSync();
+	}
+};
+//#endregion
+//#region src/ts-morph-generator/core/TSMorphCodeGenerator.ts
+var TSMorphCodeGenerator = class {
+	project = new Project();
+	generators = /* @__PURE__ */ new Map();
+	directories = {
+		documentModelDir: "document-model",
+		editorsDir: "editors",
+		processorsDir: "processors",
+		subgraphsDir: "subgraphs"
+	};
+	forceUpdate = false;
+	constructor(rootDir, docModels, packageName, options = {
+		directories: {},
+		forceUpdate: false
+	}) {
+		this.rootDir = rootDir;
+		this.docModels = docModels;
+		this.packageName = packageName;
+		this.directories = {
+			...this.directories,
+			...options.directories
+		};
+		this.packageName = packageName;
+		this.forceUpdate = options.forceUpdate ?? false;
+		this.setupGenerators();
+	}
+	setupGenerators() {
+		const importManager = new ImportManager();
+		const directoryManager = new DirectoryManager(this.directories);
+		const declarationManager = new DeclarationManager();
+		this.generators.set("reducers", new ReducerGenerator(importManager, directoryManager, declarationManager));
+	}
+	async generateReducers() {
+		await this.generateFileType("reducers");
+	}
+	async generateAll() {
+		for (const [type] of this.generators) await this.generateFileType(type);
+	}
+	async generateFileType(type) {
+		const generator = this.generators.get(type);
+		if (!generator) throw new Error(`No generator registered for type: ${type}`);
+		await this.setupProject();
+		for (const docModel of this.docModels) {
+			const latestSpec = docModel.specifications[docModel.specifications.length - 1];
+			for (const module of latestSpec.modules) {
+				const context = this.createGenerationContext(docModel, module, this.forceUpdate);
+				await generator.generate(context);
+			}
+		}
+	}
+	async setupProject() {
+		const sourcePaths = [];
+		if (this.directories.documentModelDir) {
+			const dirPath = `${this.rootDir}/${this.directories.documentModelDir}`;
+			await this.ensureDirectoryExists(dirPath);
+			sourcePaths.push(`${dirPath}/**/*.ts`);
+		}
+		if (this.directories.editorsDir) {
+			const dirPath = `${this.rootDir}/${this.directories.editorsDir}`;
+			await this.ensureDirectoryExists(dirPath);
+			sourcePaths.push(`${dirPath}/**/*.ts`);
+		}
+		if (this.directories.processorsDir) {
+			const dirPath = `${this.rootDir}/${this.directories.processorsDir}`;
+			await this.ensureDirectoryExists(dirPath);
+			sourcePaths.push(`${dirPath}/**/*.ts`);
+		}
+		if (this.directories.subgraphsDir) {
+			const dirPath = `${this.rootDir}/${this.directories.subgraphsDir}`;
+			await this.ensureDirectoryExists(dirPath);
+			sourcePaths.push(`${dirPath}/**/*.ts`);
+		}
+		sourcePaths.push(`!${this.rootDir}/**/node_modules/**`);
+		if (sourcePaths.length > 0) this.project.addSourceFilesAtPaths(sourcePaths);
+	}
+	createGenerationContext(docModel, module, forceUpdate = false) {
+		const operations = module.operations.map((op) => ({
+			...op,
+			hasInput: op.schema !== null,
+			hasAttachment: op.schema?.includes(": Attachment"),
+			scope: op.scope || "global",
+			state: op.scope === "global" ? "" : op.scope
+		}));
+		return {
+			rootDir: this.rootDir,
+			packageName: this.packageName,
+			docModel,
+			module,
+			project: this.project,
+			operations,
+			forceUpdate
+		};
+	}
+	async ensureDirectoryExists(dirPath) {
+		try {
+			await fs$2.mkdir(dirPath, { recursive: true });
+		} catch (err) {
+			console.error(`Failed to create directory: ${dirPath}`, err);
+			throw err;
+		}
+	}
+};
+//#endregion
+export { DeclarationManager, DirectoryManager, ImportManager, ReducerGenerator, TSMorphCodeGenerator, cloneRepository, configSpec, createProject, formatWithPrettierBeforeWrite, generate, generateAll, generateApp, generateDBSchema, generateDocumentModel, generateDocumentModelZodSchemas, generateEditor, generateFromDocument, generateFromFile, generateImportScript, generateManifest, generateProcessor, generateSchemas, generateSubgraph, generateSubgraphFromDocumentModel, generateTypesAndZodSchemasFromGraphql, getDocumentTypesMap, installDependencies, loadDocumentModel, parseArgs, parseConfig, scalars, scalarsValidation, validateDocumentModelState };
+
+//# sourceMappingURL=index.mjs.map