@wtfalch/foundry 0.9.0 → 0.11.0

package/dist/store/postgres.js

@@ -1,9 +1,10 @@
-import { asc, eq, sql } from 'drizzle-orm';
-import { DEFAULT_MAIL_APPS, DEFAULT_NO_REPLY_LOCAL_PART, validateBuyerIdentity, validateDomain, validateHosting, validateMail, validateOwner, validateSite, } from '../org.js';
+import { and, asc, eq, sql } from 'drizzle-orm';
+import { APP_ENTRY_KEY, DEFAULT_MAIL_APPS, DEFAULT_NO_REPLY_LOCAL_PART, validateBuyerIdentity, validateDomain, validateHosting, validateMail, validateOwner, 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, foundryAdoptions, foundryAppliedState, 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';
@@ -81,7 +82,12 @@ function rowToOrg(row) {
             usesDomain: row.hostingUsesDomain,
             tunnel: row.hostingTunnel,
             issuerApps: row.hostingIssuerApps,
-            entries: row.hostingEntries,
+            ...(row.hostingAdopt ? { adopt: row.hostingAdopt } : {}),
+            // Migration 0030's default for an entry stored before `hostnames`.
+            entries: row.hostingEntries.map((entry) => ({
+                ...entry,
+                hostnames: entry.hostnames ?? (entry.key === APP_ENTRY_KEY && row.hostingUsesDomain ? ['@'] : []),
+            })),
         },
         sso: { enabled: row.ssoEnabled },
         guests: { enabled: row.guestsEnabled },
@@ -121,6 +127,7 @@ function orgToRow(org) {
         hostingTunnel: org.hosting.tunnel,
         hostingIssuerApps: org.hosting.issuerApps,
         hostingEntries: org.hosting.entries,
+        hostingAdopt: org.hosting.adopt ?? null,
         ssoEnabled: org.sso.enabled,
         guestsEnabled: org.guests.enabled,
         soloEnabled: org.solo.enabled,
@@ -249,7 +256,10 @@ export function createPostgresDeclaredOrgStore(db) {
     // #71: same place `requireValidBuyer` checks the buyer identity (#67), on
     // both `create` and the merged result of `update`.
     function requireValidHosting(org) {
-        const reason = validateHosting(org.hosting);
+        const reason = validateHosting(org.hosting, {
+            domain: org.domain,
+            locked: lockedHostnames(org, []),
+        });
         if (reason)
             throw new DeclaredOrgError(`hosting invalid: ${reason} (#71)`);
     }
@@ -604,3 +614,68 @@ export function createPostgresRequestedChangeStore(db) {
         },
     };
 }
+function rowToAdoption(row) {
+    return {
+        orgId: row.orgId,
+        resourceKey: row.resourceKey,
+        kind: row.kind,
+        takenAt: row.takenAt.toISOString(),
+        settings: row.settings,
+        vaultRef: row.vaultRef,
+        state: row.state,
+    };
+}
+/**
+ * `AdoptionStore` (`../store.ts`) on Postgres, for #311: the snapshot row of
+ * each live resource foundry takes over, beside the stores above.
+ */
+export function createPostgresAdoptionStore(db) {
+    return {
+        async put(adoption) {
+            const values = {
+                orgId: adoption.orgId,
+                resourceKey: adoption.resourceKey,
+                kind: adoption.kind,
+                takenAt: new Date(adoption.takenAt),
+                settings: adoption.settings,
+                vaultRef: adoption.vaultRef,
+                state: 'adopted',
+            };
+            await db
+                .insert(foundryAdoptions)
+                .values(values)
+                .onConflictDoUpdate({
+                target: [foundryAdoptions.orgId, foundryAdoptions.resourceKey],
+                set: values,
+            });
+        },
+        async get(orgId, resourceKey) {
+            const [row] = await db
+                .select()
+                .from(foundryAdoptions)
+                .where(and(eq(foundryAdoptions.orgId, orgId), eq(foundryAdoptions.resourceKey, resourceKey)))
+                .limit(1);
+            return row ? rowToAdoption(row) : null;
+        },
+        async list(orgId) {
+            const rows = await db
+                .select()
+                .from(foundryAdoptions)
+                .where(eq(foundryAdoptions.orgId, orgId))
+                .orderBy(asc(foundryAdoptions.resourceKey));
+            return rows.map(rowToAdoption);
+        },
+        async setState(orgId, resourceKey, state) {
+            await db
+                .update(foundryAdoptions)
+                .set({ state })
+                .where(and(eq(foundryAdoptions.orgId, orgId), eq(foundryAdoptions.resourceKey, resourceKey)));
+        },
+        async setSettings(orgId, resourceKey, settings) {
+            await db
+                .update(foundryAdoptions)
+                .set({ settings })
+                .where(and(eq(foundryAdoptions.orgId, orgId), eq(foundryAdoptions.resourceKey, resourceKey)));
+        },
+    };
+}

package/dist/store/schema.d.ts

@@ -482,6 +482,33 @@ export declare const declaredOrgs: import("drizzle-orm/pg-core").PgTableWithColu
         }, {}, {
             $type: HostingEntry[];
         }>;
