@tailor-platform/erp-kit 0.3.0 → 0.4.1

package/src/commands/mock/index.ts

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { defineCommand, arg } from "politty";
+import { executeCommand, success, silentFailure } from "../lib/command-result";
 import { runMockStart } from "./start";
 import { runMockValidate } from "./validate";
 
@@ -19,9 +20,11 @@ const startCommand = defineCommand({
       description: "Filter by provider or provider/scenario",
     }),
   }),
-  run: async (args) => {
-    const exitCode = await runMockStart(args.mocksRoot, args.filter, args.port);
-    process.exit(exitCode);
+  run: (args) => {
+    return executeCommand(async () => {
+      const exitCode = await runMockStart(args.mocksRoot, args.filter, args.port);
+      return exitCode === 0 ? success() : silentFailure(exitCode);
+    });
   },
 });
 
@@ -37,9 +40,11 @@ const validateCommand = defineCommand({
       description: "Specific scenario paths to validate",
     }),
   }),
-  run: async (args) => {
-    const exitCode = await runMockValidate(args.mocksRoot, args.paths);
-    process.exit(exitCode);
+  run: (args) => {
+    return executeCommand(async () => {
+      const exitCode = await runMockValidate(args.mocksRoot, args.paths);
+      return exitCode === 0 ? success() : silentFailure(exitCode);
+    });
   },
 });
 

package/src/commands/module/generate.ts

@@ -3,6 +3,7 @@ import { defineCommand, arg } from "politty";
 import { z } from "zod";
 import { runGenerateCode } from "../../generator/generate-code";
 import { runGenerateDoc, MODULE_DOC_TYPES, type DocType } from "../generate-doc";
+import { executeCommand, success, silentFailure } from "../lib/command-result";
 
 const cwd = process.cwd();
 
@@ -26,9 +27,11 @@ const docCommand = defineCommand({
       description: "Item name (required for all types)",
     }),
   }),
-  run: async (args) => {
-    const exitCode = await runGenerateDoc(args.type as DocType, args.name, args.path, cwd);
-    process.exit(exitCode);
+  run: (args) => {
+    return executeCommand(async () => {
+      const exitCode = await runGenerateDoc(args.type as DocType, args.name, args.path, cwd);
+      return exitCode === 0 ? success() : silentFailure(exitCode);
+    });
   },
 });
 
@@ -37,11 +40,13 @@ const codeCommand = defineCommand({
   description: "Generate boilerplate, implementation stubs, and generated code from docs",
   args: pathArgs,
   run: (args) => {
-    const modulePath = path.resolve(cwd, args.path);
-    const moduleName = path.basename(modulePath);
-    console.log(`Generating code for ${moduleName}...`);
-    const exitCode = runGenerateCode(modulePath, moduleName);
-    process.exit(exitCode);
+    return executeCommand(() => {
+      const modulePath = path.resolve(cwd, args.path);
+      const moduleName = path.basename(modulePath);
+      console.log(`Generating code for ${moduleName}...`);
+      const exitCode = runGenerateCode(modulePath, moduleName);
+      return exitCode === 0 ? success() : silentFailure(exitCode);
+    });
   },
 });
 

package/src/commands/module/index.ts

@@ -2,9 +2,9 @@ import { z } from "zod";
 import { defineCommand, arg } from "politty";
 import { runCheck } from "../check";
 import { runInitModuleWithReadme } from "../init-module";
+import { executeCommand, success, silentFailure } from "../lib/command-result";
 import { runSyncCheck, formatSyncCheckReport } from "../sync-check";
 import { generateCommand } from "./generate";
-import { runModuleList } from "./list";
 
 const cwd = process.cwd();
 
@@ -15,22 +15,15 @@ const pathArgs = z.object({
   }),
 });
 
