gencow 0.1.147 → 0.1.148

package/core/index.js

@@ -3258,49 +3258,57 @@ async function withRlsConnection(session, rls, reuseOuterConnection, fn) {
 }
 function wrapPreparedQuery(pq, session, rls, reuseOuterConnection) {
   const origExecute = pq.execute.bind(pq);
-  const origAll = pq.all.bind(pq);
+  const origAll = typeof pq.all === "function" ? pq.all.bind(pq) : null;
+  const swapClient = (client) => {
+    const prevPq = pq.client;
+    const prevSession = session.client;
+    pq.client = client;
+    session.client = client;
+    return () => {
+      pq.client = prevPq;
+      session.client = prevSession;
+    };
+  };
   pq.execute = async (placeholderValues) => {
     const active = rlsExecClient.getStore();
     if (active) {
-      const prev = pq.client;
-      pq.client = active;
+      const restore = swapClient(active);
       try {
         return await origExecute(placeholderValues);
       } finally {
-        pq.client = prev;
+        restore();
       }
     }
     return withRlsConnection(session, rls, reuseOuterConnection, async (client) => {
-      const prev = pq.client;
-      pq.client = client;
+      const restore = swapClient(client);
       try {
         return await origExecute(placeholderValues);
       } finally {
-        pq.client = prev;
+        restore();
       }
     });
   };
-  pq.all = async (placeholderValues) => {
-    const active = rlsExecClient.getStore();
-    if (active) {
-      const prev = pq.client;
-      pq.client = active;
-      try {
-        return await origAll(placeholderValues);
-      } finally {
-        pq.client = prev;
-      }
-    }
-    return withRlsConnection(session, rls, reuseOuterConnection, async (client) => {
-      const prev = pq.client;
-      pq.client = client;
-      try {
-        return await origAll(placeholderValues);
-      } finally {
-        pq.client = prev;
+  if (origAll) {
+    pq.all = async (placeholderValues) => {
+      const active = rlsExecClient.getStore();
+      if (active) {
+        const restore = swapClient(active);
+        try {
+          return await origAll(placeholderValues);
+        } finally {
+          restore();
+        }
       }
-    });
-  };
+      return withRlsConnection(session, rls, reuseOuterConnection, async (client) => {
+        const restore = swapClient(client);
+        try {
+          return await origAll(placeholderValues);
+        } finally {
+          restore();
+        }
+      });
+    };
+  }
 }
 function wrapSession(session, rls, reuseOuterConnection) {
   return new Proxy(session, {

package/lib/add-command.mjs

@@ -5,7 +5,7 @@ import { dirname, relative, resolve } from "path";
 export const ADD_COMPONENTS = {
   ai: {
     label: "AI Engine",
-    deps: ["ai", "@ai-sdk/openai"],
+    deps: ["ai", "@ai-sdk/openai", "@ai-sdk/provider-utils"],
     files: [{ src: "ai.ts", dest: "gencow/ai.ts" }],
     env: { OPENAI_API_KEY: "" },
     requires: [],

package/lib/cli-artifact-guard.mjs

@@ -3,6 +3,7 @@ export const REQUIRED_CLI_TARBALL_FILES = Object.freeze([
   "bin/gencow-mcp.mjs",
   "lib/readme-codegen.mjs",
   "lib/deploy-auditor.mjs",
+  "lib/cron-manifest.mjs",
   "lib/dev-cloud-bundle.mjs",
   "lib/codegen/index.mjs",
   "server/index.js",

package/lib/cli-dev-runtime.mjs

@@ -8,7 +8,6 @@ import {
   resolveCodegenConfig,
   resolveCodegenPublishDir,
 } from "./codegen-command.mjs";
-import { generateAuthSchema } from "./codegen/index.mjs";
 import { updateComponentReadme } from "./component-readme.mjs";
 import { buildReadmeMarkdown, extractComponentsBlock } from "./readme-codegen.mjs";
 import { CYAN, DIM, RED, RESET, YELLOW, error, info, log, success, warn } from "./output.mjs";
@@ -146,7 +145,7 @@ export function createApiCodegenRuntime(options = {}) {
     resolvePathImpl = resolve,
     successImpl = success,
     updateComponentReadmeImpl = updateComponentReadme,
-    generateAuthSchemaImpl = generateAuthSchema,
+    generateAuthSchemaImpl,
     warnImpl = warn,
     writeFileSyncImpl = writeFileSync,
   } = options;
@@ -176,6 +175,7 @@ export function createApiCodegenRuntime(options = {}) {
       if (typeof bundled.createNodeProcessRunner !== "function") {
         throw new Error("Invalid codegen bundle: createNodeProcessRunner export not found");
       }
+      const generateAuthSchema = generateAuthSchemaImpl ?? bundled.generateAuthSchema;
 
       const result = await bundled.runCodegen({
         projectRoot: cwd,
@@ -185,7 +185,7 @@ export function createApiCodegenRuntime(options = {}) {
         finalOutDir: publishDir,
         authSchema: {
           enabled: resolveCodegenConfig(config).authSchema,
-          generate: generateAuthSchemaImpl,
+          generate: generateAuthSchema,
         },
       });
       if (result.authSchema?.changed) {

package/lib/codegen/index.mjs

@@ -6557,49 +6557,57 @@ async function withRlsConnection(session, rls, reuseOuterConnection, fn) {
 }
 function wrapPreparedQuery(pq, session, rls, reuseOuterConnection) {
   const origExecute = pq.execute.bind(pq);
-  const origAll = pq.all.bind(pq);
+  const origAll = typeof pq.all === "function" ? pq.all.bind(pq) : null;
+  const swapClient = (client) => {
+    const prevPq = pq.client;
+    const prevSession = session.client;
+    pq.client = client;
+    session.client = client;
+    return () => {
+      pq.client = prevPq;
+      session.client = prevSession;
+    };
+  };
   pq.execute = async (placeholderValues) => {
     const active = rlsExecClient.getStore();
     if (active) {
-      const prev = pq.client;
-      pq.client = active;
+      const restore = swapClient(active);
       try {
         return await origExecute(placeholderValues);
       } finally {
-        pq.client = prev;
+        restore();
       }
     }
     return withRlsConnection(session, rls, reuseOuterConnection, async (client) => {
-      const prev = pq.client;
-      pq.client = client;
+      const restore = swapClient(client);
       try {
         return await origExecute(placeholderValues);
       } finally {
-        pq.client = prev;
+        restore();
       }
     });
   };
-  pq.all = async (placeholderValues) => {
-    const active = rlsExecClient.getStore();
-    if (active) {
-      const prev = pq.client;
-      pq.client = active;
-      try {
-        return await origAll(placeholderValues);
-      } finally {
-        pq.client = prev;
-      }
-    }
-    return withRlsConnection(session, rls, reuseOuterConnection, async (client) => {
-      const prev = pq.client;
-      pq.client = client;
-      try {
-        return await origAll(placeholderValues);
-      } finally {
-        pq.client = prev;
+  if (origAll) {
+    pq.all = async (placeholderValues) => {
+      const active = rlsExecClient.getStore();
+      if (active) {
+        const restore = swapClient(active);
+        try {
+          return await origAll(placeholderValues);
+        } finally {
+          restore();
+        }
       }
-    });
-  };
+      return withRlsConnection(session, rls, reuseOuterConnection, async (client) => {
+        const restore = swapClient(client);
+        try {
+          return await origAll(placeholderValues);
+        } finally {
+          restore();
+        }
+      });
+    };
+  }
 }
 function wrapSession(session, rls, reuseOuterConnection) {
   return new Proxy(session, {

package/lib/codegen-command.mjs

@@ -1,6 +1,5 @@
 import { existsSync } from "fs";
 import { resolve, relative } from "path";
-import { generateAuthSchema } from "./codegen/index.mjs";
 
 export function resolveCodegenConfig(config = {}) {
   const outDir =
@@ -85,6 +84,7 @@ export function createCodegenCommand(deps) {
       if (typeof bundled.runCodegen !== "function") {
         throw new Error("Invalid codegen bundle: runCodegen export not found");
       }
+      const generateAuthSchema = deps.generateAuthSchemaImpl ?? bundled.generateAuthSchema;
       const result = await bundled.runCodegen({
         projectRoot: cwd,
         functionsDir: config.functionsDir,
@@ -93,7 +93,7 @@ export function createCodegenCommand(deps) {
         finalOutDir: publishDir,
         authSchema: {
           enabled: codegen.authSchema,
-          generate: deps.generateAuthSchemaImpl ?? generateAuthSchema,
+          generate: generateAuthSchema,
         },
       });
       if (result.authSchema?.changed) {

package/lib/cron-manifest.mjs

@@ -0,0 +1,142 @@
+import { createHash } from "crypto";
+import { cpSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
+import { dirname, resolve } from "path";
+import { pathToFileURL } from "url";
+
+export const CRON_MANIFEST_RELATIVE_PATH = ".gencow/cron-jobs.json";
+
+function resolveCronDefinitionsFile({ cwd, functionsDir, existsSyncImpl, resolvePathImpl }) {
+  const cronsTs = resolvePathImpl(cwd, functionsDir, "crons.ts");
+  const cronsJs = resolvePathImpl(cwd, functionsDir, "crons.js");
+  if (existsSyncImpl(cronsTs)) return cronsTs;
+  if (existsSyncImpl(cronsJs)) return cronsJs;
+  return null;
+}
+
+function readNonEmptyString(value, field) {
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new Error(`cron job ${field} must be a non-empty string`);
+  }
+  return value;
+}
+
+function normalizeCronJobs(rawJobs) {
+  if (!Array.isArray(rawJobs)) throw new Error("crons.getJobs() must return an array");
+
+  const jobs = [];
+  const skipped = [];
+  rawJobs.forEach((job, index) => {
+    if (!job || typeof job !== "object" || Array.isArray(job)) {
+      throw new Error(`cron job ${index} must be an object`);
+    }
+    if (typeof job.action !== "string") {
+      skipped.push({
+        name: typeof job.name === "string" && job.name.trim() ? job.name : `jobs[${index}]`,
+        reason: "inline action is not supported in cloud cron manifest",
+      });
+      return;
+    }
+    jobs.push({
+      name: readNonEmptyString(job.name, `${index}.name`),
+      pattern: readNonEmptyString(job.pattern, `${index}.pattern`),
+      action: readNonEmptyString(job.action, `${index}.action`),
+    });
+  });
+
+  return { jobs, skipped, skippedInlineCount: skipped.length };
+}
+
+function writeFallbackCoreShim(coreTarget, mkdirSyncImpl, writeFileSyncImpl) {
+  mkdirSyncImpl(coreTarget, { recursive: true });
+  writeFileSyncImpl(
+    resolve(coreTarget, "package.json"),
+    JSON.stringify({ name: "@gencow/core", type: "module", main: "index.js" }, null, 2),
+  );
+  writeFileSyncImpl(
+    resolve(coreTarget, "index.js"),
+    [
+      "export function cronJobs() {",
+      "  const jobs = [];",
+      "  const builder = {",
+      "    interval(name, options, action) {",
+      "      if (options?.seconds) jobs.push({ name, pattern: `*/${options.seconds} * * * * *`, action });",
+      "      else if (options?.minutes) jobs.push({ name, pattern: `*/${options.minutes} * * * *`, action });",
+      "      else if (options?.hours) jobs.push({ name, pattern: `0 */${options.hours} * * *`, action });",
+      "      else throw new Error(\"interval cron requires seconds, minutes, or hours\");",
+      "      return builder;",
+      "    },",
+      "    daily(name, options, action) { jobs.push({ name, pattern: `${options.minute ?? 0} ${options.hour} * * *`, action }); return builder; },",
+      "    weekly(name, options, action) { jobs.push({ name, pattern: `${options.minute ?? 0} ${options.hour} * * ${options.dayOfWeek}`, action }); return builder; },",
+      "    cron(name, pattern, action) { jobs.push({ name, pattern, action }); return builder; },",
+      "    getJobs() { return [...jobs]; },",
+      "  };",
+      "  return builder;",
+      "}",
+      "",
+    ].join("\n"),
+  );
+}
+
+function installCronCoreShim({ workDir, mkdirSyncImpl, resolvePathImpl, writeFileSyncImpl }) {
+  const coreTarget = resolvePathImpl(workDir, "node_modules", "@gencow", "core");
+  mkdirSyncImpl(dirname(coreTarget), { recursive: true });
+  writeFallbackCoreShim(coreTarget, mkdirSyncImpl, writeFileSyncImpl);
+}
+
+export async function writeCronManifestForProject({
+  cwd,
+  functionsDir = "gencow",
+  cpSyncImpl = cpSync,
+  existsSyncImpl = existsSync,
+  mkdirSyncImpl = mkdirSync,
+  readFileSyncImpl = readFileSync,
+  resolvePathImpl = resolve,
+  rmSyncImpl = rmSync,
+  writeFileSyncImpl = writeFileSync,
+} = {}) {
+  if (!cwd) throw new Error("cwd is required to write cron manifest");
+
+  const cronsFile = resolveCronDefinitionsFile({ cwd, functionsDir, existsSyncImpl, resolvePathImpl });
+  const manifestPath = resolvePathImpl(cwd, CRON_MANIFEST_RELATIVE_PATH);
+  if (!cronsFile) {
+    rmSyncImpl(manifestPath, { force: true });
+    return null;
+  }
+
+  const workDir = resolvePathImpl(cwd, ".gencow", "cron-manifest-workdir");
+  const stagedFunctionsDir = resolvePathImpl(workDir, functionsDir);
+  rmSyncImpl(workDir, { recursive: true, force: true });
+  mkdirSyncImpl(dirname(stagedFunctionsDir), { recursive: true });
+
+  try {
+    cpSyncImpl(resolvePathImpl(cwd, functionsDir), stagedFunctionsDir, { recursive: true });
+    installCronCoreShim({ workDir, mkdirSyncImpl, resolvePathImpl, writeFileSyncImpl });
+
+    const cronsFileName = cronsFile.endsWith(".js") ? "crons.js" : "crons.ts";
+    const stagedCronsFile = resolvePathImpl(stagedFunctionsDir, cronsFileName);
+    const importUrl = `${pathToFileURL(stagedCronsFile).href}?v=${Date.now()}-${Math.random()}`;
+    const module = await import(importUrl);
+    const builder = module.default ?? module.crons;
+    if (!builder || typeof builder.getJobs !== "function") {
+      throw new Error("crons.ts must export default cronJobs() builder");
+    }
+
+    const { jobs, skipped, skippedInlineCount } = normalizeCronJobs(builder.getJobs());
+    const sourceHash = createHash("sha256").update(readFileSyncImpl(cronsFile)).digest("hex");
+    const manifest = {
+      version: 1,
+      generatedAt: new Date().toISOString(),
+      source: `${functionsDir}/${cronsFileName}`,
+      sourceHash: `sha256:${sourceHash}`,
+      skipped,
+      skippedInlineCount,
+      jobs,
+    };
+
+    mkdirSyncImpl(dirname(manifestPath), { recursive: true });
+    writeFileSyncImpl(manifestPath, JSON.stringify(manifest, null, 2));
+    return { manifestPath, manifest };
+  } finally {
+    rmSyncImpl(workDir, { recursive: true, force: true });
+  }
+}

package/lib/deploy-dependency-compat.mjs

@@ -10,7 +10,7 @@ export const DEPENDENCY_COMPAT_MATRIX = Object.freeze([
   },
   {
     packageName: "drizzle-orm",
-    expectedRange: "workspace:* || ^1.0.0-beta || ^1.0.0",
+    expectedRange: "workspace:* || ^1.0.0-beta || ^1.0.0-rc || ^1.0.0",
     installRange: "drizzle-orm@^1.0.0",
     policy: "block",
   },
@@ -145,10 +145,7 @@ function clausesCompatible(current, expected) {
 
   if (expectedVersion.major === 0) {
     if (currentVersion.major !== 0 || currentVersion.minor !== expectedVersion.minor) return false;
-    if (currentVersion.operator === "exact") {
-      return compareVersions(currentVersion, expectedVersion) >= 0;
-    }
-    return true;
+    return compareVersions(currentVersion, expectedVersion) >= 0;
   }
 
   if (currentVersion.major !== expectedVersion.major) return false;

package/lib/deploy-package-runtime.mjs

@@ -1,6 +1,7 @@
 import { execSync } from "child_process";
 import { existsSync, mkdirSync, readFileSync, statSync, unlinkSync, writeFileSync } from "fs";
 import { dirname, resolve } from "path";
+import { CRON_MANIFEST_RELATIVE_PATH, writeCronManifestForProject } from "./cron-manifest.mjs";
 import { CYAN, DIM, RED, RESET, YELLOW, error, info, log, success, warn } from "./output.mjs";
 import { platformFetch, rpcMutation } from "./platform-client.mjs";
 
@@ -49,6 +50,7 @@ export function createDeployPackageRuntime({
   unlinkSyncImpl = unlinkSync,
   verifyAppReadyImpl,
   warnImpl = warn,
+  writeCronManifestForProjectImpl = writeCronManifestForProject,
   writeFileSyncImpl = writeFileSync,
   updateEnvLocalUrlImpl,
 } = {}) {
@@ -163,6 +165,16 @@ export function createDeployPackageRuntime({
       return null;
     }
 
+    let cronManifestPath = null;
+    try {
+      const cronManifest = await writeCronManifestForProjectImpl({ cwd, functionsDir: "gencow" });
+      cronManifestPath = cronManifest?.manifestPath ?? null;
+    } catch (caught) {
+      errorImpl(`Cron manifest generation failed: ${caught.message}`);
+      exitImpl(1);
+      return null;
+    }
+
     let auditResult = null;
     if (!forceDeploy) {
       try {
@@ -181,6 +193,7 @@ export function createDeployPackageRuntime({
     let useFilteredPkg = false;
     const filesToPack = ["gencow/", "package.json"];
     if (dependencyAuditManifestPath) filesToPack.push(".gencow/deploy-dependency-audit.json");
+    if (cronManifestPath) filesToPack.push(CRON_MANIFEST_RELATIVE_PATH);
     if (existsSyncImpl(resolvePathImpl(cwd, "bun.lockb"))) filesToPack.push("bun.lockb");
     if (existsSyncImpl(resolvePathImpl(cwd, "package-lock.json"))) filesToPack.push("package-lock.json");
     if (existsSyncImpl(resolvePathImpl(cwd, "tsconfig.json"))) filesToPack.push("tsconfig.json");

package/lib/dev-cloud-bundle.mjs

@@ -2,6 +2,7 @@ import { copyFileSync, cpSync, existsSync, mkdirSync, readFileSync, rmSync, writ
 import { dirname, resolve } from "path";
 import { create as tarCreate } from "tar";
 
+import { CRON_MANIFEST_RELATIVE_PATH, writeCronManifestForProject } from "./cron-manifest.mjs";
 import {
   DEPLOY_DEPENDENCY_AUDIT_MANIFEST,
   auditDependencyVersions,
@@ -78,6 +79,7 @@ export async function createDevCloudDeployBundle({
   rmSyncImpl = rmSync,
   tarCreateImpl = tarCreate,
   warnImpl = () => {},
+  writeCronManifestForProjectImpl = writeCronManifestForProject,
   writeFileSyncImpl = writeFileSync,
 } = {}) {
   if (!cwd || !functionsDir) throw new Error("cwd and functionsDir are required to create a dev cloud bundle");
@@ -112,6 +114,9 @@ export async function createDevCloudDeployBundle({
     mkdirSyncImpl(dirname(manifestPath), { recursive: true });
     writeFileSyncImpl(manifestPath, JSON.stringify(dependencyVersionResult.manifest, null, 2));
 
+    const cronManifest = await writeCronManifestForProjectImpl({ cwd: stagingDir, functionsDir });
+    if (cronManifest) filesToPack.push(CRON_MANIFEST_RELATIVE_PATH);
+
     const filteredPackage = buildFilteredPackageJson(projectPkg, auditResult?.runtimeDeps);
     writeFileSyncImpl(resolvePathImpl(stagingDir, "package.json"), JSON.stringify(filteredPackage, null, 2));
 

package/lib/init-command.mjs

@@ -27,8 +27,8 @@ const BASE_DEPS = {
   "@gencow/core": "latest",
   "@electric-sql/pglite": "^0.3.15",
   "better-auth": "^1.5.1",
-  "drizzle-orm": "^1.0.0-beta || ^1.0.0",
-  "drizzle-kit": "^1.0.0-beta || ^1.0.0",
+  "drizzle-orm": "^1.0.0-beta || ^1.0.0-rc || ^1.0.0",
+  "drizzle-kit": "^1.0.0-beta || ^1.0.0-rc || ^1.0.0",
   hono: "^4.12.0",
   postgres: "^3.4.8",
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gencow",
-  "version": "0.1.147",
+  "version": "0.1.148",
   "description": "Gencow — AI Backend Engine",
   "type": "module",
   "bin": {