@rikalabs/akter 0.1.0-alpha.4 → 0.1.0-alpha.6

package/dist/runtime/database/migrations.js

@@ -1213,6 +1213,77 @@ export const migrations = {
         ${[...FIRST_VIEWS, ["views", 1]].map(([view, version]) => `('${view}', ${version})`).join(", ")}
       ) AS v(view_name, version)`);
     }),
+    /** Cold pointers replace state and blob rows atomically; garbage rows never authorize deletion by themselves. */
+    "0034_cold_tier": Effect.gen(function* () {
+        const sql = yield* SqlClient.SqlClient;
+        yield* briefLocks(Effect.gen(function* () {
+            yield* sql `ALTER TABLE actor_generations
+        ADD COLUMN cold_ref text,
+        ADD COLUMN cold_digest text,
+        ADD COLUMN cold_state_version integer,
+        ADD CONSTRAINT actor_generations_cold_check CHECK (
+          (cold_ref IS NULL AND cold_digest IS NULL AND cold_state_version IS NULL)
+          OR (cold_ref IS NOT NULL AND cold_digest IS NOT NULL AND cold_state_version IS NOT NULL
+            AND cold_digest ~ '^[0-9a-f]{64}$' AND cold_state_version >= 0))`;
+            yield* sql `ALTER TABLE actor_outbox DROP CONSTRAINT actor_outbox_kind_check,
+        ADD CONSTRAINT actor_outbox_kind_check CHECK (kind IN ('intent', 'job', 'feed', 'control', 'cold')),
+        ADD CONSTRAINT actor_outbox_cold_check CHECK (
+          (kind = 'cold') = (command = '$cold') AND
+          (kind <> 'cold' OR (timer_key = '$cold' AND target_type = actor_type
+            AND target_id = actor_id AND payload = 'null' AND caller::jsonb->>'source' = 'cold'
+            AND caller::jsonb->>'_tag' = 'System') IS TRUE))`;
+            yield* sql `ALTER TABLE actor_placements ADD COLUMN state_version integer NOT NULL DEFAULT 0`;
+        }));
+        yield* sql `CREATE INDEX actor_generations_cold_version
+      ON actor_generations (actor_type, cold_state_version) WHERE cold_ref IS NOT NULL`;
+        yield* sql `CREATE TABLE actor_cold_garbage (
+      routing_key bigint NOT NULL,
+      tenant_id text NOT NULL,
+      actor_type text NOT NULL,
+      actor_id text NOT NULL,
+      object_key text NOT NULL,
+      unreferenced_at_ms bigint NOT NULL,
+      PRIMARY KEY (routing_key, object_key)
+    )`;
+        yield* sql `CREATE INDEX actor_cold_garbage_due ON actor_cold_garbage (unreferenced_at_ms)`;
+        yield* sql `ALTER TABLE actor_cold_garbage ENABLE ROW LEVEL SECURITY`;
+        yield* sql `CREATE POLICY durable_tenant ON actor_cold_garbage
+      USING (tenant_id = current_setting('durable.tenant', true))
+      WITH CHECK (tenant_id = current_setting('durable.tenant', true))`;
+        yield* sql `CREATE OR REPLACE VIEW durable.actors AS
+      SELECT g.tenant_id, g.actor_type, g.actor_id, g.routing_key, p.placement,
+        g.generation, g.created, g.event_sequence AS last_event_sequence,
+        g.cold_ref IS NOT NULL AS cold
+      FROM actor_generations g
+      LEFT JOIN actor_placements p ON p.actor_type = g.actor_type`;
+    }),
+    /** The transaction's generation lock, not a referential trigger, authorizes state and receipt writes. */
+    "0035_hot_table_foreign_keys": Effect.gen(function* () {
+        const sql = yield* SqlClient.SqlClient;
+        yield* briefLocks(Effect.gen(function* () {
+            for (const table of ["actor_state", "actor_receipts"]) {
+                const constraints = yield* sql `
+            SELECT c.conname AS name FROM pg_constraint c
+            WHERE c.contype = 'f' AND c.conrelid = ${table}::regclass
+              AND c.confrelid = 'actor_generations'::regclass
+              AND c.confupdtype = 'a' AND c.confdeltype = 'a' AND c.confmatchtype = 's'
+              AND c.convalidated AND NOT c.condeferrable AND NOT c.condeferred
+              AND ARRAY(SELECT a.attname::text FROM unnest(c.conkey) WITH ORDINALITY k(n, ord)
+                JOIN pg_attribute a ON a.attrelid = c.conrelid AND a.attnum = k.n
+                ORDER BY k.ord) = ARRAY['routing_key', 'tenant_id', 'actor_type', 'actor_id']
+              AND ARRAY(SELECT a.attname::text FROM unnest(c.confkey) WITH ORDINALITY k(n, ord)
+                JOIN pg_attribute a ON a.attrelid = c.confrelid AND a.attnum = k.n
+                ORDER BY k.ord) = ARRAY['routing_key', 'tenant_id', 'actor_type', 'actor_id']`;
+                if (constraints.length !== 1) {
+                    return yield* new Migrator.MigrationError({
+                        kind: "BadState",
+                        message: `Expected exactly one generation foreign key on ${table}; found ${constraints.length}`,
+                    });
+                }
+                yield* sql `ALTER TABLE ${sql(table)} DROP CONSTRAINT ${sql(constraints[0].name)}`;
+            }
+        }));
+    }),
 };
 /**
  * Runs `record` like `Migrator`, but first refuses a database where a
@@ -1246,7 +1317,7 @@ export const migrator = (record) => {
     const transactional = refuseSkipped.pipe(Effect.andThen(run), Effect.tap(() => refuseSkipped));
     return Effect.gen(function* () {
         return yield* Option.isSome(yield* Effect.serviceOption(PgClient.PgClient))
-            ? withMigrationCoordination(transactional)
+            ? withMigrationCoordination({ effect: transactional, history: "actor_migrations" })
             : transactional;
     });
 };

package/dist/runtime/entity/mailbox.d.ts

@@ -65,22 +65,30 @@ export declare const takeBatch: <W extends Mergeable & {
  * front command is takeable, so the worker never sleeps past ready work and a
  * command whose hook is still running holds back every command behind it.
  * `alone` outlives the handler: it holds the ids of a failed batch, each run
- * in a transaction of its own once.
+ * in a transaction of its own once. Methods are shared; the waiting commands,
+ * wake-up and retry isolation belong to this handler alone.
  */
 export declare const activationMailbox: <W extends Mergeable & {
     queued: boolean;
-}>(alone: Set<string>) => {
-    offer: (entry: W) => void;
+}>(alone: Set<string>) => ActivationMailbox<W>;
+declare class ActivationMailbox<W extends Mergeable & {
+    queued: boolean;
+}> {
+    private readonly alone;
+    private readonly waiting;
+    private readonly ready;
+    constructor(alone: Set<string>);
+    offer(entry: W): void;
     /** Marks `entry`'s `queued` hook finished, so a batch may take it. */
-    queued: (entry: W) => void;
+    queued(entry: W): void;
     /** Waits until the front command may be takeable. */
-    await: import("effect/Effect").Effect<void, never, never>;
+    readonly await: import("effect/Effect").Effect<void, never, never>;
     /** The next batch, possibly empty; the wake-up closes once the front command is not takeable. */
-    take: () => W[];
+    take(): W[];
     /** Puts taken commands back in front of everything that arrived since. */
-    requeue: (entries: ReadonlyArray<W>) => void;
+    requeue(entries: ReadonlyArray<W>): void;
     /** Runs each of `ids` alone once, the next time it is taken. */
-    isolate: (ids: Iterable<string>) => void;
-    size: () => number;
-};
+    isolate(ids: Iterable<string>): void;
+    size(): number;
+}
 export {};

package/dist/runtime/entity/mailbox.js

@@ -84,38 +84,46 @@ export const takeBatch = ({ waiting, alone, }) => {
  * front command is takeable, so the worker never sleeps past ready work and a
  * command whose hook is still running holds back every command behind it.
  * `alone` outlives the handler: it holds the ids of a failed batch, each run
- * in a transaction of its own once.
+ * in a transaction of its own once. Methods are shared; the waiting commands,
+ * wake-up and retry isolation belong to this handler alone.
  */
-export const activationMailbox = (alone) => {
-    const waiting = [];
-    const ready = Latch.makeUnsafe(false);
-    return {
-        offer: (entry) => {
-            waiting.push(entry);
-        },
-        /** Marks `entry`'s `queued` hook finished, so a batch may take it. */
-        queued: (entry) => {
-            entry.queued = true;
-            ready.openUnsafe();
-        },
-        /** Waits until the front command may be takeable. */
-        await: ready.await,
-        /** The next batch, possibly empty; the wake-up closes once the front command is not takeable. */
-        take: () => {
-            const batch = takeBatch({ waiting, alone });
-            if (waiting[0]?.queued !== true)
-                ready.closeUnsafe();
-            return batch;
-        },
-        /** Puts taken commands back in front of everything that arrived since. */
-        requeue: (entries) => {
-            if (entries.length === 0)
-                return;
-            waiting.unshift(...entries);
-            ready.openUnsafe();
-        },
-        /** Runs each of `ids` alone once, the next time it is taken. */
-        isolate: (ids) => markAlone({ alone, ids }),
-        size: () => waiting.length,
-    };
-};
+export const activationMailbox = (alone) => new ActivationMailbox(alone);
+class ActivationMailbox {
+    alone;
+    waiting = [];
+    ready = Latch.makeUnsafe(false);
+    constructor(alone) {
+        this.alone = alone;
+    }
+    offer(entry) {
+        this.waiting.push(entry);
+    }
+    /** Marks `entry`'s `queued` hook finished, so a batch may take it. */
+    queued(entry) {
+        entry.queued = true;
+        this.ready.openUnsafe();
+    }
+    /** Waits until the front command may be takeable. */
+    await = this.ready.await;
+    /** The next batch, possibly empty; the wake-up closes once the front command is not takeable. */
+    take() {
+        const batch = takeBatch({ waiting: this.waiting, alone: this.alone });
+        if (this.waiting[0]?.queued !== true)
+            this.ready.closeUnsafe();
+        return batch;
+    }
+    /** Puts taken commands back in front of everything that arrived since. */
+    requeue(entries) {
+        if (entries.length === 0)
+            return;
+        this.waiting.unshift(...entries);
+        this.ready.openUnsafe();
+    }
+    /** Runs each of `ids` alone once, the next time it is taken. */
+    isolate(ids) {
+        markAlone({ alone: this.alone, ids });
+    }
+    size() {
+        return this.waiting.length;
+    }
+}

package/dist/runtime/entity/register.d.ts

@@ -42,7 +42,7 @@ export declare const commandEntity: (name: string) => Entity.Entity<string, Rpc.
     readonly caller: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"User", {
         readonly subject: Schema.NonEmptyString;
     }>, Schema.TaggedStruct<"Anonymous", {}>, Schema.TaggedStruct<"System", {
-        readonly source: Schema.Literals<readonly ["process", "actor", "timer", "cron", "workflow", "job", "subscription"]>;
+        readonly source: Schema.Literals<readonly ["process", "actor", "timer", "cron", "workflow", "job", "subscription", "cold"]>;
         readonly ref: Schema.optional<Schema.Struct<{
             readonly tenant: Schema.NonEmptyString;
             readonly actor: Schema.NonEmptyString;
@@ -147,7 +147,7 @@ export declare const connectionEntity: (name: string) => Entity.Entity<`${string
     caller: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"User", {
         readonly subject: Schema.NonEmptyString;
     }>, Schema.TaggedStruct<"Anonymous", {}>, Schema.TaggedStruct<"System", {
-        readonly source: Schema.Literals<readonly ["process", "actor", "timer", "cron", "workflow", "job", "subscription"]>;
+        readonly source: Schema.Literals<readonly ["process", "actor", "timer", "cron", "workflow", "job", "subscription", "cold"]>;
         readonly ref: Schema.optional<Schema.Struct<{
             readonly tenant: Schema.NonEmptyString;
             readonly actor: Schema.NonEmptyString;
@@ -224,7 +224,7 @@ export declare const connectionEntity: (name: string) => Entity.Entity<`${string
     caller: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"User", {
         readonly subject: Schema.NonEmptyString;
     }>, Schema.TaggedStruct<"Anonymous", {}>, Schema.TaggedStruct<"System", {
-        readonly source: Schema.Literals<readonly ["process", "actor", "timer", "cron", "workflow", "job", "subscription"]>;
+        readonly source: Schema.Literals<readonly ["process", "actor", "timer", "cron", "workflow", "job", "subscription", "cold"]>;
         readonly ref: Schema.optional<Schema.Struct<{
             readonly tenant: Schema.NonEmptyString;
             readonly actor: Schema.NonEmptyString;