-const listCommand = defineCommand({
-  name: "list",
-  description: "List available modules",
-  run: () => {
-    const exitCode = runModuleList();
-    process.exit(exitCode);
-  },
-});
-
 const checkCommand = defineCommand({
   name: "check",
   description: "Validate module docs against schemas",
   args: pathArgs,
-  run: async (args) => {
-    const exitCode = await runCheck({ modulesRoot: args.path }, cwd);
-    process.exit(exitCode);
+  run: (args) => {
+    return executeCommand(async () => {
+      const exitCode = await runCheck({ modulesRoot: args.path }, cwd);
+      return exitCode === 0 ? success() : silentFailure(exitCode);
+    });
   },
 });
 
@@ -38,10 +31,12 @@ const syncCheckCommand = defineCommand({
   name: "sync-check",
   description: "Validate source <-> doc correspondence",
   args: pathArgs,
-  run: async (args) => {
-    const result = await runSyncCheck({ modulesRoot: args.path }, cwd);
-    console.log(formatSyncCheckReport(result));
-    process.exit(result.exitCode);
+  run: (args) => {
+    return executeCommand(async () => {
+      const result = await runSyncCheck({ modulesRoot: args.path }, cwd);
+      console.log(formatSyncCheckReport(result));
+      return result.exitCode === 0 ? success() : silentFailure(result.exitCode);
+    });
   },
 });
 
@@ -58,9 +53,11 @@ const initCommand = defineCommand({
       description: "Parent directory where the module will be created",
     }),
   }),
-  run: async (args) => {
-    const exitCode = await runInitModuleWithReadme(args.name, args.dir, cwd);
-    process.exit(exitCode);
+  run: (args) => {
+    return executeCommand(async () => {
+      const exitCode = await runInitModuleWithReadme(args.name, args.dir, cwd);
+      return exitCode === 0 ? success() : silentFailure(exitCode);
+    });
   },
 });
 
