@tailor-platform/erp-kit 0.2.2 → 0.4.0

package/src/generator/generate-app-code.test.ts

@@ -0,0 +1,121 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { describe, expect, it, beforeEach, afterEach } from "vitest";
+import { runGenerateAppCode } from "./generate-app-code";
+
+describe("runGenerateAppCode", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "erp-kit-app-test-"));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("generates resolver stubs and tests from docs", () => {
+    // Set up docs
+    const docsDir = path.join(tmpDir, "docs", "resolver");
+    fs.mkdirSync(docsDir, { recursive: true });
+
+    fs.writeFileSync(
+      path.join(docsDir, "createItem.md"),
+      `# createItem
+
+## Overview
+
+Creates a new item.
+
+## Modules Commands Used
+
+- \`item-management.createItem\` — Creates a new item record
+
+## Exception Handling
+
+| Error Code | Description |
+| --- | --- |
+| DUPLICATE_SKU | SKU already exists |
+`,
+    );
+
+    fs.writeFileSync(
+      path.join(docsDir, "getMyProfile.md"),
+      `# getMyProfile
+
+## Overview
+
+Gets profile.
+
+## Modules Commands Used
+
+- \`user-management.getMyProfile\` — Fetches profile
+`,
+    );
+
+    const exitCode = runGenerateAppCode(tmpDir);
+    expect(exitCode).toBe(0);
+
+    const resolverDir = path.join(tmpDir, "backend", "src", "resolvers");
+    expect(fs.existsSync(resolverDir)).toBe(true);
+
+    const files = fs.readdirSync(resolverDir).sort();
+    // Template scaffolding may copy additional files (e.g. createUser.ts)
+    expect(files).toContain("createItem.test.ts");
+    expect(files).toContain("createItem.ts");
+    expect(files).toContain("getMyProfile.test.ts");
+    expect(files).toContain("getMyProfile.ts");
+    expect(files).not.toContain("createItem.generated.ts");
+
+    // Stub has createResolver
+    const stub = fs.readFileSync(path.join(resolverDir, "createItem.ts"), "utf-8");
+    expect(stub).toContain("createResolver");
+    expect(stub).toContain('name: "createItem"');
+    expect(stub).toContain('getDB("main-db")');
+
+    // Test stub exists
+    const test = fs.readFileSync(path.join(resolverDir, "createItem.test.ts"), "utf-8");
+    expect(test).toContain('describe("createItem"');
+  });
+
+  it("does not overwrite existing stubs on re-run", () => {
+    const docsDir = path.join(tmpDir, "docs", "resolver");
+    fs.mkdirSync(docsDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(docsDir, "createItem.md"),
+      `# createItem
+
+## Overview
+Creates an item.
+
+## Modules Commands Used
+- \`item-management.createItem\` — Creates item
+`,
+    );
+
+    runGenerateAppCode(tmpDir);
+
+    // Modify the stub
+    const resolverDir = path.join(tmpDir, "backend", "src", "resolvers");
+    const stubPath = path.join(resolverDir, "createItem.ts");
+    fs.writeFileSync(stubPath, "// custom implementation");
+
+    // Re-run
+    runGenerateAppCode(tmpDir);
+
+    // Stub should not be overwritten
+    expect(fs.readFileSync(stubPath, "utf-8")).toBe("// custom implementation");
+  });
+
+  it("returns 0 with no docs/resolver directory", () => {
+    const exitCode = runGenerateAppCode(tmpDir);
+    expect(exitCode).toBe(0);
+  });
+
+  it("returns 0 with empty docs/resolver directory", () => {
+    fs.mkdirSync(path.join(tmpDir, "docs", "resolver"), { recursive: true });
+    const exitCode = runGenerateAppCode(tmpDir);
+    expect(exitCode).toBe(0);
+  });
+});

package/src/generator/generate-app-code.ts

