gencow 0.1.135 → 0.1.136

package/bin/gencow.mjs

@@ -75,9 +75,7 @@ import { platformFetch, requireCreds, rpcMutation, rpcQuery } from "../lib/platf
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const _drizzleKitCmd = (subcmd) => buildDrizzleKitCommand(subcmd);
-const generateApiTs = createApiCodegenRuntime({
-  findServerRootImpl: findServerRoot,
-});
+const generateApiTs = createApiCodegenRuntime({});
 const runAddCommand = createAddCommand({
   loadConfig,
   updateComponentReadmeImpl: updateComponentReadme,

package/core/index.js

@@ -2683,6 +2683,13 @@ var _ownerRlsTables = [];
 function getOwnerRlsTables() {
   return _ownerRlsTables;
 }
+if (!globalThis.__gencow_crudCodegenRegistry) {
+  globalThis.__gencow_crudCodegenRegistry = /* @__PURE__ */ new Map();
+}
+var crudCodegenRegistry = globalThis.__gencow_crudCodegenRegistry;
+function getRegisteredCrudCodegenMeta() {
+  return Array.from(crudCodegenRegistry.values());
+}
 function detectIdType(column) {
   const colType = column.dataType;
   if (colType === "string") return v.string();
@@ -2872,6 +2879,15 @@ function crud(table, options) {
     });
   }
   const enabledMethods = new Set(options?.methods ?? ["list", "get", "create", "update", "remove"]);
+  const enabledMethodsList = Array.from(enabledMethods);
+  crudCodegenRegistry.set(prefix, {
+    tableName,
+    prefix,
+    methods: enabledMethodsList,
+    allowedFilters: (options?.allowedFilters ?? []).map((field) => String(field)),
+    searchFields: (options?.searchFields ?? []).map((field) => String(field)),
+    isPublic
+  });
   const listDef = !enabledMethods.has("list") ? void 0 : query(`${prefix}.list`, {
     public: isPublic,
     args: {
@@ -3052,6 +3068,7 @@ export {
   getOwnerRlsTables,
   getQueryDef,
   getQueryHandler,
+  getRegisteredCrudCodegenMeta,
   getRegisteredHttpActions,
   getRegisteredMutations,
   getRegisteredQueries,

package/lib/__tests__/ai-template-smoke.test.ts

@@ -1,5 +1,6 @@
 import { describe, expect, it } from "bun:test";
 import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, symlinkSync, writeFileSync } from "fs";
+import { createRequire } from "module";
 import { join, resolve } from "path";
 import { tmpdir } from "os";
 
@@ -9,17 +10,32 @@ const syncedTemplatePaths = [
   join(repoRoot, "packages/cli/templates/fullstack/ai.ts"),
   join(repoRoot, "packages/cli/templates/ai-chat/ai.ts"),
 ];
+const fixtureWorkspacePath = join(repoRoot, "apps/test-ai-template-fixture");
 const fixtureNodeModules = join(repoRoot, "apps/test-ai-template-fixture/node_modules");
+const fixtureRequire = createRequire(join(fixtureWorkspacePath, "package.json"));
 
 function readTemplate(path: string): string {
   return readFileSync(path, "utf8");
 }
 
 function requireFixtureNodeModules(): string {
+  const requiredPackages = ["typescript/bin/tsc", "ai/package.json", "@ai-sdk/openai/package.json", "zod/package.json"];
+  for (const packagePath of requiredPackages) {
+    try {
+      fixtureRequire.resolve(packagePath);
+    } catch {
+      throw new Error(
+        "AI template smoke test requires the fixture workspace dependencies from a normal repo install. " +
+          "Run `pnpm install` at the repo root first.",
+      );
+    }
+  }
+
   if (existsSync(fixtureNodeModules)) return fixtureNodeModules;
+
   throw new Error(
-    "AI template smoke test requires repo-local fixture dependencies. " +
-      "Run `pnpm install --filter ./apps/test-ai-template-fixture` first.",
+    "AI template smoke test requires the fixture workspace links from a normal repo install. " +
+      "Run `pnpm install` at the repo root first.",
   );
 }
 

package/lib/__tests__/cli-project-runtime.test.mjs

@@ -22,6 +22,7 @@ describe("loadConfig()", () => {
     ).toEqual({
       functionsDir: "./gencow",
       schema: "./gencow/schema.ts",
+      codegenOutDir: "./src/gencow",
       storage: "./.gencow/uploads",
       db: { url: "./.gencow/data" },
       port: 5456,
@@ -33,12 +34,13 @@ describe("loadConfig()", () => {
     const root = mkdtempSync(resolve(tmpdir(), "gencow-cli-config-"));
     writeFileSync(
       resolve(root, "gencow.config.ts"),
-      `export default { functionsDir: "./api", schema: "./api/schema.ts", storage: "./uploads", db: { url: "./data" }, port: 6001 };`,
+      `export default { functionsDir: "./api", schema: "./api/schema.ts", codegenOutDir: "./src/gencow", storage: "./uploads", db: { url: "./data" }, port: 6001 };`,
     );
 
     expect(loadConfig({ cwd: root })).toEqual({
       functionsDir: "./api",
       schema: "./api/schema.ts",
+      codegenOutDir: "./src/gencow",
       storage: "./uploads",
       db: { url: "./data" },
       port: 6001,
@@ -46,6 +48,18 @@ describe("loadConfig()", () => {
 
     rmSync(root, { recursive: true, force: true });
   });
+
+  it("parses schema arrays from gencow.config.ts", () => {
+    const root = mkdtempSync(resolve(tmpdir(), "gencow-cli-config-schema-array-"));
+    writeFileSync(
+      resolve(root, "gencow.config.ts"),
+      `export default { schema: ["./src/custom-db.ts", "./src/auth-model.ts"] };`,
+    );
+
+    expect(loadConfig({ cwd: root }).schema).toEqual(["./src/custom-db.ts", "./src/auth-model.ts"]);
+
+    rmSync(root, { recursive: true, force: true });
+  });
 });
 
 describe("findServerRoot()", () => {

package/lib/__tests__/codegen-command-output-dir.test.mjs

@@ -0,0 +1,46 @@
+import { describe, expect, it } from "bun:test";
+import { mkdtempSync, mkdirSync, rmSync } from "fs";
+import { tmpdir } from "os";
+import { resolve } from "path";
+import { resolveCodegenPublishDir } from "../codegen-command.mjs";
+
+describe("resolveCodegenPublishDir()", () => {
+  it("prefers codegenOutDir from config when provided", () => {
+    const root = mkdtempSync(resolve(tmpdir(), "gencow-codegen-outdir-"));
+    try {
+      mkdirSync(resolve(root, "src"), { recursive: true });
+      const out = resolveCodegenPublishDir(root, {
+        functionsDir: "./gencow",
+        codegenOutDir: "./custom/generated",
+      });
+      expect(out).toBe(resolve(root, "custom/generated"));
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  it("falls back to src/gencow when src exists", () => {
+    const root = mkdtempSync(resolve(tmpdir(), "gencow-codegen-outdir-"));
+    try {
+      mkdirSync(resolve(root, "src"), { recursive: true });
+      const out = resolveCodegenPublishDir(root, {
+        functionsDir: "./gencow",
+      });
+      expect(out).toBe(resolve(root, "src/gencow"));
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  it("falls back to functionsDir when src does not exist", () => {
+    const root = mkdtempSync(resolve(tmpdir(), "gencow-codegen-outdir-"));
+    try {
+      const out = resolveCodegenPublishDir(root, {
+        functionsDir: "./gencow",
+      });
+      expect(out).toBe(resolve(root, "gencow"));
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+});

package/lib/__tests__/codegen-command.test.mjs

@@ -1,28 +1,52 @@
 import { describe, expect, it } from "bun:test";
+import { createCodegenCommand } from "../codegen-command.mjs";
 
-import { buildFrontendApiTs, resolveCodegenOutdir } from "../codegen-command.mjs";
-
-describe("resolveCodegenOutdir()", () => {
-  it("defaults to src/gencow under cwd", () => {
-    expect(resolveCodegenOutdir("/repo/demo", [])).toBe("/repo/demo/src/gencow");
-  });
+describe("createCodegenCommand()", () => {
+  it("passes multi-schema config to runCodegen from CLI boundary", async () => {
+    let capturedInput = null;
+    const logs = [];
+    const command = createCodegenCommand({
+      BOLD: "",
+      CYAN: "",
+      DIM: "",
+      RED: "",
+      RESET: "",
+      YELLOW: "",
+      loadConfig: () => ({
+        functionsDir: "./src/gencow",
+        schema: ["./src/custom-db.ts", "./src/auth-model.ts"],
+        codegenOutDir: "./src/gencow/gen",
+      }),
+      cwdImpl: () => "/tmp/project",
+      resolvePathImpl: (cwd, p) => `${cwd}/${p.replace(/^\.\//, "")}`,
+      logImpl: (line) => logs.push(String(line)),
+      infoImpl: (line) => logs.push(String(line)),
+      successImpl: () => {},
+      errorImpl: (line) => logs.push(String(line)),
+      exitImpl: (code) => {
+        throw new Error(`Unexpected exit: ${code}`);
+      },
+      loadCodegenBundleImpl: async () => ({
+        runCodegen: async (input) => {
+          capturedInput = input;
+          return {
+            ok: true,
+            diagnostics: [],
+            artifacts: [{ path: "manifest.json" }, { path: "api.ts" }],
+          };
+        },
+      }),
+    });
 
-  it("uses --outdir and -o overrides", () => {
-    expect(resolveCodegenOutdir("/repo/demo", ["--outdir", "web/gen"])).toBe("/repo/demo/web/gen");
-    expect(resolveCodegenOutdir("/repo/demo", ["-o", "app/api"])).toBe("/repo/demo/app/api");
-  });
-});
+    await command();
 
-describe("buildFrontendApiTs()", () => {
-  it("renders query and mutation definitions for frontend use", () => {
-    const out = buildFrontendApiTs({
-      tasks: { queries: ["list"], mutations: ["create"] },
-      users: { queries: ["me"], mutations: [] },
+    expect(capturedInput).toEqual({
+      projectRoot: "/tmp/project",
+      functionsDir: "./src/gencow",
+      schema: ["./src/custom-db.ts", "./src/auth-model.ts"],
+      outDir: "/tmp/project/.gencow/codegen",
+      finalOutDir: "/tmp/project/src/gencow/gen",
     });
-
-    expect(out).toContain('import { defineQuery, defineMutation } from "@gencow/react";');
-    expect(out).toContain('list: defineQuery("tasks.list")');
-    expect(out).toContain('create: defineMutation("tasks.create")');
-    expect(out).toContain('me: defineQuery("users.me")');
+    expect(logs.join("\n")).toContain("Output:");
   });
 });

package/lib/__tests__/dev-local-command.test.mjs

@@ -25,9 +25,11 @@ describe("buildKillPortsCommand()", () => {
 });
 
 describe("isGeneratedCodegenFile()", () => {
-  it("filters generated api.ts and README.md files only", () => {
+  it("filters generated client artifact basenames", () => {
     expect(isGeneratedCodegenFile("gencow/api.ts")).toBe(true);
     expect(isGeneratedCodegenFile("nested/README.md")).toBe(true);
+    expect(isGeneratedCodegenFile("gencow/db.d.ts")).toBe(true);
+    expect(isGeneratedCodegenFile("gencow/operations.d.ts")).toBe(true);
     expect(isGeneratedCodegenFile("schema.ts")).toBe(false);
   });
 });

package/lib/__tests__/init-command.test.mjs

@@ -58,6 +58,11 @@ describe("mergeGitignoreContent()", () => {
     const merged = mergeGitignoreContent("dist/\nnode_modules/\n");
     expect(merged).toContain("# Gencow");
     expect(merged).toContain(".gencow/");
+    expect(merged).toContain("src/gencow/api.ts");
+    expect(merged).toContain("src/gencow/db.d.ts");
+    expect(merged).toContain("src/gencow/operations.d.ts");
+    expect(merged).toContain("src/gencow/zod.ts");
+    expect(merged).toContain("gencow/zod.ts");
     expect(merged.match(/node_modules\//g)?.length).toBe(1);
   });
 });

package/lib/__tests__/name-casing.test.mjs

@@ -0,0 +1,26 @@
+import { describe, it, expect } from "bun:test";
+import { toCamelCase, toPascalCase } from "../name-casing.mjs";
+
+describe("toPascalCase", () => {
+  it("splits on non-alphanumeric runs and capitalizes segments", () => {
+    expect(toPascalCase("tasks")).toBe("Tasks");
+    expect(toPascalCase("my_tasks")).toBe("MyTasks");
+    expect(toPascalCase("my-tasks.list")).toBe("MyTasksList");
+  });
+
+  it("coerces non-strings like api-codegen callers", () => {
+    expect(toPascalCase(12)).toBe("12");
+  });
+});
+
+describe("toCamelCase", () => {
+  it("lowercases the first character of PascalCase", () => {
+    expect(toCamelCase("tasks")).toBe("tasks");
+    expect(toCamelCase("my_tasks")).toBe("myTasks");
+  });
+
+  it("returns empty string for empty Pascal base", () => {
+    expect(toCamelCase("")).toBe("");
+    expect(toCamelCase("___")).toBe("");
+  });
+});

package/lib/__tests__/test-script-regression.test.ts

@@ -0,0 +1,92 @@
+import { describe, expect, it } from "bun:test";
+import { readFileSync } from "fs";
+import { join, resolve } from "path";
+
+const repoRoot = resolve(import.meta.dir, "../../../..");
+const helperPath = join(repoRoot, "scripts/lib/test-helpers.sh");
+const aiTemplateSmokePath = join(repoRoot, "packages/cli/lib/__tests__/ai-template-smoke.test.ts");
+
+const coreShellScripts = [
+  "scripts/test-server.sh",
+  "scripts/test-auth-flow.sh",
+  "scripts/test-security.sh",
+  "scripts/test-realtime.sh",
+  "scripts/test-cron-scheduler.sh",
+  "scripts/test-env.sh",
+] as const;
+
+function readRepoFile(path: string): string {
+  return readFileSync(path, "utf8");
+}
+
+describe("shell test helper regression", () => {
+  it("keeps core shell suites on the shared Bun-based helper path", () => {
+    const helperSource = readRepoFile(helperPath);
+    expect(helperSource).toContain("json_get()");
+    expect(helperSource).toContain("run_with_timeout()");
+    expect(helperSource).toContain("make_test_email()");
+
+    for (const relativePath of coreShellScripts) {
+      const source = readRepoFile(join(repoRoot, relativePath));
+      expect(source).toContain('source "${SCRIPT_DIR}/lib/test-helpers.sh"');
+      expect(source).not.toContain("python3 -c");
+    }
+  });
+
+  it("uses per-run identities for remote auth fixtures", () => {
+    const serverSource = readRepoFile(join(repoRoot, "scripts/test-server.sh"));
+    const securitySource = readRepoFile(join(repoRoot, "scripts/test-security.sh"));
+    const realtimeSource = readRepoFile(join(repoRoot, "scripts/test-realtime.sh"));
+
+    expect(serverSource).toContain('make_test_email "server-e2e"');
+    expect(serverSource).not.toContain("test@example.com");
+
+    expect(securitySource).toContain('make_test_email "security-e2e"');
+    expect(securitySource).not.toContain("sectest@example.com");
+
+    expect(realtimeSource).toContain('make_test_email "realtime-e2e"');
+    expect(realtimeSource).not.toContain("realtime@example.com");
+  });
+
+  it("keeps realtime smoke portable across timeout implementations", () => {
+    const realtimeSource = readRepoFile(join(repoRoot, "scripts/test-realtime.sh"));
+
+    expect(realtimeSource).toContain("run_with_timeout 3 websocat");
+    expect(realtimeSource).not.toMatch(/\n\s*timeout 3 websocat/);
+    expect(realtimeSource).toContain("portable JSON parsing + timeout fallback");
+  });
+
+  it("treats admin access checks as policy-aware instead of hard-coded public 200s", () => {
+    const securitySource = readRepoFile(join(repoRoot, "scripts/test-security.sh"));
+
+    expect(securitySource).toContain('EXPECT_ADMIN_ACCESS="${EXPECT_ADMIN_ACCESS:-auto}"');
+    expect(securitySource).toContain("assert_admin_access_policy");
+    expect(securitySource).not.toContain('assert_status "Admin status → 200" "200" "$ADMIN_STATUS"');
+    expect(securitySource).not.toContain('assert_status "Admin tables → 200" "200" "$ADMIN_TABLES"');
+  });
+});
+
+describe("AI template smoke fixture regression", () => {
+  it("anchors fixture dependency messaging to a normal repo install", () => {
+    const source = readRepoFile(aiTemplateSmokePath);
+
+    expect(source).toContain('createRequire(join(fixtureWorkspacePath, "package.json"))');
+    expect(source).toContain("Run `pnpm install` at the repo root first.");
+    expect(source).not.toContain("pnpm install --filter ./apps/test-ai-template-fixture");
+  });
+});
+
+describe("cowbox DEV test path regression", () => {
+  it("exposes a dedicated DEV Linux test entrypoint for cowbox", () => {
+    const packageJson = readRepoFile(join(repoRoot, "package.json"));
+    const scriptSource = readRepoFile(join(repoRoot, "scripts/test-cowbox-dev.sh"));
+
+    expect(packageJson).toContain('"test:cowbox:dev": "./scripts/test-cowbox-dev.sh"');
+    expect(scriptSource).toContain('DEV_HOST="${GENCOW_DEV_HOST:-root@100.114.201.127}"');
+    expect(scriptSource).toContain("cargo test -- --nocapture");
+    expect(scriptSource).toContain("./target/release/cowbox check");
+    expect(scriptSource).toContain("./target/release/cowbox run");
+    expect(scriptSource).toContain("allowed write smoke");
+    expect(scriptSource).toContain("denied write smoke");
+  });
+});

package/lib/api-codegen.mjs

@@ -1,3 +1,5 @@
+import { toPascalCase } from "./name-casing.mjs";
+
 export const CORE_GENERATED_NAMESPACES = new Set(["workflows"]);
 
 export function buildApiObject({ queries = [], mutations = [] }) {
@@ -39,13 +41,18 @@ export function buildGeneratedApiTs({
   namespaceImportPaths = {},
   singleFileImportPath = "./index.ts",
   coreGeneratedNamespaces = CORE_GENERATED_NAMESPACES,
+  useCrudTypes = false,
+  crudTypeImportPath = "./crud.d.ts",
+  crudTypeNamespaces = [],
 }) {
-  const hasNamespaceFiles = Object.keys(namespaceImportPaths).length > 0;
+  const hasNamespaceFiles = !useCrudTypes && Object.keys(namespaceImportPaths).length > 0;
 
   let out = `/**\n * Generated by Gencow\n * Do not edit this file manually.\n */\n`;
   out += `import { defineQuery, defineMutation } from "@gencow/react";\n\n`;
 
-  if (hasNamespaceFiles) {
+  if (useCrudTypes) {
+    out += `import type * as Crud from "${crudTypeImportPath}";\n`;
+  } else if (hasNamespaceFiles) {
     for (const [namespace, importPath] of Object.entries(namespaceImportPaths)) {
       out += `import type * as ${namespace} from "${importPath}";\n`;
     }
@@ -55,6 +62,8 @@ export function buildGeneratedApiTs({
 
   out += `\nexport const api = {\n`;
   for (const [namespace, fns] of Object.entries(apiObj)) {
+    const namespaceBase = toPascalCase(namespace);
+    const hasCrudTypesForNamespace = useCrudTypes && crudTypeNamespaces.includes(namespace);
     const typedReference = canUseTypedReference({
       namespace,
       hasNamespaceFiles,
@@ -65,7 +74,15 @@ export function buildGeneratedApiTs({
     out += `    ${namespace}: {\n`;
     for (const queryName of fns.queries) {
       const tsExport = toTsExportName(queryName);
-      if (typedReference && hasNamespaceFiles) {
+      if (hasCrudTypesForNamespace) {
+        if (queryName === "list") {
+          out += `        ${queryName}: defineQuery<{ _args?: Crud.${namespaceBase}ListInput; _return?: Crud.${namespaceBase}ListOutput }>("${namespace}.${queryName}"),\n`;
+        } else if (queryName === "get") {
+          out += `        ${queryName}: defineQuery<{ _args?: Crud.${namespaceBase}GetInput; _return?: Crud.${namespaceBase}Select }>("${namespace}.${queryName}"),\n`;
+        } else {
+          out += `        ${queryName}: defineQuery("${namespace}.${queryName}"),\n`;
+        }
+      } else if (typedReference && hasNamespaceFiles) {
         out += `        ${queryName}: defineQuery<typeof ${namespace}.${tsExport}>("${namespace}.${queryName}"),\n`;
       } else if (typedReference) {
         out += `        ${queryName}: defineQuery<typeof _all.${tsExport}>("${namespace}.${queryName}"),\n`;
@@ -75,7 +92,17 @@ export function buildGeneratedApiTs({
     }
     for (const mutationName of fns.mutations) {
       const tsExport = toTsExportName(mutationName);
-      if (typedReference && hasNamespaceFiles) {
+      if (hasCrudTypesForNamespace) {
+        if (mutationName === "create") {
+          out += `        ${mutationName}: defineMutation<{ _args?: Crud.${namespaceBase}CreateInput; _return?: Crud.${namespaceBase}Select }>("${namespace}.${mutationName}"),\n`;
+        } else if (mutationName === "update") {
+          out += `        ${mutationName}: defineMutation<{ _args?: Crud.${namespaceBase}UpdateInput; _return?: Crud.${namespaceBase}Select }>("${namespace}.${mutationName}"),\n`;
+        } else if (mutationName === "remove") {
+          out += `        ${mutationName}: defineMutation<{ _args?: Crud.${namespaceBase}RemoveInput; _return?: unknown }>("${namespace}.${mutationName}"),\n`;
+        } else {
+          out += `        ${mutationName}: defineMutation("${namespace}.${mutationName}"),\n`;
+        }
+      } else if (typedReference && hasNamespaceFiles) {
         out += `        ${mutationName}: defineMutation<typeof ${namespace}.${tsExport}>("${namespace}.${mutationName}"),\n`;
       } else if (typedReference) {
         out += `        ${mutationName}: defineMutation<typeof _all.${tsExport}>("${namespace}.${mutationName}"),\n`;