@wtfalch/foundry 0.42.1 → 0.43.0

package/dist/release/types.d.ts

@@ -0,0 +1,54 @@
+export type Color = 'blue' | 'green';
+export type WindowState = {
+    kind: 'idle';
+} | {
+    kind: 'step';
+    percent: number;
+    since: string;
+} | {
+    kind: 'inconclusive';
+    percent: number;
+    since: string;
+} | {
+    kind: 'window';
+    since: string;
+} | {
+    kind: 'passed';
+    at: string;
+} | {
+    kind: 'rolled_back';
+    at: string;
+    reason: string;
+} | {
+    kind: 'cap';
+    since: string;
+};
+export interface ReleaseSignal {
+    requests: number;
+    errors: number;
+    baselineRate: number | null;
+    verdict: 'pass' | 'fail' | 'hard_fail' | 'inconclusive';
+}
+export interface ReleaseState {
+    entryKey: string;
+    live: Color;
+    weights: Record<Color, number>;
+    digests: Record<Color, string | null>;
+    stageDigest: string | null;
+    window: WindowState;
+    signal: ReleaseSignal | null;
+    held: string[];
+}
+export type ReleaseAction = {
+    kind: 'promote';
+} | {
+    kind: 'rollback';
+} | {
+    kind: 'clear_held';
+    digest: string;
+} | {
+    kind: 'decide_at_cap';
+    decision: 'pass' | 'rollback';
+};
+export declare const COLORS: readonly Color[];
+export declare function otherColor(color: Color): Color;

package/dist/release/types.js

@@ -0,0 +1,4 @@
+export const COLORS = ['blue', 'green'];
+export function otherColor(color) {
+    return color === 'blue' ? 'green' : 'blue';
+}

package/dist/store/postgres.d.ts

@@ -1,4 +1,5 @@
 import type { PgDatabase, PgQueryResultHKT } from 'drizzle-orm/pg-core';
+import { type ReleaseStore } from '../release/state.js';
 import { type AppliedVersionsStore, type DeclaredOrgStore, type PlatformStore, type RequestedChangeStore } from '../store.js';
 /**
  * The host's own drizzle handle or a transaction open on it, same shape
@@ -98,3 +99,10 @@ export declare function createPostgresRequestedChangeStore(db: FoundryStoreDb):
  * lost the way `foundry_applied_state`'s one row per service would lose it.
  */
 export declare function createPostgresAppliedVersionsStore(db: FoundryStoreDb): AppliedVersionsStore;
+/**
+ * `ReleaseStore` (`../release/state.ts`) on Postgres: the recorded `bg.*`
+ * keys come from an org's applied state, or the platform's for the orgId
+ * `platform`; requests are rows in `foundry_release_requests`. Reading leaves
+ * the open rows consumed only when the caller says its run succeeded (`consumeRequests`).
+ */
+export declare function createPostgresReleaseStore(db: FoundryStoreDb): ReleaseStore;

package/dist/store/postgres.js

@@ -1,12 +1,13 @@
-import { and, asc, desc, eq, ne, sql } from 'drizzle-orm';
-import { APP_ENTRY_KEY, DEFAULT_MAIL_APPS, DEFAULT_NO_REPLY_LOCAL_PART, validateBuyerIdentity, validateCalls, validateDomain, validateDomainClaim, validateHosting, validateMail, validateOwners, validateServices, validateSignIn, validateSite, validateVersionPin, } from '../org.js';
+import { and, asc, desc, eq, inArray, isNull, ne, sql } from 'drizzle-orm';
+import { APP_ENTRY_KEY, DEFAULT_MAIL_APPS, DEFAULT_NO_REPLY_LOCAL_PART, validateBlueGreen, validateBuyerIdentity, validateCalls, validateDomain, validateDomainClaim, validateHosting, validateMail, validateOwners, validateServices, validateSignIn, validateSite, validateVersionPin, } from '../org.js';
 import { lockedHostnames } from '../plan/locked-hostnames.js';
 import { findNameClashes, nameClashMessage } from '../plan/org-names.js';
 import { validatePlatform } from '../platform.js';