@@ -0,0 +1,51 @@
+import fs from "node:fs";
+import path from "node:path";
+import { parseResolverDoc } from "./parse-resolver-doc";
+import { generateResolverStub, generateResolverTestStub } from "./generate-stubs";
+import { scaffoldAppBoilerplate } from "./scaffold";
+
+export function runGenerateAppCode(appPath: string): number {
+  const appName = path.basename(appPath);
+  scaffoldAppBoilerplate(appPath, appName);
+
+  const docsDir = path.join(appPath, "docs", "resolver");
+  const resolverDir = path.join(appPath, "backend", "src", "resolvers");
+
+  if (!fs.existsSync(docsDir)) {
+    console.log(`No docs/resolver/ directory found — skipping resolver generation`);
+    console.log(`Generated boilerplate for ${appName}`);
+    return 0;
+  }
+
+  const mdFiles = fs.readdirSync(docsDir).filter((f) => f.endsWith(".md"));
+  if (mdFiles.length === 0) {
+    console.log(`No resolver docs found — skipping resolver generation`);
+    console.log(`Generated boilerplate for ${appName}`);
+    return 0;
+  }
+
+  fs.mkdirSync(resolverDir, { recursive: true });
+  let generated = 0;
+
+  for (const file of mdFiles) {
+    const content = fs.readFileSync(path.join(docsDir, file), "utf-8");
+    const fileName = path.basename(file, ".md");
+    const doc = parseResolverDoc(fileName, content);
+
+    const implFile = path.join(resolverDir, `${doc.resolverName}.ts`);
+    if (!fs.existsSync(implFile)) {
+      fs.writeFileSync(implFile, generateResolverStub(doc.resolverName));
+      console.log(`  scaffolded ${path.relative(appPath, implFile)}`);
+      generated++;
+    }
+
+    const testFile = path.join(resolverDir, `${doc.resolverName}.test.ts`);
+    if (!fs.existsSync(testFile)) {
+      fs.writeFileSync(testFile, generateResolverTestStub(doc.resolverName));
+      console.log(`  scaffolded ${path.relative(appPath, testFile)}`);
+    }
+  }
+
+  console.log(`Scaffolded ${generated} resolver(s) for ${appName}`);
+  return 0;
+}

package/src/{commands/scaffold.test.ts → generator/generate-code-boilerplate.test.ts}

@@ -2,88 +2,9 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { describe, it, expect, afterEach } from "vitest";
-import { resolveScaffoldPath, scaffoldModuleSrc, copyTemplateDir } from "./scaffold";
+import { copyTemplateDir, scaffoldModuleBoilerplate } from "./scaffold";
 
