@wtfalch/foundry 0.16.7 → 0.16.8

package/dist/platform.js

@@ -1,3 +1,4 @@
+import { isIPv4 } from 'node:net';
 import { validateDomain } from './org.js';
 export const PLATFORM_SERVICE_KEYS = [
     'auth',
@@ -21,6 +22,7 @@ function serviceOf(platform, key) {
  * shape as `org.ts`'s `validateBuyerIdentity`.
  *
  * - `apex` is a valid domain (`org.ts`'s `validateDomain`).
+ * - `serverIpv4`, when declared, is a dotted-quad IPv4 address.
  * - Every service's `hostname` is the apex itself or a subdomain of it -- a
  *   platform service does not live outside the platform's own apex.
  * - Every service's `gitRef` is non-empty once that service is `enabled` --
@@ -30,6 +32,9 @@ export function validatePlatform(platform) {
     const apexReason = validateDomain(platform.apex);
     if (apexReason)
         return `apex invalid: ${apexReason}`;
+    if (platform.serverIpv4 != null && !isIPv4(platform.serverIpv4)) {
+        return `serverIpv4 '${platform.serverIpv4}' must be a dotted-quad IPv4 address`;
+    }
     for (const key of PLATFORM_SERVICE_KEYS) {
         const service = serviceOf(platform, key);
         if (!service.hostname.trim()) {

package/dist/store/postgres.d.ts

@@ -1,5 +1,5 @@
 import type { PgDatabase, PgQueryResultHKT } from 'drizzle-orm/pg-core';
-import type { DeclaredOrgStore, PlatformStore, RequestedChangeStore } from '../store.js';
+import type { AppliedVersionsStore, DeclaredOrgStore, PlatformStore, RequestedChangeStore } from '../store.js';
 /**
  * The host's own drizzle handle or a transaction open on it, same shape
  * `@wtfalch/keys`'s `HeldKeysDb` uses: postgres-js in a real host, PGlite in
@@ -90,3 +90,11 @@ export declare function createPostgresPlatformStore(db: FoundryStoreDb): Platfor
  * argument makes -- and stores the result as the request's initial `state`.
  */
 export declare function createPostgresRequestedChangeStore(db: FoundryStoreDb): RequestedChangeStore;
+/**
+ * `AppliedVersionsStore` (`../store.ts`) on Postgres, for #253: an appended
+ * history of recorded applies, beside `createPostgresDeclaredOrgStore`'s own
+ * single-snapshot `putAppliedState` above. `record` always inserts a new
+ * row -- never an upsert -- so the row it replaces by being newer is never
+ * lost the way `foundry_applied_state`'s one row per service would lose it.
+ */
+export declare function createPostgresAppliedVersionsStore(db: FoundryStoreDb): AppliedVersionsStore;

package/dist/store/postgres.js

@@ -1,10 +1,10 @@
-import { and, asc, eq, sql } from 'drizzle-orm';
+import { and, asc, desc, eq, sql } from 'drizzle-orm';
 import { APP_ENTRY_KEY, DEFAULT_MAIL_APPS, DEFAULT_NO_REPLY_LOCAL_PART, validateBuyerIdentity, validateDomain, validateHosting, validateMail, validateOwners, validateSite, } from '../org.js';
 import { lockedHostnames } from '../plan/locked-hostnames.js';
 import { validatePlatform } from '../platform.js';
 import { RequestedChangeError, classifyChange } from '../requested-changes.js';
 import { validateSlug } from '../slug.js';
-import { declaredOrgs, foundryAppliedState, foundryDeclaredPlatform, foundryRequestedChanges, } from './schema.js';
+import { declaredOrgs, foundryAppliedState, foundryAppliedVersions, foundryDeclaredPlatform, foundryRequestedChanges, } from './schema.js';
 const UNIQUE_VIOLATION = '23505';
 /** `migrations/0004_slug_unique.sql` / `migrations/0015_domain_unique.sql`'s index names, read back off a caught unique-violation to tell which one fired. */
 const SLUG_UNIQUE_INDEX = 'foundry_declared_orgs_slug_idx';
@@ -466,6 +466,7 @@ function rowToPlatform(row) {
     return {
         ownerOrgId: row.ownerOrgId,
         apex: row.apex,
+        ...(row.serverIpv4 ? { serverIpv4: row.serverIpv4 } : {}),
         auth: { enabled: row.authEnabled, hostname: row.authHostname, gitRef: row.authGitRef },
         mail: { enabled: row.mailEnabled, hostname: row.mailHostname, gitRef: row.mailGitRef },
         sfu: { enabled: row.sfuEnabled, hostname: row.sfuHostname, gitRef: row.sfuGitRef },
@@ -489,6 +490,7 @@ function platformToRow(platform) {
         id: PLATFORM_ROW_ID,
         ownerOrgId: platform.ownerOrgId,
         apex: platform.apex,
+        serverIpv4: platform.serverIpv4 ?? null,
         authEnabled: platform.auth.enabled,
         authHostname: platform.auth.hostname,
         authGitRef: platform.auth.gitRef,
@@ -617,3 +619,35 @@ export function createPostgresRequestedChangeStore(db) {
         },
     };
 }
+/**
+ * `AppliedVersionsStore` (`../store.ts`) on Postgres, for #253: an appended
+ * history of recorded applies, beside `createPostgresDeclaredOrgStore`'s own
+ * single-snapshot `putAppliedState` above. `record` always inserts a new
+ * row -- never an upsert -- so the row it replaces by being newer is never
+ * lost the way `foundry_applied_state`'s one row per service would lose it.
+ */
+export function createPostgresAppliedVersionsStore(db) {
+    return {
+        async record({ service, ref, appliedAt, runId, backupId }) {
+            await db.insert(foundryAppliedVersions).values({
+                service,
+                ref,
+                appliedAt: new Date(appliedAt),
+                runId: runId ?? null,
+                backupId: backupId ?? null,
+            });
+        },
+        async previousAppliedRef(service) {
+            // The two most recent rows for this service, newest first: index 0 is
+            // the current one, index 1 -- if it exists -- is what a rollback would
+            // go back to.
+            const rows = await db
+                .select({ ref: foundryAppliedVersions.ref })
+                .from(foundryAppliedVersions)
+                .where(eq(foundryAppliedVersions.service, service))
+                .orderBy(desc(foundryAppliedVersions.appliedAt), desc(foundryAppliedVersions.id))
+                .limit(2);
+            return rows[1]?.ref ?? null;
+        },
+    };
+}

package/dist/store/schema.d.ts

@@ -948,6 +948,121 @@ export declare const foundryAppliedState: import("drizzle-orm/pg-core").PgTableW
     };
     dialect: "pg";
 }>;
+/**
+ * Mirrors `migrations/0036_applied_versions.sql`, the source of truth: an
+ * appended history row beside `foundryAppliedState`'s single current
+ * snapshot (#253). See that migration for what `service`, `ref`, `runId`
+ * and `backupId` mean and why the last two are nullable.
+ */
+export declare const foundryAppliedVersions: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "foundry_applied_versions";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "foundry_applied_versions";
+            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;
+        }, {}, {}>;
+        service: import("drizzle-orm/pg-core").PgColumn<{
+            name: "service";
+            tableName: "foundry_applied_versions";
+            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;
+        }, {}, {}>;
+        ref: import("drizzle-orm/pg-core").PgColumn<{
+            name: "ref";
+            tableName: "foundry_applied_versions";
+            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;
+        }, {}, {}>;
+        appliedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "applied_at";
+            tableName: "foundry_applied_versions";
+            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;
+        }, {}, {}>;
+        runId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "run_id";
+            tableName: "foundry_applied_versions";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        backupId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "backup_id";
+            tableName: "foundry_applied_versions";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
 /** Mirrors `migrations/0012_audit.sql`, the source of truth (#85). */
 export declare const foundryAuditEvents: import("drizzle-orm/pg-core").PgTableWithColumns<{
     name: "foundry_audit_events";
@@ -1195,6 +1310,23 @@ export declare const foundryDeclaredPlatform: import("drizzle-orm/pg-core").PgTa
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
+        serverIpv4: import("drizzle-orm/pg-core").PgColumn<{
+            name: "server_ipv4";
+            tableName: "foundry_declared_platform";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
         authEnabled: import("drizzle-orm/pg-core").PgColumn<{
             name: "auth_enabled";
             tableName: "foundry_declared_platform";
@@ -1803,3 +1935,5 @@ export type DeclaredPlatformRow = typeof foundryDeclaredPlatform.$inferSelect;
 export type NewDeclaredPlatformRow = typeof foundryDeclaredPlatform.$inferInsert;
 export type RequestedChangeRow = typeof foundryRequestedChanges.$inferSelect;
 export type NewRequestedChangeRow = typeof foundryRequestedChanges.$inferInsert;
+export type AppliedVersionRow = typeof foundryAppliedVersions.$inferSelect;
+export type NewAppliedVersionRow = typeof foundryAppliedVersions.$inferInsert;

package/dist/store/schema.js

@@ -102,6 +102,20 @@ export const foundryAppliedState = pgTable('foundry_applied_state', {
     lastAppliedAt: timestamp('last_applied_at', { withTimezone: true }),
     lastAppliedDeclaredOrgVersion: text('last_applied_declared_org_version'),
 });
+/**
+ * Mirrors `migrations/0036_applied_versions.sql`, the source of truth: an
+ * appended history row beside `foundryAppliedState`'s single current
+ * snapshot (#253). See that migration for what `service`, `ref`, `runId`
+ * and `backupId` mean and why the last two are nullable.
+ */
+export const foundryAppliedVersions = pgTable('foundry_applied_versions', {
+    id: bigserial('id', { mode: 'number' }).primaryKey(),
+    service: text('service').notNull(),
+    ref: text('ref').notNull(),
+    appliedAt: timestamp('applied_at', { withTimezone: true }).notNull().defaultNow(),
+    runId: text('run_id'),
+    backupId: text('backup_id'),
+});
 /** Mirrors `migrations/0012_audit.sql`, the source of truth (#85). */
 export const foundryAuditEvents = pgTable('foundry_audit_events', {
     id: bigserial('id', { mode: 'number' }).primaryKey(),
@@ -126,6 +140,7 @@ export const foundryDeclaredPlatform = pgTable('foundry_declared_platform', {
     id: boolean('id').primaryKey().default(true),
     ownerOrgId: text('owner_org_id').notNull(),
     apex: text('apex').notNull(),
+    serverIpv4: text('server_ipv4'),
     authEnabled: boolean('auth_enabled').notNull().default(false),
     authHostname: text('auth_hostname').notNull(),
     authGitRef: text('auth_git_ref').notNull().default(''),

package/dist/store.d.ts

@@ -90,6 +90,43 @@ export interface PlatformStore {
     /** Replaces the recorded ids. A no-op until the platform is declared. */
     putServiceIds(serviceIds: Record<string, string>): Promise<void>;
 }
+/**
+ * One recorded apply, appended to the history #253 keeps beside
+ * {@link AppliedState}'s single current snapshot. See
+ * `migrations/0036_applied_versions.sql` for what each field means and why
+ * `runId`/`backupId` are nullable.
+ */
+export interface AppliedVersion {
+    service: string;
+    ref: string;
+    appliedAt: string;
+    runId: string | null;
+    backupId: string | null;
+}
+/**
+ * The persistence seam for #253's history of recorded applies: a row
+ * appended every time a version is recorded as applied, never replaced in
+ * place the way {@link DeclaredOrgStore.putAppliedState} and
+ * {@link PlatformStore.putServiceIds} replace their own single snapshot.
+ * `service` is whatever was just recorded -- today, an org's id -- and
+ * `previousAppliedRef` is what a rollback reads to find what to roll back
+ * to.
+ */
+export interface AppliedVersionsStore {
+    /** Appends a row. Never replaces or deduplicates an existing one. */
+    record(entry: {
+        service: string;
+        ref: string;
+        appliedAt: string;
+        runId?: string | null;
+        backupId?: string | null;
+    }): Promise<void>;
+    /**
+     * The `ref` of the second-most-recent row recorded for `service` -- the
+     * one before whatever is current -- or `null` with fewer than two rows.
+     */
+    previousAppliedRef(service: string): Promise<string | null>;
+}
 /**
  * The persistence seam for #178's {@link RequestedChange}: a company's own
  * Boule requests a setting change on its declared org, foundry classifies

package/package.json

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