+import { releaseActionSchema } from '../release/state.js';
 import { RequestedChangeError, classifyChange } from '../requested-changes.js';
 import { validateSlug } from '../slug.js';
 import { StaleLeaseError, } from '../store.js';
-import { declaredOrgs, foundryAppliedState, foundryAppliedVersions, foundryDeclaredPlatform, foundryMutationLeases, foundryRequestedChanges, } from './schema.js';
+import { declaredOrgs, foundryAppliedState, foundryAppliedVersions, foundryDeclaredPlatform, foundryMutationLeases, foundryReleaseRequests, foundryRequestedChanges, } from './schema.js';
 const UNIQUE_VIOLATION = '23505';
 /**
  * #441: runs `write`, and with a `fence` only if its token is still the
@@ -718,6 +719,10 @@ function rowToPlatform(row) {
             enabled: row.archonEnabled,
             hostname: row.archonHostname,
             gitRef: row.archonGitRef,
+            // Omitted while off. Validated on read: a stored value is not trusted.
+            ...(row.archonBlueGreen && validateBlueGreen(row.archonBlueGreen, 'archon') === null
+                ? { blueGreen: row.archonBlueGreen }
+                : {}),
         },
         edge: {
             enabled: row.edgeEnabled,
@@ -771,6 +776,7 @@ function platformToRow(platform) {
         archonEnabled: platform.archon.enabled,
         archonHostname: platform.archon.hostname,
         archonGitRef: platform.archon.gitRef,
+        archonBlueGreen: platform.archon.blueGreen ?? null,
         edgeEnabled: platform.edge.enabled,
         edgeHostname: platform.edge.hostname,
         edgeGitRef: platform.edge.gitRef,
@@ -923,3 +929,50 @@ export function createPostgresAppliedVersionsStore(db) {
         },
     };
 }
+/**
+ * `ReleaseStore` (`../release/state.ts`) on Postgres: the recorded `bg.*`
+ * keys come from an org's applied state, or the platform's for the orgId
+ * `platform`; requests are rows in `foundry_release_requests`. Reading leaves
+ * the open rows consumed only when the caller says its run succeeded (`consumeRequests`).
+ */
+export function createPostgresReleaseStore(db) {
+    return {
+        async getScopeIds(orgId) {
+            if (orgId === 'platform') {
+                const [row] = await db
+                    .select({ ids: foundryDeclaredPlatform.serviceIds })
+                    .from(foundryDeclaredPlatform)
+                    .limit(1);
+                return row?.ids ?? {};
+            }
+            const [row] = await db
+                .select({ ids: foundryAppliedState.serviceIds })
+                .from(foundryAppliedState)
+                .where(eq(foundryAppliedState.orgId, orgId))
+                .limit(1);
+            return row?.ids ?? {};
+        },
+        async addRequest({ orgId, entryKey, action, actor }) {
+            await db.insert(foundryReleaseRequests).values({ orgId, entryKey, action, actor });
+        },
+        async openRequests({ orgId, entryKey }) {
+            const rows = await db
+                .select()
+                .from(foundryReleaseRequests)
+                .where(and(eq(foundryReleaseRequests.orgId, orgId), eq(foundryReleaseRequests.entryKey, entryKey), isNull(foundryReleaseRequests.consumedAt)))
+                .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 }] : [];
+            });
+        },
+        async consumeRequests(ids) {
+            if (ids.length === 0)
+                return;
+            await db
+                .update(foundryReleaseRequests)
+                .set({ consumedAt: sql `now()` })
+                .where(and(inArray(foundryReleaseRequests.id, [...ids]), isNull(foundryReleaseRequests.consumedAt)));
+        },
+    };
+}

package/dist/store/schema.d.ts

@@ -2002,6 +2002,31 @@ export declare const foundryDeclaredPlatform: import("drizzle-orm/pg-core").PgTa
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
+        archonBlueGreen: import("drizzle-orm/pg-core").PgColumn<{
+            name: "archon_blue_green";
+            tableName: "foundry_declared_platform";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: {
+                steps?: number[];
+                stepHoldMinutes?: number;
+            } | null;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: {
+                steps?: number[];
+                stepHoldMinutes?: number;
+            } | null;
+        }>;
         edgeEnabled: import("drizzle-orm/pg-core").PgColumn<{
             name: "edge_enabled";
             tableName: "foundry_declared_platform";
@@ -2414,6 +2439,135 @@ export declare const foundryRequestedChanges: import("drizzle-orm/pg-core").PgTa
     };
     dialect: "pg";
 }>;