+        hostingAdopt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "hosting_adopt";
+            tableName: "foundry_declared_orgs";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: {
+                database?: string;
+                tunnel?: string;
+                connectorApp?: string;
+            };
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: {
+                database?: string;
+                tunnel?: string;
+                connectorApp?: string;
+            };
+        }>;
         ssoEnabled: import("drizzle-orm/pg-core").PgColumn<{
             name: "sso_enabled";
             tableName: "foundry_declared_orgs";
@@ -1809,6 +1836,140 @@ export declare const foundryRequestedChanges: import("drizzle-orm/pg-core").PgTa
     };
     dialect: "pg";
 }>;
+/**
+ * Mirrors `migrations/0031_adoptions.sql`, which is the source of truth (the
+ * CHECKs live there). One row per live resource foundry took over (#311).
+ * `settings` holds non-secret settings only; secrets go to the vault under
+ * `vaultRef`.
+ */
+export declare const foundryAdoptions: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "foundry_adoptions";
+    schema: undefined;
+    columns: {
+        orgId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "org_id";
+            tableName: "foundry_adoptions";
+            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;
+        }, {}, {}>;
+        resourceKey: import("drizzle-orm/pg-core").PgColumn<{
+            name: "resource_key";
+            tableName: "foundry_adoptions";
+            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;
+        }, {}, {}>;
+        kind: import("drizzle-orm/pg-core").PgColumn<{
+            name: "kind";
+            tableName: "foundry_adoptions";
+            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;
+        }, {}, {}>;
+        takenAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "taken_at";
+            tableName: "foundry_adoptions";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        settings: import("drizzle-orm/pg-core").PgColumn<{
+            name: "settings";
+            tableName: "foundry_adoptions";
+            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>;
+        }>;
+        vaultRef: import("drizzle-orm/pg-core").PgColumn<{
+            name: "vault_ref";
+            tableName: "foundry_adoptions";
+            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;
+        }, {}, {}>;
+        state: import("drizzle-orm/pg-core").PgColumn<{
+            name: "state";
+            tableName: "foundry_adoptions";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            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;
@@ -1818,3 +1979,4 @@ 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 AdoptionRow = typeof foundryAdoptions.$inferSelect;

package/dist/store/schema.js

@@ -1,4 +1,4 @@
-import { bigserial, boolean, jsonb, pgTable, text, timestamp } from 'drizzle-orm/pg-core';
+import { bigserial, boolean, jsonb, pgTable, primaryKey, 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
@@ -54,6 +54,9 @@ export const declaredOrgs = pgTable('foundry_declared_orgs', {
     // hosting_access_emails and hosting_app_env columns, which stay for an older
     // reader and are no longer written.
     hostingEntries: jsonb('hosting_entries').notNull().default([]).$type(),
+    // HostingConfig.adopt (org.ts): the live resources the org takes over by
+    // uuid. null when it adopts none. An entry's own `adopt` lives in `hostingEntries`.
+    hostingAdopt: jsonb('hosting_adopt').$type(),
     ssoEnabled: boolean('sso_enabled').notNull().default(false),
     guestsEnabled: boolean('guests_enabled').notNull().default(false),
     soloEnabled: boolean('solo_enabled').notNull().default(false),
@@ -172,3 +175,18 @@ export const foundryRequestedChanges = pgTable('foundry_requested_changes', {
     createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
     state: text('state').notNull().default('needs_approval'),
 });
+/**
+ * Mirrors `migrations/0031_adoptions.sql`, which is the source of truth (the
+ * CHECKs live there). One row per live resource foundry took over (#311).
+ * `settings` holds non-secret settings only; secrets go to the vault under
+ * `vaultRef`.
+ */
+export const foundryAdoptions = pgTable('foundry_adoptions', {
+    orgId: text('org_id').notNull(),
+    resourceKey: text('resource_key').notNull(),
+    kind: text('kind').notNull(),
+    takenAt: timestamp('taken_at', { withTimezone: true }).notNull(),
+    settings: jsonb('settings').notNull().$type(),
+    vaultRef: text('vault_ref'),
+    state: text('state').notNull().default('adopted'),
+}, (table) => [primaryKey({ columns: [table.orgId, table.resourceKey] })]);

package/dist/store.d.ts

@@ -96,3 +96,40 @@ export interface RequestedChangeStore {
     /** Every request an org has made, oldest first. */
     listForOrg(orgId: OrgId): Promise<RequestedChange[]>;
 }
+export type AdoptionKind = 'app' | 'database' | 'tunnel' | 'connector' | 'access';
+export type AdoptionState = 'adopted' | 'confirmed' | 'restored' | 'released';
+/**
+ * What foundry recorded before it first changed a live resource it took over
+ * (#311). `settings` holds non-secret settings only; secrets live in the
+ * `AdoptionVault` (`plan/adoption-vault.ts`) under `vaultRef`.
+ */
+export interface Adoption {
+    orgId: OrgId;
+    /** The scope key of the resource, for example `coolify:app:<orgId>:<entryKey>`. */
+    resourceKey: string;
+    kind: AdoptionKind;
+    /** ISO time the snapshot was taken. */
+    takenAt: string;
+    settings: Record<string, unknown>;
+    /** The vault ref of the secret part of the snapshot, or `null` when it has none. */
+    vaultRef: string | null;
+    state: AdoptionState;
+}
+/** The persistence seam for #311's {@link Adoption} rows, beside {@link DeclaredOrgStore}. */
+export interface AdoptionStore {
+    /**
+     * Inserts the row, or replaces it in any state; the row is stored as
+     * `adopted`. A new snapshot after a restore or a release replaces the old one.
+     */
+    put(adoption: Omit<Adoption, 'state'>): Promise<void>;
+    get(orgId: OrgId, resourceKey: string): Promise<Adoption | null>;
+    /** Every row of an org, ordered by resource key. */
+    list(orgId: OrgId): Promise<Adoption[]>;
+    /** Moves a row to `state`. A no-op for a row that does not exist. */
+    setState(orgId: OrgId, resourceKey: string, state: AdoptionState): Promise<void>;
+    /**
+     * Replaces a row's `settings` and nothing else: its state, `takenAt` and
+     * `vaultRef` stay (#312). A no-op for a row that does not exist.
+     */
+    setSettings(orgId: OrgId, resourceKey: string, settings: Record<string, unknown>): Promise<void>;
+}

package/package.json

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