alepha 0.22.0 → 0.24.0

package/src/cache/database/entities/cacheEntries.ts

@@ -1,4 +1,4 @@
-import { type Static, t } from "alepha";
+import { type Static, z } from "alepha";
 import { $entity, db } from "alepha/orm";
 
 /**
@@ -13,41 +13,30 @@ import { $entity, db } from "alepha/orm";
  */
 export const cacheEntries = $entity({
   name: "cache_entries",
-  schema: t.object({
-    id: db.primaryKey(t.uuid()),
+  schema: z.object({
+    id: db.primaryKey(z.uuid()),
 
     createdAt: db.createdAt(),
 
-    container: t.text({
+    container: z.text({
       description: "Cache container name, set by the $cache primitive.",
     }),
 
-    cacheKey: t.text({
+    cacheKey: z.text({
       description: "Per-container key chosen by the caller.",
     }),
 
-    value: t.optional(
-      // No maxLength: cache values are arbitrary-sized (especially when
-      // `compress: true` is enabled on the $cache primitive, which can
-      // produce blobs well above the default 255-char `t.text()` cap). This
-      // resolves to TEXT in both Postgres and SQLite, which have no
-      // practical length limit either.
-      t.string({
-        description: "Base64-encoded bytes. Used by set/get.",
-      }),
-    ),
-
-    count: t.optional(
-      t.integer({
-        description: "Counter value. Used by atomic incr().",
-      }),
-    ),
-
-    expiresAt: t.optional(
-      t.datetime({
-        description: "Null means no expiration.",
-      }),
-    ),
+    value: z
+      .string()
+      .describe("Base64-encoded bytes. Used by set/get.")
+      .optional(),
+
+    count: z
+      .integer()
+      .describe("Counter value. Used by atomic incr().")
+      .optional(),
+
+    expiresAt: z.datetime().describe("Null means no expiration.").optional(),
   }),
   indexes: [{ columns: ["container", "cacheKey"], unique: true }, "expiresAt"],
 });

package/src/cache/database/providers/DatabaseCacheProvider.ts

@@ -1,4 +1,4 @@
-import { $atom, $hook, $inject, $state, Alepha, type Static, t } from "alepha";
+import { $atom, $hook, $inject, $state, Alepha, type Static, z } from "alepha";
 import { CacheProvider } from "alepha/cache";
 import { DateTimeProvider } from "alepha/datetime";
 import { $logger } from "alepha/logger";
@@ -12,20 +12,22 @@ import { cacheEntries } from "../entities/cacheEntries.ts";
  */
 export const databaseCacheOptions = $atom({
   name: "alepha.cache.database.options",
-  schema: t.object({
-    sweepProbability: t.number({
-      description:
+  schema: z.object({
+    sweepProbability: z
+      .number()
+      .min(0)
+      .max(1)
+      .describe(
         "Probability (0..1) that a write operation triggers a sweep of expired rows. Set to 0 to disable opportunistic sweeping.",
-      default: 0.01,
-      minimum: 0,
-      maximum: 1,
-    }),
-    sweepBatchSize: t.integer({
-      description:
+      )
+      .default(0.01),
+    sweepBatchSize: z
+      .integer()
+      .min(1)
+      .describe(
         "Maximum number of expired rows deleted per opportunistic sweep.",
-      default: 100,
-      minimum: 1,
-    }),
+      )
+      .default(100),
   }),
   default: {
     sweepProbability: 0.01,

package/src/cache/redis/providers/RedisCacheProvider.ts

@@ -1,4 +1,4 @@
-import { $atom, $inject, $state, Alepha, type Static, t } from "alepha";
+import { $atom, $inject, $state, Alepha, type Static, z } from "alepha";
 import { CacheProvider } from "alepha/cache";
 import { $logger } from "alepha/logger";
 import { RedisProvider } from "alepha/redis";
@@ -10,13 +10,13 @@ import { RedisProvider } from "alepha/redis";
  */
 export const redisCacheOptions = $atom({
   name: "alepha.cache.redis.options",
-  schema: t.object({
-    prefix: t.optional(
-      t.text({
+  schema: z.object({
+    prefix: z
+      .text({
         description:
           "Prefix for all cache keys in Redis. Useful for testing or multi-tenant applications.",
-      }),
-    ),
+      })
+      .optional(),
   }),
   default: {},
 });

package/src/captcha/providers/TurnstileCaptchaProvider.ts

@@ -1,4 +1,4 @@
-import { $context, AlephaError, t } from "alepha";
+import { $context, AlephaError, z } from "alepha";
 import { $logger } from "alepha/logger";
 import type { CaptchaProvider } from "./CaptchaProvider.ts";
 
@@ -70,12 +70,12 @@ export class TurnstileCaptchaProvider implements CaptchaProvider {
     const { alepha } = $context();
 
     const env = alepha.parseEnv(
-      t.object({
-        TURNSTILE_SECRET_KEY: t.text({
+      z.object({
+        TURNSTILE_SECRET_KEY: z.text({
           description:
             "The secret key from the Cloudflare Turnstile dashboard.",
         }),
-        TURNSTILE_SITE_KEY: t.text({
+        TURNSTILE_SITE_KEY: z.text({
           description:
             "The public site key from the Cloudflare Turnstile dashboard, rendered on the client.",
         }),

package/src/cli/core/__tests__/BuildCloudflareTask.spec.ts

@@ -0,0 +1,178 @@
+import { Alepha } from "alepha";
+import { FileSystemProvider, MemoryFileSystemProvider } from "alepha/system";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { BuildCloudflareTask } from "../tasks/BuildCloudflareTask.ts";
+
+/**
+ * Exposes the protected binding enhancers so the wrangler.jsonc shape can be
+ * asserted directly without driving a full build.
+ */
+class TestBuildCloudflareTask extends BuildCloudflareTask {
+  public testEnhanceD1 = this.enhanceD1.bind(this);
+  public testEnhanceR2 = this.enhanceR2.bind(this);
+  public testEnhanceQueue = this.enhanceQueue.bind(this);
+  public testWriteWorkerEntryPoint = this.writeWorkerEntryPoint.bind(this);
+}
+
+describe("BuildCloudflareTask", () => {
+  const createTask = () => {
+    const alepha = Alepha.create().with({
+      provide: FileSystemProvider,
+      use: MemoryFileSystemProvider,
+    });
+    return alepha.inject(TestBuildCloudflareTask);
+  };
+
+  const createTaskWithFs = () => {
+    const alepha = Alepha.create().with({
+      provide: FileSystemProvider,
+      use: MemoryFileSystemProvider,
+    });
+    return {
+      task: alepha.inject(TestBuildCloudflareTask),
+      fs: alepha.inject(MemoryFileSystemProvider),
+    };
+  };
+
+  // Snapshot + restore the env vars these enhancers read so tests don't leak.
+  const ENV_KEYS = [
+    "DATABASE_URL",
+    "R2_BUCKET_NAME",
+    "CLOUDFLARE_JURISDICTION",
+    "CLOUDFLARE_QUEUE_NAME",
+    "CLOUDFLARE_QUEUE_DLQ_NAME",
+    "CLOUDFLARE_QUEUE_MAX_RETRIES",
+  ] as const;
+  const saved: Record<string, string | undefined> = {};
+  beforeEach(() => {
+    for (const k of ENV_KEYS) saved[k] = process.env[k];
+  });
+  afterEach(() => {
+    for (const k of ENV_KEYS) {
+      if (saved[k] === undefined) delete process.env[k];
+      else process.env[k] = saved[k];
+    }
+  });
+
+  describe("enhanceD1", () => {
+    it("does not emit `jurisdiction` on the D1 binding (wrangler rejects it)", () => {
+      // D1 jurisdiction is applied at database-creation time, not on the
+      // binding — wrangler warns on the unexpected field. See CloudflareApi.
+      process.env.DATABASE_URL = "d1://my-db:db-id-123";
+      process.env.CLOUDFLARE_JURISDICTION = "eu";
+
+      const wrangler: Record<string, any> = {};
+      createTask().testEnhanceD1(wrangler);
+
+      expect(wrangler.d1_databases).toEqual([
+        { binding: "DB", database_name: "my-db", database_id: "db-id-123" },
+      ]);
+      expect(wrangler.d1_databases[0]).not.toHaveProperty("jurisdiction");
+      expect(wrangler.vars.DATABASE_URL).toBe("d1://DB");
+    });
+
+    it("ignores non-d1 DATABASE_URL", () => {
+      process.env.DATABASE_URL = "postgres://localhost/db";
+      const wrangler: Record<string, any> = {};
+      createTask().testEnhanceD1(wrangler);
+      expect(wrangler.d1_databases).toBeUndefined();
+    });
+  });
+
+  describe("enhanceR2", () => {
+    it("keeps `jurisdiction` on the R2 binding (wrangler accepts it)", () => {
+      process.env.R2_BUCKET_NAME = "my-bucket";
+      process.env.CLOUDFLARE_JURISDICTION = "eu";
+
+      const wrangler: Record<string, any> = {};
+      createTask().testEnhanceR2(wrangler);
+
+      expect(wrangler.r2_buckets).toEqual([
+        { binding: "my-bucket", bucket_name: "my-bucket", jurisdiction: "eu" },
+      ]);
+    });
+  });
+
+  describe("enhanceQueue", () => {
+    /**
+     * The worker's queue handler calls `msg.retry()` on any throw. Without a
+     * `dead_letter_queue`, CF burns its retries and then DISCARDS the message —
+     * a poison job disappears with no record and no signal.
+     */
+    it("gives the consumer a dead-letter queue and a retry ceiling", () => {
+      process.env.CLOUDFLARE_QUEUE_NAME = "my-queue";
+
+      const wrangler: Record<string, any> = {};
+      createTask().testEnhanceQueue(wrangler);
+
+      expect(wrangler.queues.consumers).toEqual([
+        {
+          queue: "my-queue",
+          dead_letter_queue: "my-queue-dlq",
+          max_retries: 3,
+        },
+      ]);
+    });
+
+    it("honours an explicit dead-letter queue and retry ceiling", () => {
+      process.env.CLOUDFLARE_QUEUE_NAME = "my-queue";
+      process.env.CLOUDFLARE_QUEUE_DLQ_NAME = "shared-dlq";
+      process.env.CLOUDFLARE_QUEUE_MAX_RETRIES = "5";
+
+      const wrangler: Record<string, any> = {};
+      createTask().testEnhanceQueue(wrangler);
+
+      expect(wrangler.queues.consumers[0]).toEqual({
+        queue: "my-queue",
+        dead_letter_queue: "shared-dlq",
+        max_retries: 5,
+      });
+    });
+
+    it("ignores a non-numeric retry ceiling rather than emitting NaN", () => {
+      process.env.CLOUDFLARE_QUEUE_NAME = "my-queue";
+      process.env.CLOUDFLARE_QUEUE_MAX_RETRIES = "not-a-number";
+
+      const wrangler: Record<string, any> = {};
+      createTask().testEnhanceQueue(wrangler);
+
+      expect(wrangler.queues.consumers[0].max_retries).toBe(3);
+    });
+  });
+
+  describe("writeWorkerEntryPoint", () => {
+    const ENTRY = "/root/dist/main.cloudflare.js";
+
+    /**
+     * A single CF isolate serves concurrent invocations. Stashing the
+     * per-invocation `executionCtx.waitUntil` on the shared Alepha store means
+     * request B overwrites request A's, and A's background work then calls B's
+     * (already-returned) context — "waitUntil after response" — silently
+     * killing it. The handle must ride the per-invocation async context.
+     */
+    it("does not stash waitUntil on the shared global store", async () => {
+      const { task, fs } = createTaskWithFs();
+
+      await task.testWriteWorkerEntryPoint("/root", "dist");
+
+      expect(
+        fs.wasWrittenMatching(
+          ENTRY,
+          /__alepha\.set\(\s*["']cloudflare\.waitUntil["']/,
+        ),
+      ).toBe(false);
+    });
+
+    it("scopes waitUntil to each invocation's async context", async () => {
+      const { task, fs } = createTaskWithFs();
+
+      await task.testWriteWorkerEntryPoint("/root", "dist");
+
+      // Every entry point (fetch / scheduled / queue) must run its body inside
+      // an Alepha fork seeded with that invocation's waitUntil.
+      expect(fs.wasWrittenMatching(ENTRY, /__alepha\.context\.run\(/)).toBe(
+        true,
+      );
+    });
+  });
+});

package/src/cli/core/__tests__/BuildDockerTask.spec.ts

@@ -50,8 +50,6 @@ describe("BuildDockerTask", () => {
     run.rm = async () => "";
     run.cp = async () => "";
     run.end = () => {};
-    run.pause = () => {};
-    run.resume = () => {};
     return run;
   };
 

package/src/cli/core/__tests__/DbCommand.spec.ts

@@ -0,0 +1,108 @@
+import { Alepha } from "alepha";
+import { FileSystemProvider, MemoryFileSystemProvider } from "alepha/system";
+import { describe, expect, it } from "vitest";
+import { DbCommand } from "../commands/db.ts";
+
+/**
+ * Exposes the destructive-migration guard so it can be driven without booting
+ * a real app + drizzle-kit.
+ */
+class TestDbCommand extends DbCommand {
+  public testAssertNoDestructiveMigrations =
+    this.assertNoDestructiveMigrations.bind(this);
+}
+
+describe("DbCommand", () => {
+  const create = () => {
+    const alepha = Alepha.create().with({
+      provide: FileSystemProvider,
+      use: MemoryFileSystemProvider,
+    });
+    return {
+      db: alepha.inject(TestDbCommand),
+      fs: alepha.inject(MemoryFileSystemProvider),
+    };
+  };
+
+  /**
+   * D1 ignores `PRAGMA foreign_keys=OFF`, so a generated migration that drops a
+   * CASCADE parent silently wipes every child row on deploy. Today the only
+   * defence is a human remembering to grep the migration before pushing.
+   */
+  describe("assertNoDestructiveMigrations", () => {
+    it("rejects a newly generated migration containing DROP TABLE", async () => {
+      const { db, fs } = create();
+      await fs.writeFile(
+        "/app/migrations/sqlite/0042_drop_it.sql",
+        'ALTER TABLE "quests" ADD COLUMN "note" text;\nDROP TABLE "campaigns";',
+      );
+
+      await expect(
+        db.testAssertNoDestructiveMigrations("/app/migrations/sqlite", [
+          "0042_drop_it.sql",
+        ]),
+      ).rejects.toThrowError(/DROP TABLE/);
+    });
+
+    it("names the offending file so it can be reviewed", async () => {
+      const { db, fs } = create();
+      await fs.writeFile(
+        "/app/migrations/sqlite/0042_drop_it.sql",
+        'DROP TABLE IF EXISTS "campaigns";',
+      );
+
+      await expect(
+        db.testAssertNoDestructiveMigrations("/app/migrations/sqlite", [
+          "0042_drop_it.sql",
+        ]),
+      ).rejects.toThrowError(/0042_drop_it\.sql/);
+    });
+
+    it("accepts a migration with no table drops", async () => {
+      const { db, fs } = create();
+      await fs.writeFile(
+        "/app/migrations/sqlite/0043_add_col.sql",
+        'ALTER TABLE "quests" ADD COLUMN "note" text;',
+      );
+
+      await expect(
+        db.testAssertNoDestructiveMigrations("/app/migrations/sqlite", [
+          "0043_add_col.sql",
+        ]),
+      ).resolves.toBeUndefined();
+    });
+
+    it("ignores DROP TABLE inside a SQL comment", async () => {
+      const { db, fs } = create();
+      await fs.writeFile(
+        "/app/migrations/sqlite/0044_comment.sql",
+        '-- DROP TABLE "campaigns"; (kept for reference)\nALTER TABLE "quests" ADD COLUMN "note" text;',
+      );
+
+      await expect(
+        db.testAssertNoDestructiveMigrations("/app/migrations/sqlite", [
+          "0044_comment.sql",
+        ]),
+      ).resolves.toBeUndefined();
+    });
+
+    it("does not flag pre-existing migrations, only the newly generated ones", async () => {
+      const { db, fs } = create();
+      // An old, already-applied migration that legitimately dropped a table.
+      await fs.writeFile(
+        "/app/migrations/sqlite/0001_old.sql",
+        'DROP TABLE "legacy";',
+      );
+      await fs.writeFile(
+        "/app/migrations/sqlite/0045_new.sql",
+        'ALTER TABLE "quests" ADD COLUMN "note" text;',
+      );
+
+      await expect(
+        db.testAssertNoDestructiveMigrations("/app/migrations/sqlite", [
+          "0045_new.sql",
+        ]),
+      ).resolves.toBeUndefined();
+    });
+  });
+});

package/src/cli/core/atoms/appEntryOptions.ts

@@ -1,11 +1,11 @@
-import { $atom, type Static, t } from "alepha";
+import { $atom, type Static, z } from "alepha";
 
 export const appEntryOptions = $atom({
   name: "alepha.cli.appEntry.options",
-  schema: t.object({
-    server: t.optional(t.text()),
-    browser: t.optional(t.text()),
-    style: t.optional(t.text()),
+  schema: z.object({
+    server: z.text().optional(),
+    browser: z.text().optional(),
+    style: z.text().optional(),
   }),
   default: {},
 });