+/** Mirrors `migrations/0055_release_requests.sql`: an operator's release action, consumed once by the runner. */
+export declare const foundryReleaseRequests: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "foundry_release_requests";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "foundry_release_requests";
+            dataType: "number";
+            columnType: "PgBigSerial53";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        orgId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "org_id";
+            tableName: "foundry_release_requests";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        entryKey: import("drizzle-orm/pg-core").PgColumn<{
+            name: "entry_key";
+            tableName: "foundry_release_requests";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        action: import("drizzle-orm/pg-core").PgColumn<{
+            name: "action";
+            tableName: "foundry_release_requests";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: Record<string, unknown>;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: Record<string, unknown>;
+        }>;
+        actor: import("drizzle-orm/pg-core").PgColumn<{
+            name: "actor";
+            tableName: "foundry_release_requests";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "foundry_release_requests";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        consumedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "consumed_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";
+}>;
 export type DeclaredOrgRow = typeof declaredOrgs.$inferSelect;
 export type NewDeclaredOrgRow = typeof declaredOrgs.$inferInsert;
 export type AppliedStateRow = typeof foundryAppliedState.$inferSelect;

package/dist/store/schema.js

@@ -191,6 +191,8 @@ export const foundryDeclaredPlatform = pgTable('foundry_declared_platform', {
     archonEnabled: boolean('archon_enabled').notNull().default(false),
     archonHostname: text('archon_hostname').notNull(),
     archonGitRef: text('archon_git_ref').notNull().default(''),
+    /** `migrations/0056_platform_archon_blue_green.sql`: `platform.archon.blueGreen`; null keeps one app. */
+    archonBlueGreen: jsonb('archon_blue_green').$type(),
     /** #317 (F7), `migrations/0043_platform_names.sql`, renamed from `names_*` by `0045_names_to_edge.sql`. */
     edgeEnabled: boolean('edge_enabled').notNull().default(false),
     edgeHostname: text('edge_hostname').notNull(),
@@ -230,3 +232,13 @@ export const foundryRequestedChanges = pgTable('foundry_requested_changes', {
     createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
     state: text('state').notNull().default('needs_approval'),
 });
+/** Mirrors `migrations/0055_release_requests.sql`: an operator's release action, consumed once by the runner. */
+export const foundryReleaseRequests = pgTable('foundry_release_requests', {
+    id: bigserial('id', { mode: 'number' }).primaryKey(),
+    orgId: text('org_id').notNull(),
+    entryKey: text('entry_key').notNull(),
+    action: jsonb('action').notNull().$type(),
+    actor: text('actor').notNull(),
+    createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+    consumedAt: timestamp('consumed_at', { withTimezone: true }),
+});

package/package.json

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

package/versions.digests.json

@@ -8,5 +8,6 @@
   "hc": "sha256:aa08a61b0dcfd83f1332eab195d5cec1b595ae076eb8388cadf8a3d597114f9b",
   "alpine": "sha256:4bcff63911fcb4448bd4fdacec207030997caf25e9bea4045fa6c8c44de311d1",
   "busybox": "sha256:5cec3fc171c87218698e85a52af7087de727372aae264a787b8112901a5b0092",
-  "postgres": "sha256:786dab398303b8ce7cb76b407bb21ef2e4dfbbbd4c6abcf3d29b3130467ffdbc"
+  "postgres": "sha256:786dab398303b8ce7cb76b407bb21ef2e4dfbbbd4c6abcf3d29b3130467ffdbc",
+  "traefik": "sha256:575fa15b135078fe5e50aa847987d96dbddd7b093c172429618404df73f3fa7c"
 }

package/versions.json

@@ -8,5 +8,6 @@
   "hc": "v4.4",
   "alpine": "3.22.1",
   "busybox": "1.37.0-musl",
-  "postgres": "16.14-alpine3.22"
+  "postgres": "16.14-alpine3.22",
+  "traefik": "v3.7.14"
 }