@@ -68,7 +65,6 @@ export const moduleCommand = defineCommand({
   name: "module",
   description: "Module management",
   subCommands: {
-    list: listCommand,
     check: checkCommand,
     "sync-check": syncCheckCommand,
     init: initCommand,

package/src/commands/parse-doc-test-cases.ts

@@ -43,13 +43,24 @@ export function parseTestCasesFromDoc(markdown: string): string[] {
 /**
  * Parse `it("...")` descriptions from a test file using regex.
  * Test files are not Markdown, so regex is appropriate here.
+ * Uses separate patterns per quote type so that e.g. an apostrophe
+ * inside a double-quoted string does not end the match early.
  */
 export function parseItDescriptionsFromTest(content: string): string[] {
   const descriptions: string[] = [];
-  const regex = /\bit\(\s*["'`]([^"'`]+)["'`]/g;
+  const regex = /\bit\(\s*"([^"]+)"/gs;
   let match: RegExpExecArray | null;
   while ((match = regex.exec(content)) !== null) {
-    descriptions.push(match[1]);
+    descriptions.push(match[1].replace(/\s+/g, " ").trim());
+  }
+  // Also match single-quoted and backtick-quoted descriptions
+  const singleQuoteRegex = /\bit\(\s*'([^']+)'/gs;
+  while ((match = singleQuoteRegex.exec(content)) !== null) {
+    descriptions.push(match[1].replace(/\s+/g, " ").trim());
+  }
+  const backtickRegex = /\bit\(\s*`([^`]+)`/gs;
+  while ((match = backtickRegex.exec(content)) !== null) {
+    descriptions.push(match[1].replace(/\s+/g, " ").trim());
   }
   return descriptions;
 }

package/src/commands/sync-check.test.ts

@@ -2,384 +2,26 @@ import path from "node:path";
 import os from "node:os";
 import fs from "node:fs";
 import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { runSyncCheck, checkStaleness } from "./sync-check";
-import { parseTestCasesFromDoc, parseItDescriptionsFromTest } from "./parse-doc-test-cases";
+import { runSyncCheck } from "./sync-check";
 
-describe("runSyncCheck", () => {
+describe("runSyncCheck (integration)", () => {
   let tmpDir: string;
 
   beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "sync-check-"));
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "sync-check-int-"));
   });
 
   afterEach(() => {
     fs.rmSync(tmpDir, { recursive: true, force: true });
   });
 
-  it("returns 0 for an empty directory with no sources or docs", async () => {
-    const result = await runSyncCheck({ modulesRoot: "modules", appRoot: "examples" }, tmpDir);
-    expect(result.exitCode).toBe(0);
-    expect(result.errors).toHaveLength(0);
-  });
-
-  it("reports missing doc when source exists without doc", async () => {
-    const srcDir = path.join(tmpDir, "modules", "foo", "command");
-    fs.mkdirSync(srcDir, { recursive: true });
-    fs.writeFileSync(path.join(srcDir, "createOrder.ts"), "export {}");
-
-    const result = await runSyncCheck({ modulesRoot: "modules", appRoot: "examples" }, tmpDir);
-    expect(result.exitCode).toBe(1);
-    expect(result.errors).toContainEqual(
-      expect.objectContaining({ type: "missing-doc", expectedBasename: "createorder" }),
-    );
-  });
-
-  it("reports orphaned doc when doc exists without source", async () => {
-    const docDir = path.join(tmpDir, "modules", "foo", "docs", "commands");
-    fs.mkdirSync(docDir, { recursive: true });
-    fs.writeFileSync(path.join(docDir, "createOrder.md"), "# CreateOrder");
-
-    const result = await runSyncCheck({ modulesRoot: "modules", appRoot: "examples" }, tmpDir);
-    expect(result.exitCode).toBe(1);
-    expect(result.errors).toContainEqual(
-      expect.objectContaining({ type: "orphaned-doc", expectedBasename: "createorder" }),
-    );
-  });
-
-  it("returns 0 when source and doc match", async () => {
-    const srcDir = path.join(tmpDir, "modules", "foo", "command");
-    const docDir = path.join(tmpDir, "modules", "foo", "docs", "commands");
-    fs.mkdirSync(srcDir, { recursive: true });
-    fs.mkdirSync(docDir, { recursive: true });
-    fs.writeFileSync(path.join(srcDir, "createOrder.ts"), "export {}");
-    fs.writeFileSync(path.join(docDir, "createOrder.md"), "# CreateOrder");
-
-    const result = await runSyncCheck({ modulesRoot: "modules", appRoot: "examples" }, tmpDir);
-    expect(result.exitCode).toBe(0);
-    expect(result.errors).toHaveLength(0);
-  });
-
-  it("excludes test files from source matching", async () => {
-    const srcDir = path.join(tmpDir, "modules", "foo", "command");
-    fs.mkdirSync(srcDir, { recursive: true });
-    fs.writeFileSync(path.join(srcDir, "createOrder.test.ts"), "test()");
-
-    const result = await runSyncCheck({ modulesRoot: "modules", appRoot: "examples" }, tmpDir);
-    expect(result.exitCode).toBe(0);
-    expect(result.errors).toHaveLength(0);
-  });
-
-  it("uses custom modulesRoot to rewrite glob patterns", async () => {
-    const srcDir = path.join(tmpDir, "custom-mods", "foo", "command");
-    const docDir = path.join(tmpDir, "custom-mods", "foo", "docs", "commands");
-    fs.mkdirSync(srcDir, { recursive: true });
-    fs.mkdirSync(docDir, { recursive: true });
-    fs.writeFileSync(path.join(srcDir, "createOrder.ts"), "export {}");
-    fs.writeFileSync(path.join(docDir, "createOrder.md"), "# CreateOrder");
-
-    const result = await runSyncCheck({ modulesRoot: "custom-mods" }, tmpDir);
-    expect(result.exitCode).toBe(0);
-    expect(result.summary.totalSources).toBe(1);
-  });
-
-  it("uses custom appRoot to rewrite glob patterns", async () => {
-    const srcDir = path.join(
-      tmpDir,
-      "apps",
-      "app1",
-      "backend",
-      "src",
-      "modules",
-      "m1",
-      "resolvers",
-    );
-    const docDir = path.join(tmpDir, "apps", "app1", "docs", "resolver");
-    fs.mkdirSync(srcDir, { recursive: true });
-    fs.mkdirSync(docDir, { recursive: true });
-    fs.writeFileSync(path.join(srcDir, "myResolver.ts"), "export {}");
-    fs.writeFileSync(path.join(docDir, "myResolver.md"), "# MyResolver");
-
-    const result = await runSyncCheck({ appRoot: "apps" }, tmpDir);
-    expect(result.exitCode).toBe(0);
-    expect(result.summary.totalSources).toBe(1);
-  });
-
-  it("reports missing doc for query source without doc", async () => {
-    const srcDir = path.join(tmpDir, "modules", "foo", "query");
-    fs.mkdirSync(srcDir, { recursive: true });
-    fs.writeFileSync(path.join(srcDir, "convertAmount.ts"), "export {}");
-
-    const result = await runSyncCheck({ modulesRoot: "modules", appRoot: "examples" }, tmpDir);
-    expect(result.exitCode).toBe(1);
-    expect(result.errors).toContainEqual(
-      expect.objectContaining({
-        type: "missing-doc",
-        category: "query",
-        expectedBasename: "convertamount",
-      }),
-    );
-  });
-
-  it("returns 0 when query source and doc match", async () => {
-    const srcDir = path.join(tmpDir, "modules", "foo", "query");
-    const docDir = path.join(tmpDir, "modules", "foo", "docs", "queries");
-    fs.mkdirSync(srcDir, { recursive: true });
-    fs.mkdirSync(docDir, { recursive: true });
-    fs.writeFileSync(path.join(srcDir, "convertAmount.ts"), "export {}");
-    fs.writeFileSync(path.join(docDir, "convertAmount.md"), "# ConvertAmount");
-
-    const result = await runSyncCheck({ modulesRoot: "modules", appRoot: "examples" }, tmpDir);
-    expect(result.exitCode).toBe(0);
-  });
-
-  it("matches generated query files to docs by stripping .generated suffix", async () => {
-    const srcDir = path.join(tmpDir, "modules", "foo", "query");
-    const docDir = path.join(tmpDir, "modules", "foo", "docs", "queries");
-    fs.mkdirSync(srcDir, { recursive: true });
-    fs.mkdirSync(docDir, { recursive: true });
-    fs.writeFileSync(path.join(srcDir, "getCurrency.generated.ts"), "export {}");
-    fs.writeFileSync(path.join(docDir, "GetCurrency.md"), "# GetCurrency");
-
-    const result = await runSyncCheck({ modulesRoot: "modules", appRoot: "examples" }, tmpDir);
-    expect(result.exitCode).toBe(0);
-    expect(result.errors).toHaveLength(0);
-  });
-
-  it("excludes generated command files from source matching", async () => {
+  it("combines source sync and test case sync errors", async () => {
     const srcDir = path.join(tmpDir, "modules", "foo", "command");
-    const docDir = path.join(tmpDir, "modules", "foo", "docs", "commands");
     fs.mkdirSync(srcDir, { recursive: true });
-    fs.mkdirSync(docDir, { recursive: true });
     fs.writeFileSync(path.join(srcDir, "createOrder.ts"), "export {}");
-    fs.writeFileSync(path.join(srcDir, "createOrder.generated.ts"), "export {}");
-    fs.writeFileSync(path.join(docDir, "createOrder.md"), "# CreateOrder");
-
-    const result = await runSyncCheck({ modulesRoot: "modules", appRoot: "examples" }, tmpDir);
-    expect(result.exitCode).toBe(0);
-  });
-
-  it("checks only module patterns when appRoot is not set", async () => {
-    const resolverSrcDir = path.join(
-      tmpDir,
-      "examples",
-      "app1",
-      "backend",
-      "src",
-      "modules",
-      "m1",
-      "resolvers",
-    );
-    fs.mkdirSync(resolverSrcDir, { recursive: true });
-    fs.writeFileSync(path.join(resolverSrcDir, "myResolver.ts"), "export {}");
-
-    const result = await runSyncCheck({ modulesRoot: "modules", appRoot: undefined }, tmpDir);
-    // Without appRoot, app-compose patterns are not checked
-    expect(result.exitCode).toBe(0);
-    expect(result.errors).toHaveLength(0);
-  });
-});
-
-describe("parseTestCasesFromDoc", () => {
-  it("extracts test cases from ## Test Cases section", () => {
-    const content = `# CreateProduct
-
-## Error Scenarios
-
-- **DUPLICATE_CODE**: A product with the same code already exists
-
-## Test Cases
-
-- returns error when code is empty
-- creates product in DRAFT status
-- passes custom fields through
-`;
-    const cases = parseTestCasesFromDoc(content);
-    expect(cases).toEqual([
-      "returns error when code is empty",
-      "creates product in DRAFT status",
-      "passes custom fields through",
-    ]);
-  });
-
-  it("returns empty array when no Test Cases section", () => {
-    const content = `# CreateProduct\n\n## Overview\n\nSome text.`;
-    expect(parseTestCasesFromDoc(content)).toEqual([]);
-  });
-
-  it("stops at next ## heading", () => {
-    const content = `## Test Cases
-
-- case one
-- case two
-
-## Other Section
-
-- not a test case
-`;
-    expect(parseTestCasesFromDoc(content)).toEqual(["case one", "case two"]);
-  });
-});
-
-describe("parseItDescriptionsFromTest", () => {
-  it("extracts it() descriptions from test file", () => {
-    const content = `
-describe("createProduct", () => {
-  it("returns error when code is empty", async () => {});
-  it("creates product in DRAFT status", async () => {});
-  it('passes custom fields through', async () => {});
-});`;
-    const descriptions = parseItDescriptionsFromTest(content);
-    expect(descriptions).toEqual([
-      "returns error when code is empty",
-      "creates product in DRAFT status",
-      "passes custom fields through",
-    ]);
-  });
-
-  it("returns empty array when no it() blocks", () => {
-    expect(parseItDescriptionsFromTest("const x = 1;")).toEqual([]);
-  });
-});
-
-describe("runSyncCheck test-case sync", () => {
-  let tmpDir: string;
-
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "sync-check-tc-"));
-  });
-
-  afterEach(() => {
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  it("reports missing-test-case when doc has case not in test", async () => {
-    const docDir = path.join(tmpDir, "modules", "foo", "docs", "commands");
-    const testDir = path.join(tmpDir, "modules", "foo", "command");
-    fs.mkdirSync(docDir, { recursive: true });
-    fs.mkdirSync(testDir, { recursive: true });
-
-    fs.writeFileSync(
-      path.join(docDir, "CreateOrder.md"),
-      "# CreateOrder\n\n## Test Cases\n\n- creates order\n- validates input\n",
-    );
-    fs.writeFileSync(path.join(testDir, "createOrder.ts"), "export {}");
-    fs.writeFileSync(
-      path.join(testDir, "createOrder.test.ts"),
-      'describe("createOrder", () => { it("creates order", async () => {}); });',
-    );
 
     const result = await runSyncCheck({ modulesRoot: "modules" }, tmpDir);
-    expect(result.errors).toContainEqual(
-      expect.objectContaining({
-        type: "missing-test-case",
-        category: "command-test-case",
-        expectedBasename: "validates input",
-      }),
-    );
-  });
-
-  it("reports extra-test-case when test has case not in doc", async () => {
-    const docDir = path.join(tmpDir, "modules", "foo", "docs", "commands");
-    const testDir = path.join(tmpDir, "modules", "foo", "command");
-    fs.mkdirSync(docDir, { recursive: true });
-    fs.mkdirSync(testDir, { recursive: true });
-
-    fs.writeFileSync(
-      path.join(docDir, "CreateOrder.md"),
-      "# CreateOrder\n\n## Test Cases\n\n- creates order\n",
-    );
-    fs.writeFileSync(path.join(testDir, "createOrder.ts"), "export {}");
-    fs.writeFileSync(
-      path.join(testDir, "createOrder.test.ts"),
-      'describe("createOrder", () => { it("creates order", async () => {}); it("extra case", async () => {}); });',
-    );
-
-    const result = await runSyncCheck({ modulesRoot: "modules" }, tmpDir);
-    expect(result.errors).toContainEqual(
-      expect.objectContaining({
-        type: "extra-test-case",
-        category: "command-test-case",
-        expectedBasename: "extra case",
-      }),
-    );
-  });
-
-  it("returns 0 when doc test cases match test it() descriptions", async () => {
-    const docDir = path.join(tmpDir, "modules", "foo", "docs", "commands");
-    const testDir = path.join(tmpDir, "modules", "foo", "command");
-    fs.mkdirSync(docDir, { recursive: true });
-    fs.mkdirSync(testDir, { recursive: true });
-
-    fs.writeFileSync(
-      path.join(docDir, "CreateOrder.md"),
-      "# CreateOrder\n\n## Test Cases\n\n- creates order\n- validates input\n",
-    );
-    fs.writeFileSync(path.join(testDir, "createOrder.ts"), "export {}");
-    fs.writeFileSync(
-      path.join(testDir, "createOrder.test.ts"),
-      'describe("createOrder", () => { it("creates order", async () => {}); it("validates input", async () => {}); });',
-    );
-
-    const result = await runSyncCheck({ modulesRoot: "modules" }, tmpDir);
-    const tcErrors = result.errors.filter(
-      (e) => e.type === "missing-test-case" || e.type === "extra-test-case",
-    );
-    expect(tcErrors).toHaveLength(0);
-  });
-
-  it("skips test-case check when doc has no Test Cases section", async () => {
-    const docDir = path.join(tmpDir, "modules", "foo", "docs", "commands");
-    const testDir = path.join(tmpDir, "modules", "foo", "command");
-    fs.mkdirSync(docDir, { recursive: true });
-    fs.mkdirSync(testDir, { recursive: true });
-
-    fs.writeFileSync(
-      path.join(docDir, "CreateOrder.md"),
-      "# CreateOrder\n\n## Overview\n\nSome text.\n",
-    );
-    fs.writeFileSync(path.join(testDir, "createOrder.ts"), "export {}");
-    fs.writeFileSync(
-      path.join(testDir, "createOrder.test.ts"),
-      'describe("createOrder", () => { it("creates order", async () => {}); });',
-    );
-
-    const result = await runSyncCheck({ modulesRoot: "modules" }, tmpDir);
-    const tcErrors = result.errors.filter(
-      (e) => e.type === "missing-test-case" || e.type === "extra-test-case",
-    );
-    expect(tcErrors).toHaveLength(0);
-  });
-});
-
-describe("checkStaleness", () => {
-  it("reports stale when doc mtime > generated mtime", () => {
-    const errors = checkStaleness(
-      [{ docPath: "docs/commands/CreateItem.md", docMtime: 2000 }],
-      [{ genPath: "lib/errors.generated.ts", genMtime: 1000 }],
-    );
-
-    expect(errors).toHaveLength(1);
-    expect(errors[0].type).toBe("stale-generation");
-  });
-
-  it("reports no staleness when generated is newer", () => {
-    const errors = checkStaleness(
-      [{ docPath: "docs/commands/CreateItem.md", docMtime: 1000 }],
-      [{ genPath: "lib/errors.generated.ts", genMtime: 2000 }],
-    );
-
-    expect(errors).toHaveLength(0);
-  });
-
-  it("returns empty when no generated files", () => {
-    const errors = checkStaleness([{ docPath: "docs/commands/CreateItem.md", docMtime: 1000 }], []);
-
-    expect(errors).toHaveLength(0);
-  });
-
-  it("returns empty when no doc files", () => {
-    const errors = checkStaleness([], [{ genPath: "lib/errors.generated.ts", genMtime: 1000 }]);
-
-    expect(errors).toHaveLength(0);
+    expect(result.exitCode).toBe(1);
+    expect(result.errors.some((e) => e.type === "missing-doc")).toBe(true);
   });
 });