@wtfalch/foundry 0.73.0 → 0.74.0

package/dist/store/postgres.js

@@ -1,4 +1,4 @@
-import { and, asc, desc, eq, gte, inArray, isNull, ne, sql } from 'drizzle-orm';
+import { and, asc, desc, eq, gt, gte, inArray, isNotNull, isNull, lte, ne, or, sql, } from 'drizzle-orm';
 import { APP_ENTRY_KEY, DEFAULT_MAIL_APPS, DEFAULT_NO_REPLY_LOCAL_PART, normalizeHostingRepos, refuseBuiltinBlueGreen, refuseCustomers, refuseHosting, validateBlueGreen, validateBuyerIdentity, validateCalls, validateDomain, validateDomainClaim, validateMail, validateOwners, validateServices, validateSignIn, validateSite, validateVersionPin, withNewOrgAppsDefault, } from '../org.js';
 import { hostingNames } from '../plan/locked-hostnames.js';
 import { findNameClashes, nameClashMessage } from '../plan/org-names.js';
@@ -1066,6 +1066,46 @@ export function createPostgresAppliedVersionsStore(db) {
         },
     };
 }
+/** A request row, and for a go-live with a time its `scheduled` line, in the caller's transaction. */
+async function insertScheduledRequest(tx, input) {
+    const { orgId, entryKey, action, actor, notBefore } = input;
+    await tx.insert(foundryReleaseRequests).values({
+        orgId,
+        entryKey,
+        action,
+        actor,
+        ...(notBefore ? { notBefore: new Date(notBefore) } : {}),
+    });
+    if (notBefore && action.kind === 'go_live') {
+        await tx.insert(foundryReleaseEvents).values({
+            orgId,
+            entryKey,
+            at: new Date(),
+            kind: 'scheduled',
+            payload: { actor, reason: `${action.tag} at ${new Date(notBefore).toISOString()}` },
+        });
+    }
+}
+/** Consumes a waiting request in one statement and writes `schedule_cancelled` with it. False when it was not open, was claimed, or is already due. */
+async function cancelScheduledRequest(tx, input) {
+    const rows = await tx
+        .update(foundryReleaseRequests)
+        .set({ consumedAt: sql `now()` })
+        .where(and(eq(foundryReleaseRequests.id, input.id), eq(foundryReleaseRequests.orgId, input.orgId), eq(foundryReleaseRequests.entryKey, input.entryKey), isNull(foundryReleaseRequests.consumedAt), isNull(foundryReleaseRequests.claimedAt), gt(foundryReleaseRequests.notBefore, input.now ?? sql `now()`)))
+        .returning({ action: foundryReleaseRequests.action });
+    const row = rows[0];
+    if (!row)
+        return false;
+    const tag = row.action.tag;
+    await tx.insert(foundryReleaseEvents).values({
+        orgId: input.orgId,
+        entryKey: input.entryKey,
+        at: new Date(),
+        kind: 'schedule_cancelled',
+        payload: { actor: input.actor, ...(typeof tag === 'string' ? { reason: tag } : {}) },
+    });
+    return true;
+}
 /**
  * `ReleaseStore` (`../release/state.ts`) on Postgres: the recorded `bg.*`
  * keys come from an org's applied state, or the platform's for the orgId
@@ -1089,18 +1129,69 @@ export function createPostgresReleaseStore(db) {
                 .limit(1);
             return row?.ids ?? {};
         },
-        async addRequest({ orgId, entryKey, action, actor }) {
-            await db.insert(foundryReleaseRequests).values({ orgId, entryKey, action, actor });
+        async addRequest({ orgId, entryKey, action, actor, notBefore }) {
+            await db.transaction(async (tx) => {
+                await insertScheduledRequest(tx, { orgId, entryKey, action, actor, notBefore });
+            });
         },
-        async openRequests({ orgId, entryKey }) {
+        async openRequests({ orgId, entryKey, now }) {
             const rows = await db
                 .select()
                 .from(foundryReleaseRequests)
-                .where(and(eq(foundryReleaseRequests.orgId, orgId), eq(foundryReleaseRequests.entryKey, entryKey), isNull(foundryReleaseRequests.consumedAt)))
+                .where(and(eq(foundryReleaseRequests.orgId, orgId), eq(foundryReleaseRequests.entryKey, entryKey), isNull(foundryReleaseRequests.consumedAt), or(isNull(foundryReleaseRequests.notBefore), lte(foundryReleaseRequests.notBefore, now ?? sql `now()`))))
                 .orderBy(asc(foundryReleaseRequests.id));
             return rows.flatMap((row) => {
                 const action = releaseActionSchema.safeParse(row.action);
-                return action.success ? [{ id: row.id, action: action.data, actor: row.actor }] : [];
+                return action.success
+                    ? [
+                        {
+                            id: row.id,
+                            action: action.data,
+                            actor: row.actor,
+                            notBefore: row.notBefore ? row.notBefore.toISOString() : null,
+                        },
+                    ]
+                    : [];
+            });
+        },
+        async claimRequests(ids) {
+            if (ids.length === 0)
+                return;
+            await db
+                .update(foundryReleaseRequests)
+                .set({ claimedAt: sql `now()` })
+                .where(and(inArray(foundryReleaseRequests.id, [...ids]), isNull(foundryReleaseRequests.claimedAt)));
+        },
+        async cancelRequest(input) {
+            return db.transaction((tx) => cancelScheduledRequest(tx, input));
+        },
+        async readScheduled({ orgId, entryKey }) {
+            const rows = await db
+                .select()
+                .from(foundryReleaseRequests)
+                .where(and(eq(foundryReleaseRequests.orgId, orgId), eq(foundryReleaseRequests.entryKey, entryKey), isNull(foundryReleaseRequests.consumedAt), isNotNull(foundryReleaseRequests.notBefore)))
+                .orderBy(asc(foundryReleaseRequests.notBefore), asc(foundryReleaseRequests.id));
+            return rows.flatMap((row) => {
+                const action = releaseActionSchema.safeParse(row.action);
+                return action.success && row.notBefore
+                    ? [
+                        {
+                            id: row.id,
+                            action: action.data,
+                            notBefore: row.notBefore.toISOString(),
+                            actor: row.actor,
+                            claimed: row.claimedAt !== null,
+                        },
+                    ]
+                    : [];
+            });
+        },
+        async rescheduleRequest({ id, orgId, entryKey, action, notBefore, actor, now }) {
+            return db.transaction(async (tx) => {
+                if (!(await cancelScheduledRequest(tx, { id, orgId, entryKey, actor, now })))
+                    return false;
+                await insertScheduledRequest(tx, { orgId, entryKey, action, actor, notBefore });
+                return true;
             });
         },
         async consumeRequests(ids) {

package/dist/store/schema.d.ts

@@ -2906,6 +2906,40 @@ export declare const foundryReleaseRequests: import("drizzle-orm/pg-core").PgTab
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
+        notBefore: import("drizzle-orm/pg-core").PgColumn<{
+            name: "not_before";
+            tableName: "foundry_release_requests";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        claimedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "claimed_at";
+            tableName: "foundry_release_requests";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
     };
     dialect: "pg";
 }>;

package/dist/store/schema.js

@@ -1,4 +1,5 @@
-import { bigint, bigserial, boolean, integer, jsonb, pgTable, text, timestamp, } from 'drizzle-orm/pg-core';
+import { sql } from 'drizzle-orm';
+import { bigint, bigserial, boolean, index, integer, jsonb, pgTable, text, timestamp, } from 'drizzle-orm/pg-core';
 /**
  * Mirrors `migrations/0001_declared_org.sql`, which is the source of truth:
  * the SQL carries the CHECKs drizzle-kit does not generate here (this
@@ -271,7 +272,15 @@ export const foundryReleaseRequests = pgTable('foundry_release_requests', {
     actor: text('actor').notNull(),
     createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
     consumedAt: timestamp('consumed_at', { withTimezone: true }),
-});
+    /** `migrations/0071_release_request_schedule.sql`: null is due at once. */
+    notBefore: timestamp('not_before', { withTimezone: true }),
+    /** Set when the runner starts a due go-live; a claimed request can no longer be cancelled or moved. */
+    claimedAt: timestamp('claimed_at', { withTimezone: true }),
+}, (t) => [
+    index('foundry_release_requests_scheduled_idx')
+        .on(t.orgId, t.entryKey, t.notBefore)
+        .where(sql `consumed_at is null and not_before is not null`),
+]);
 /** Mirrors `migrations/0069_release_events.sql`: a release's history, appended by the release run and never changed. */
 export const foundryReleaseEvents = pgTable('foundry_release_events', {
     id: bigserial('id', { mode: 'number' }).primaryKey(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wtfalch/foundry",
-  "version": "0.73.0",
+  "version": "0.74.0",
   "description": "Foundry's SDK: the declared org's types, the plan and apply contracts, and the state store's interface.",
   "repository": {
     "type": "git",