-describe("resolveScaffoldPath", () => {
-  // Module types
-  it("resolves module scaffold path", () => {
-    const result = resolveScaffoldPath("module", "inventory", undefined, "modules");
-    expect(result).toBe("modules/inventory/README.md");
-  });
-
-  it("resolves command scaffold path", () => {
-    const result = resolveScaffoldPath("command", "inventory", "CreateOrder", "modules");
-    expect(result).toBe("modules/inventory/docs/commands/CreateOrder.md");
-  });
-
-  it("resolves feature scaffold path", () => {
-    const result = resolveScaffoldPath("feature", "inventory", "stock-tracking", "modules");
-    expect(result).toBe("modules/inventory/docs/features/stock-tracking.md");
-  });
-
-  it("resolves model scaffold path", () => {
-    const result = resolveScaffoldPath("model", "inventory", "StockItem", "modules");
-    expect(result).toBe("modules/inventory/docs/models/StockItem.md");
-  });
-
-  // App-compose types
-  it("resolves app scaffold path", () => {
-    const result = resolveScaffoldPath("app", "my-app", undefined, "examples");
-    expect(result).toBe("examples/my-app/README.md");
-  });
-
-  it("resolves actors scaffold path", () => {
-    const result = resolveScaffoldPath("actors", "my-app", "admin", "examples");
-    expect(result).toBe("examples/my-app/docs/actors/admin.md");
-  });
-
-  it("resolves business-flow scaffold path", () => {
-    const result = resolveScaffoldPath("business-flow", "my-app", "onboarding", "examples");
-    expect(result).toBe("examples/my-app/docs/business-flow/onboarding/README.md");
-  });
-
-  it("resolves story scaffold path with flow/name format", () => {
-    const result = resolveScaffoldPath(
-      "story",
-      "my-app",
-      "onboarding/admin--create-user",
-      "examples",
-    );
-    expect(result).toBe(
-      "examples/my-app/docs/business-flow/onboarding/story/admin--create-user.md",
-    );
-  });
-
-  it("resolves screen scaffold path", () => {
-    const result = resolveScaffoldPath("screen", "my-app", "supplier-list", "examples");
-    expect(result).toBe("examples/my-app/docs/screen/supplier-list.md");
-  });
-
-  it("resolves resolver scaffold path", () => {
-    const result = resolveScaffoldPath("resolver", "my-app", "create-supplier", "examples");
-    expect(result).toBe("examples/my-app/docs/resolver/create-supplier.md");
-  });
-
-  it("resolves query scaffold path", () => {
-    const result = resolveScaffoldPath("query", "inventory", "ConvertQuantity", "modules");
-    expect(result).toBe("modules/inventory/docs/queries/ConvertQuantity.md");
-  });
-
-  // Validation
-  it("throws when name is required but missing", () => {
-    expect(() => resolveScaffoldPath("command", "inventory", undefined, "modules")).toThrow(
-      "Name is required",
-    );
-  });
-
-  it("throws when story name is not flow/name format", () => {
-    expect(() => resolveScaffoldPath("story", "my-app", "bad-name", "examples")).toThrow(
-      "Story name must be",
-    );
-  });
-});
-
-describe("scaffoldModuleSrc", () => {
+describe("scaffoldModuleBoilerplate", () => {
   let tmpDir: string;
 
   afterEach(() => {
@@ -97,19 +18,16 @@ describe("scaffoldModuleSrc", () => {
     const moduleDir = path.join(tmpDir, "test-module");
     fs.mkdirSync(moduleDir, { recursive: true });
 
-    scaffoldModuleSrc(moduleDir, "test-module");
+    scaffoldModuleBoilerplate(moduleDir, "test-module");
 
-    // Verify directories exist directly under module root (flat structure)
     for (const dir of ["db", "command", "executor", "generated", "lib", "query", "testing"]) {
       expect(fs.existsSync(path.join(moduleDir, dir))).toBe(true);
     }
 
-    // Verify .gitkeep in empty directories
     for (const dir of ["db", "command", "executor", "generated", "query"]) {
       expect(fs.existsSync(path.join(moduleDir, dir, ".gitkeep"))).toBe(true);
     }
 
-    // Verify starter files exist
     const expectedFiles = [
       "module.ts",
       "index.ts",
@@ -123,7 +41,6 @@ describe("scaffoldModuleSrc", () => {
       expect(fs.existsSync(path.join(moduleDir, file))).toBe(true);
     }
 
-    // Verify module name is used in content
     const permissions = fs.readFileSync(path.join(moduleDir, "permissions.ts"), "utf-8");
     expect(permissions).toContain('definePermissions("test-module"');
 
@@ -151,7 +68,6 @@ describe("copyTemplateDir", () => {
     const srcDir = path.join(tmpDir, "src");
     const destDir = path.join(tmpDir, "dest");
 
-    // Build a minimal fixture
     fs.mkdirSync(path.join(srcDir, "backend"), { recursive: true });
     fs.mkdirSync(path.join(srcDir, "frontend/src"), { recursive: true });
     fs.writeFileSync(
@@ -174,13 +90,11 @@ describe("copyTemplateDir", () => {
     const placeholderFiles = new Set(["package.json", "index.html"]);
     copyTemplateDir(srcDir, destDir, replacements, placeholderFiles);
 
-    // Files are copied
     expect(fs.existsSync(path.join(destDir, "backend/package.json"))).toBe(true);
     expect(fs.existsSync(path.join(destDir, "frontend/package.json"))).toBe(true);
     expect(fs.existsSync(path.join(destDir, "frontend/index.html"))).toBe(true);
     expect(fs.existsSync(path.join(destDir, "frontend/src/main.tsx"))).toBe(true);
 
-    // Placeholder replacement
     const backendPkg = fs.readFileSync(path.join(destDir, "backend/package.json"), "utf-8");
     expect(backendPkg).toContain('"name": "my-app"');
     expect(backendPkg).not.toContain("template-app-backend");
@@ -209,4 +123,20 @@ describe("copyTemplateDir", () => {
     expect(fs.existsSync(path.join(destDir, ".gitignore"))).toBe(true);
     expect(fs.existsSync(path.join(destDir, "__dot__gitignore"))).toBe(false);
   });
+
+  it("does not overwrite existing files", () => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "copy-template-test-"));
+    const srcDir = path.join(tmpDir, "src");
+    const destDir = path.join(tmpDir, "dest");
+
+    fs.mkdirSync(srcDir, { recursive: true });
+    fs.mkdirSync(destDir, { recursive: true });
+    fs.writeFileSync(path.join(srcDir, "file.txt"), "template content");
+    fs.writeFileSync(path.join(destDir, "file.txt"), "existing content");
+
+    copyTemplateDir(srcDir, destDir, {}, new Set());
+
+    const content = fs.readFileSync(path.join(destDir, "file.txt"), "utf-8");
+    expect(content).toBe("existing content");
+  });
 });

package/src/generator/generate-code.test.ts

@@ -1,13 +1,14 @@
 import { describe, expect, it } from "vitest";
+import { moduleNameToPrefix, generateErrors } from "./generate-errors";
+import { generatePermissions } from "./generate-permissions";
+import { generateCommandShell, generateQueryShell } from "./generate-shells";
 import {
-  generateErrors,
-  generatePermissions,
-  generateCommandShell,
-  generateQueryShell,
   generateQueryStub,
   generateQueryTestStub,
-  moduleNameToPrefix,
-} from "./generate-code";
+  generateDbStub,
+  generateResolverStub,
+  generateResolverTestStub,
+} from "./generate-stubs";
 import type { ParsedCommandDoc } from "./parse-command-doc";
 
 describe("moduleNameToPrefix", () => {
@@ -189,6 +190,29 @@ describe("generateQueryStub", () => {
   });
 });
 
+describe("generateDbStub", () => {
+  it("generates an empty db type definition with TODO", () => {
+    const result = generateDbStub("item");
+
+    expect(result).toContain(
+      "import { db, unsafeAllowAllGqlPermission, unsafeAllowAllTypePermission }",
+    );
+    expect(result).toContain("export const item = db");
+    expect(result).toContain('.type("Item"');
+    expect(result).toContain("// TODO: define fields");
+    expect(result).toContain("...db.fields.timestamps()");
+    expect(result).toContain(".permission(unsafeAllowAllTypePermission)");
+    expect(result).toContain(".gqlPermission(unsafeAllowAllGqlPermission)");
+  });
+
+  it("handles camelCase model names", () => {
+    const result = generateDbStub("taxonomyNode");
+
+    expect(result).toContain("export const taxonomyNode = db");
+    expect(result).toContain('.type("TaxonomyNode"');
+  });
+});
+
 describe("generateQueryTestStub", () => {
   it("generates a test stub with createMockDb and run import", () => {
     const doc: ParsedCommandDoc = {
@@ -209,3 +233,30 @@ describe("generateQueryTestStub", () => {
     expect(result).toContain("expect(result).toBeDefined();");
   });
 });
+
+describe("generateResolverStub", () => {
+  it("generates a createResolver stub with SDK imports and transaction boilerplate", () => {
+    const result = generateResolverStub("createItem");
+
+    expect(result).toContain('import { createResolver, t } from "@tailor-platform/sdk";');
+    expect(result).toContain('import { createContext } from "@tailor-platform/erp-kit/app";');
+    expect(result).toContain('import { getDB } from "@/generated/kysely-tailordb";');
+    expect(result).toContain('name: "createItem"');
+    expect(result).toContain('operation: "mutation"');
+    expect(result).toContain('getDB("main-db")');
+    expect(result).toContain("db.transaction().execute");
+    expect(result).toContain('.description("CreateItem response")');
+  });
+});
+
+describe("generateResolverTestStub", () => {
+  it("generates a test that imports and verifies the resolver", () => {
+    const result = generateResolverTestStub("createItem");
+
+    expect(result).toContain('import { describe, expect, it } from "vitest";');
+    expect(result).toContain('describe("createItem"');
+    expect(result).toContain('import("./createItem")');
+    expect(result).toContain("expect(resolver.default).toBeDefined()");
+    expect(result).toContain('expect(resolver.default.name).toBe("createItem")');
+  });
+});

package/src/generator/generate-code.ts

@@ -1,173 +1,36 @@
 import fs from "node:fs";
 import path from "node:path";
-import { parseCommandDoc, errorCodeToClassName, type ParsedCommandDoc } from "./parse-command-doc";
-
-export function moduleNameToPrefix(moduleName: string): string {
-  return moduleName.toUpperCase().replace(/-/g, "_");
-}
-
-export function generateErrors(moduleName: string, docs: ParsedCommandDoc[]): string {
-  const seen = new Set<string>();
-  const lines: string[] = [];
-  const prefix = moduleNameToPrefix(moduleName);
-
-  for (const doc of docs) {
-    for (const error of doc.errors) {
-      if (seen.has(error.code)) continue;
-      seen.add(error.code);
-
-      const className = errorCodeToClassName(error.code);
-      const prefixedCode = `${prefix}_${error.code}`;
-      lines.push(`export const ${className} = createDomainError(`);
-      lines.push(`  "${className}", "${prefixedCode}",`);
-      const escapedDesc = error.description.replace(/`/g, "'");
-      lines.push(`  (identifier: string) => \`${escapedDesc}: \${identifier}\`,`);
-      lines.push(`);`);
-      lines.push(``);
-    }
-  }
-
-  if (lines.length === 0) return "";
-
-  return `// @generated — do not edit
-import { createDomainError } from "../../../shared";
-
-${lines.join("\n")}`;
-}
-
-export function generateCommandStub(doc: ParsedCommandDoc): string {
-  const pascal = doc.commandName.charAt(0).toUpperCase() + doc.commandName.slice(1);
-  const inputType = `${pascal}Input`;
-
-  return `import { ok, type CommandContext } from "../../../shared";
-import type { Transaction } from "../generated/kysely-tailordb";
-
-export interface ${inputType} {
-  // TODO: define input fields
-}
-
-export async function run(db: Transaction, input: ${inputType}, ctx: CommandContext) {
-  // TODO: implement
-  return ok({});
-}
-`;
-}
-
-export function generateTestStub(doc: ParsedCommandDoc): string {
-  const pascal = doc.commandName.charAt(0).toUpperCase() + doc.commandName.slice(1);
-
-  return `import { describe, expect, it } from "vitest";
-import { createMockDb } from "../../../testing/index";
-import type { CommandContext } from "../../../shared";
-import type { Transaction } from "../generated/kysely-tailordb";
-import { run, ${pascal}Input } from "./${doc.commandName}";
-
-describe("${doc.commandName} - test scenario", () => {
-  const ctx: CommandContext = {
-    actorId: "test-actor",
-    permissions: ["TODO:${doc.commandName}"],
-  };
-
-  it("should be implemented", async () => {
-    const { db } = createMockDb<Transaction>();
-    const result = await run(db, {} as ${pascal}Input, ctx);
-    expect(result.ok).toBe(true);
-  });
-});
-`;
-}
-
-export function generateCommandShell(doc: ParsedCommandDoc): string {
-  const lines: string[] = [
-    `// @generated — do not edit`,
-    `import { defineCommand } from "../../../shared";`,
-    `import { permissions } from "../lib/permissions.generated";`,
-    `import { run } from "./${doc.commandName}";`,
-    ``,
-    `export const ${doc.commandName} = defineCommand(permissions.${doc.commandName}, run);`,
-    ``,
-  ];
-
-  return lines.join("\n");
-}
-
-export function generateQueryShell(doc: ParsedCommandDoc): string {
-  const lines: string[] = [
-    `// @generated — do not edit`,
-    `import { defineQuery } from "../../../shared";`,
-    `import { run } from "./${doc.commandName}";`,
-    ``,
-    `export const ${doc.commandName} = defineQuery(run);`,
-    ``,
-  ];
-
-  return lines.join("\n");
-}
-
-export function generateQueryStub(doc: ParsedCommandDoc): string {
-  const pascal = doc.commandName.charAt(0).toUpperCase() + doc.commandName.slice(1);
-  const inputType = `${pascal}Input`;
-
-  return `import type { ReadonlyDB } from "../../../shared";
-import type { DB } from "../generated/kysely-tailordb";
-
-export interface ${inputType} {
-  // TODO: define input fields
-}
-
-export async function run(db: ReadonlyDB<DB>, input: ${inputType}) {
-  // TODO: implement
-  return {};
-}
-`;
-}
-
-export function generateQueryTestStub(doc: ParsedCommandDoc): string {
-  const pascal = doc.commandName.charAt(0).toUpperCase() + doc.commandName.slice(1);
-  const inputType = `${pascal}Input`;
-
-  return `import { describe, expect, it } from "vitest";
-import { createMockDb } from "../../../testing/index";
-import type { DB } from "../generated/kysely-tailordb";
-import { run, type ${inputType} } from "./${doc.commandName}";
-
-describe("${doc.commandName}", () => {
-  it("should be implemented", async () => {
-    const { db } = createMockDb<DB>();
-    const result = await run(db, {} as ${inputType});
-    expect(result).toBeDefined();
-  });
-});
-`;
-}
-
-export function generatePermissions(moduleName: string, commandNames: string[]): string {
-  const sorted = [...commandNames].sort();
-  const entries = sorted.map((name) => `  "${name}",`).join("\n");
-
-  return `// @generated — do not edit
-import { definePermissions } from "../../../shared";
-
-export const { permissions, own, all } = definePermissions("${moduleName}", [
-${entries}
-] as const);
-`;
-}
+import { parseCommandDoc, type ParsedCommandDoc } from "./parse-command-doc";
+import { generateErrors } from "./generate-errors";
+import { generatePermissions } from "./generate-permissions";
+import { generateCommandShell, generateQueryShell } from "./generate-shells";
+import {
+  generateCommandStub,
+  generateTestStub,
+  generateQueryStub,
+  generateQueryTestStub,
+  generateDbStub,
+} from "./generate-stubs";
+import { scaffoldModuleBoilerplate } from "./scaffold";
 
 export function runGenerateCode(modulePath: string, moduleName: string): number {
+  scaffoldModuleBoilerplate(modulePath, moduleName);
+
   const docsDir = path.join(modulePath, "docs", "commands");
   const libDir = path.join(modulePath, "lib");
   const commandDir = path.join(modulePath, "command");
 
   if (!fs.existsSync(docsDir)) {
-    console.error(`No docs/commands/ directory found at ${docsDir}`);
-    return 1;
+    console.log(`No docs/commands/ directory found — skipping code generation`);
+    console.log(`Generated boilerplate for ${moduleName}`);
+    return 0;
   }
 
   const mdFiles = fs.readdirSync(docsDir).filter((f) => f.endsWith(".md"));
   if (mdFiles.length === 0) {
-    console.error(`No command docs found in ${docsDir}`);
-    return 1;
+    console.log(`No command docs found — skipping code generation`);
+    console.log(`Generated boilerplate for ${moduleName}`);
+    return 0;
   }
 
   const parsedDocs: ParsedCommandDoc[] = [];
@@ -261,6 +124,26 @@ export function runGenerateCode(modulePath: string, moduleName: string): number
     }
   }
 
+  // Generate db stubs from docs/models/*.md
+  const modelDocsDir = path.join(modulePath, "docs", "models");
+  if (fs.existsSync(modelDocsDir)) {
+    const modelFiles = fs.readdirSync(modelDocsDir).filter((f) => f.endsWith(".md"));
+    if (modelFiles.length > 0) {
+      const dbDir = path.join(modulePath, "db");
+      fs.mkdirSync(dbDir, { recursive: true });
+
+      for (const file of modelFiles) {
+        const modelName = path.basename(file, ".md");
+        const camelName = modelName.charAt(0).toLowerCase() + modelName.slice(1);
+        const dbFile = path.join(dbDir, `${camelName}.ts`);
+        if (!fs.existsSync(dbFile)) {
+          fs.writeFileSync(dbFile, generateDbStub(camelName));
+          console.log(`  scaffolded ${path.relative(modulePath, dbFile)}`);
+        }
+      }
+    }
+  }
+
   console.log(`Generated ${generated} file(s) for ${moduleName}`);
   return 0;
 }

package/src/generator/generate-errors.ts

@@ -0,0 +1,34 @@
+import { errorCodeToClassName, type ParsedCommandDoc } from "./parse-command-doc";
+
+export function moduleNameToPrefix(moduleName: string): string {
+  return moduleName.toUpperCase().replace(/-/g, "_");
+}
+
+export function generateErrors(moduleName: string, docs: ParsedCommandDoc[]): string {
+  const seen = new Set<string>();
+  const lines: string[] = [];
+  const prefix = moduleNameToPrefix(moduleName);
+
+  for (const doc of docs) {
+    for (const error of doc.errors) {
+      if (seen.has(error.code)) continue;
+      seen.add(error.code);
+
+      const className = errorCodeToClassName(error.code);
+      const prefixedCode = `${prefix}_${error.code}`;
+      lines.push(`export const ${className} = createDomainError(`);
+      lines.push(`  "${className}", "${prefixedCode}",`);
+      const escapedDesc = error.description.replace(/`/g, "'");
+      lines.push(`  (identifier: string) => \`${escapedDesc}: \${identifier}\`,`);
+      lines.push(`);`);
+      lines.push(``);
+    }
+  }
+
+  if (lines.length === 0) return "";
+
+  return `// @generated — do not edit
+import { createDomainError } from "../../../shared";
+
+${lines.join("\n")}`;
+}

package/src/generator/generate-permissions.ts

@@ -0,0 +1,12 @@
+export function generatePermissions(moduleName: string, commandNames: string[]): string {
+  const sorted = [...commandNames].sort();
+  const entries = sorted.map((name) => `  "${name}",`).join("\n");
+
+  return `// @generated — do not edit
+import { definePermissions } from "../../../shared";
+
+export const { permissions, own, all } = definePermissions("${moduleName}", [
+${entries}
+] as const);
+`;
+}