@wtfalch/foundry 0.42.1 → 0.44.0

package/dist/store/schema.d.ts

@@ -372,6 +372,40 @@ export declare const declaredOrgs: import("drizzle-orm/pg-core").PgTableWithColu
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
+        customersEnabled: import("drizzle-orm/pg-core").PgColumn<{
+            name: "customers_enabled";
+            tableName: "foundry_declared_orgs";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        customersSignUp: import("drizzle-orm/pg-core").PgColumn<{
+            name: "customers_sign_up";
+            tableName: "foundry_declared_orgs";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
         versionPin: import("drizzle-orm/pg-core").PgColumn<{
             name: "version_pin";
             tableName: "foundry_declared_orgs";
@@ -2002,6 +2036,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 +2473,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

@@ -40,6 +40,9 @@ export const declaredOrgs = pgTable('foundry_declared_orgs', {
     servicesSfuSlot: integer('services_sfu_slot'),
     // SignInConfig.inApp (org.ts); migrations/0054.
     signInInApp: boolean('signin_in_app').notNull().default(false),
+    // CustomersConfig (org.ts); migrations/0057.
+    customersEnabled: boolean('customers_enabled').notNull().default(false),
+    customersSignUp: boolean('customers_sign_up').notNull().default(false),
     // VersionPin (org.ts): null follows the platform. `migrations/0053_org_version_pin.sql`.
     versionPin: jsonb('version_pin').$type(),
     // SiteConfig (org.ts, T10). A brand new org has no cms site.
@@ -191,6 +194,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 +235,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/dist/worker-app-config.d.ts

@@ -0,0 +1,151 @@
+import type { HostingConfig, HostingEntry } from './org.js';
+/**
+ * A hosting entry that runs as a Cloudflare Worker with Durable Objects and,
+ * optionally, Containers (foundry ADR 0002, `docs/adr/0002-worker-app-hosting-option.md`).
+ * The entry has no Coolify app, no volumes and no gate. The org's repo CI builds
+ * the module and the image; foundry fetches the module, checks its sha256 and
+ * uploads it, and never builds or checks out source.
+ */
+export interface WorkerAppConfig {
+    /** Built module (https URL) and its sha256, as in `WorkerConfig`. */
+    artifactUrl: string;
+    artifactSha256: string;
+    /** Defaults to `WORKER_COMPATIBILITY_DATE`. Flags come from an allowlist in foundry. */
+    compatibilityDate?: string;
+    compatibilityFlags?: 'nodejs_compat'[];
+    durableObjects: {
+        /** Binding name -> exported class. */
+        classes: Record<string, string>;
+        /** Append-only. Foundry sends only tags not yet applied. */
+        migrations: {
+            tag: string;
+            newSqliteClasses?: string[];
+            deletedClasses?: string[];
+            renamedClasses?: {
+                from: string;
+                to: string;
+            }[];
+        }[];
+    };
+    containers?: {
+        /** Must be a durable object class above. */
+        className: string;
+        /** Image pushed by the app's CI to the platform registry, pinned by digest. */
+        image: {
+            repository: string;
+            digest: `sha256:${string}`;
+        };
+        instanceType: 'lite' | 'basic' | 'standard-1' | 'standard-2' | 'standard-3' | 'standard-4';
+        maxInstances: number;
+    }[];
+    /**
+     * Name -> source. Delivered as Worker secrets. `keysCustody` (named
+     * `KEYS_CREDENTIAL`, at most one) delivers a keys custody Worker credential
+     * for the app's own host id (`workerAppHostId`), with `KEYS_URL` as a var.
+     * `keys` (an issued API key) is refused: custody does not accept one.
+     */
+    secrets?: Record<string, {
+        from: 'generated';
+    } | {
+        from: 'keysCustody';
+    }>;
+    /** True delivers the entry's sign-in env as Worker vars. Needs `uses.auth`. */
+    authEnv?: boolean;
+    /**
+     * A Postgres database in the org's Coolify database, reached by the Worker
+     * through a Hyperdrive config bound as `HYPERDRIVE` (connect as `<db>_rt`).
+     * The release may carry `migrations.json` (`[{ id, sql }]`, ordered); foundry
+     * applies the unapplied ids before the Worker deploys. `appendOnly` names
+     * tables the runtime role may insert into and read but never update, delete
+     * or truncate. `migrationsSha256` (64 lowercase hex) pins the release's
+     * `migrations.json`: required when the release has one, and foundry refuses
+     * to parse bytes whose sha256 differs. Omit it only for a release with no
+     * `migrations.json`; one that has the file is then refused.
+     */
+    database?: {
+        appendOnly?: string[];
+        migrationsSha256?: string;
+    };
+    /** Plain vars. Never secrets. */
+    vars?: Record<string, string>;
+    /** Host label: '@' for the apex, else a label. Exact host, never a wildcard. */
+    host: string;
+}
+/** The compatibility flags a Worker app may ask for. */
+export declare const WORKER_APP_COMPATIBILITY_FLAGS: ReadonlySet<string>;
+export declare const WORKER_APP_INSTANCE_TYPES: ReadonlySet<string>;
+/** The most instances one container class may scale to. */
+export declare const WORKER_APP_MAX_INSTANCES = 100;
+/** The secret that carries a `keysCustody` source: the custody Worker credential. */
+export declare const WORKER_APP_KEYS_SECRET = "KEYS_CREDENTIAL";
+export declare const WORKER_APP_KEYS_URL_VAR = "KEYS_URL";
+/**
+ * Names foundry writes into a Worker app's environment itself, so a
+ * declaration may not use them as a binding, secret or var.
+ */
+export declare const WORKER_APP_RESERVED_NAMES: RegExp;
+/** True when the entry needs the org's Postgres database: a Coolify app with `database`, or a Worker app with `workerApp.database`. */
+export declare const entryHasDatabase: (entry: {
+    database: boolean;
+    workerApp?: {
+        database?: unknown;
+    } | undefined;
+}) => boolean;
+/** The Hyperdrive binding of a Worker app with `database`. */
+export declare const WORKER_APP_HYPERDRIVE_BINDING = "HYPERDRIVE";
+/** The most tables `database.appendOnly` may name, and the shape of one name (`table` or `schema.table`). */
+export declare const WORKER_APP_APPEND_ONLY_MAX = 100;
+/** Hex characters of the org id's sha256 in a host id. */
+export declare const WORKER_APP_HOST_ID_HASH_LENGTH = 12;
+/**
+ * The custody host id of a Worker app: `app-<12 hex of sha256(org id)>-<entry key>`.
+ * It derives from the org id, never the slug, so a slug rename keeps it, and
+ * two orgs cannot share one (their hashes differ). The entry key is unique
+ * within an org. Null when the result breaks the custody pattern
+ * `^app-[a-z0-9]+(-[a-z0-9]+)*$`, 64 characters, or ends in `-next`.
+ */
+export declare function workerAppHostId(orgId: string, entryKey: string): string | null;
+/** The script name ends in this; the entry key's budget against Cloudflare's 63 characters follows from it. */
+export declare const WORKER_APP_NAME_SUFFIX = "-app";
+/**
+ * Checks an artifact reference: an https URL with no userinfo, query or
+ * fragment (those end up verbatim in recorded scope ids) and a lowercase hex
+ * sha256. Shared by `worker` and `workerApp`.
+ */
+export declare function validateArtifact(at: string, artifactUrl: string, sha256: string, repo?: string | null): string | null;
+/**
+ * The one exact name a Worker app is served at: `<host>.<domain>` or the apex
+ * on the org's own domain, else `<slug>-<key>.oikos.host` (one label under
+ * `oikos.host`, so the free Universal certificate covers it), and
+ * `<slug>.oikos.host` for the entry keyed `app`.
+ */
+export declare function workerAppHostnameOf(org: {
+    slug: string;
+    domain: string | null;
+    usesDomain: boolean;
+}, key: string, host: string): string;
+/**
+ * The Durable Object classes the migrations leave behind, folded in order:
+ * created, then removed, then renamed. A rename of a class that does not exist
+ * at that point is an error.
+ */
+export declare function foldMigrationClasses(migrations: WorkerAppConfig['durableObjects']['migrations']): {
+    classes: Set<string>;
+} | {
+    error: string;
+};
+/**
+ * `workerApp`: exclusive with `worker` and a Coolify repo, no Coolify-only
+ * setting, a Durable Object and container declaration Cloudflare will accept,
+ * names that cannot clash with what foundry delivers, and one exact host.
+ * `null` when valid. Whether a migration was already applied is a fact of the
+ * live system; the planner checks that (`plan/worker-app.ts`).
+ */
+export declare function validateEntryWorkerApp(entry: HostingEntry, hosting: HostingConfig, names?: {
+    domain: string | null;
+    locked: ReadonlySet<string>;
+    /** Without it the domain-less host `<slug>-<key>.oikos.host` cannot be checked. */
+    slug?: string;
+    /** True when the site is served at the apex of the org's domain. */
+    siteOwnsApex?: boolean;
+}): string | null;