@wtfalch/foundry 0.4.0 → 0.6.0

package/dist/store/postgres.js

@@ -1,7 +1,9 @@
-import { eq, sql } from 'drizzle-orm';
-import { validateBuyerIdentity, validateDomain, validateHosting, validateOwner, validateSite, } from '../org.js';
+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 { validatePlatform } from '../platform.js';
+import { RequestedChangeError, classifyChange } from '../requested-changes.js';
 import { validateSlug } from '../slug.js';
-import { declaredOrgs, foundryAppliedState, } from './schema.js';
+import { declaredOrgs, 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';
@@ -57,7 +59,14 @@ function rowToOrg(row) {
         slug: row.slug,
         displayName: row.displayName,
         domain: row.domain,
-        mail: { mode: row.mailMode, usesDomain: row.mailUsesDomain },
+        mail: {
+            mode: row.mailMode,
+            usesDomain: row.mailUsesDomain,
+            ownerMailboxAddress: row.ownerMailboxAddress,
+            noReplyLocalPart: row.noReplyLocalPart,
+            mailApps: row.mailApps,
+            roleMailboxes: row.roleMailboxes,
+        },
         chat: { usesDomain: row.chatUsesDomain },
         calls: { enabled: row.callsEnabled, usesDomain: row.callsUsesDomain },
         issuer: { usesDomain: row.issuerUsesDomain },
@@ -94,6 +103,10 @@ function orgToRow(org) {
         domain: org.domain,
         mailMode: org.mail.mode,
         mailUsesDomain: org.mail.usesDomain,
+        ownerMailboxAddress: org.mail.ownerMailboxAddress ?? null,
+        noReplyLocalPart: org.mail.noReplyLocalPart ?? DEFAULT_NO_REPLY_LOCAL_PART,
+        mailApps: org.mail.mailApps ?? [...DEFAULT_MAIL_APPS],
+        roleMailboxes: org.mail.roleMailboxes ?? [],
         chatUsesDomain: org.chat.usesDomain,
         callsEnabled: org.calls.enabled,
         callsUsesDomain: org.calls.usesDomain,
@@ -254,6 +267,16 @@ export function createPostgresDeclaredOrgStore(db) {
         if (reason)
             throw new DeclaredOrgError(`owner invalid: ${reason}`);
     }
+    // #162: same place `requireValidOwner` checks the owner, on both `create`
+    // and the merged result of `update`. Deliberately does not require
+    // `mail.ownerMailboxAddress` just because mail is on -- `validateMail`'s
+    // own doc comment says why. Also covers #34's `mailApps` check, folded
+    // into the same `validateMail`.
+    function requireValidMail(org) {
+        const reason = validateMail(org);
+        if (reason)
+            throw new DeclaredOrgError(`mail invalid: ${reason} (#162)`);
+    }
     return {
         async create(org) {
             requireValidSlug(org.slug);
@@ -263,6 +286,7 @@ export function createPostgresDeclaredOrgStore(db) {
             requireValidHosting(org);
             requireValidSite(org);
             requireValidOwner(org);
+            requireValidMail(org);
             try {
                 await db.insert(declaredOrgs).values(orgToRow(org));
             }
@@ -287,6 +311,12 @@ export function createPostgresDeclaredOrgStore(db) {
             const [row] = await db.select().from(declaredOrgs).where(eq(declaredOrgs.id, id)).limit(1);
             return row ? rowToOrg(row) : null;
         },
+        // #133: ordered by display name, the same `asc(...)` shape
+        // `createPostgresRequestedChangeStore.listForOrg` already uses below.
+        async list() {
+            const rows = await db.select().from(declaredOrgs).orderBy(asc(declaredOrgs.displayName));
+            return rows.map(rowToOrg);
+        },
         async slugTaken(slug) {
             const [row] = await db
                 .select({ id: declaredOrgs.id })
@@ -336,6 +366,7 @@ export function createPostgresDeclaredOrgStore(db) {
             requireValidHosting(next);
             requireValidSite(next);
             requireValidOwner(next);
+            requireValidMail(next);
             try {
                 await db
                     .update(declaredOrgs)
@@ -405,3 +436,171 @@ export function createPostgresDeclaredOrgStore(db) {
         },
     };
 }
+/**
+ * Thrown by `put` when `validatePlatform` (`../platform.js`) refuses the
+ * platform given to it -- same "throw with a reason" shape
+ * {@link DeclaredOrgError} gives `create`/`update`.
+ */
+export class PlatformError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'PlatformError';
+    }
+}
+/** `migrations/0016_platform.sql`'s singleton row -- `id` is always `true`, the only value its `check (id)` constraint allows. */
+const PLATFORM_ROW_ID = true;
+function rowToPlatform(row) {
+    return {
+        ownerOrgId: row.ownerOrgId,
+        apex: row.apex,
+        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 },
+        files: { enabled: row.filesEnabled, hostname: row.filesHostname, gitRef: row.filesGitRef },
+        ai: { enabled: row.aiEnabled, hostname: row.aiHostname, gitRef: row.aiGitRef },
+        jobs: { enabled: row.jobsEnabled, hostname: row.jobsHostname, gitRef: row.jobsGitRef },
+        integrations: {
+            enabled: row.integrationsEnabled,
+            hostname: row.integrationsHostname,
+            gitRef: row.integrationsGitRef,
+        },
+        archon: {
+            enabled: row.archonEnabled,
+            hostname: row.archonHostname,
+            gitRef: row.archonGitRef,
+        },
+    };
+}
+function platformToRow(platform) {
+    return {
+        id: PLATFORM_ROW_ID,
+        ownerOrgId: platform.ownerOrgId,
+        apex: platform.apex,
+        authEnabled: platform.auth.enabled,
+        authHostname: platform.auth.hostname,
+        authGitRef: platform.auth.gitRef,
+        mailEnabled: platform.mail.enabled,
+        mailHostname: platform.mail.hostname,
+        mailGitRef: platform.mail.gitRef,
+        sfuEnabled: platform.sfu.enabled,
+        sfuHostname: platform.sfu.hostname,
+        sfuGitRef: platform.sfu.gitRef,
+        filesEnabled: platform.files.enabled,
+        filesHostname: platform.files.hostname,
+        filesGitRef: platform.files.gitRef,
+        aiEnabled: platform.ai.enabled,
+        aiHostname: platform.ai.hostname,
+        aiGitRef: platform.ai.gitRef,
+        jobsEnabled: platform.jobs.enabled,
+        jobsHostname: platform.jobs.hostname,
+        jobsGitRef: platform.jobs.gitRef,
+        integrationsEnabled: platform.integrations.enabled,
+        integrationsHostname: platform.integrations.hostname,
+        integrationsGitRef: platform.integrations.gitRef,
+        archonEnabled: platform.archon.enabled,
+        archonHostname: platform.archon.hostname,
+        archonGitRef: platform.archon.gitRef,
+    };
+}
+/**
+ * `PlatformStore` (`../store.ts`) on Postgres, for #166: get and put the one
+ * {@link DeclaredPlatform}, beside `createPostgresDeclaredOrgStore` above.
+ * `put` validates with `../platform.js`'s `validatePlatform` and then
+ * upserts onto the fixed singleton row `migrations/0016_platform.sql`
+ * declares -- the first call creates it, every later call replaces it, and
+ * the table's own `check (id)` constraint is what actually refuses a second
+ * row, not this function.
+ */
+export function createPostgresPlatformStore(db) {
+    return {
+        async get() {
+            const [row] = await db.select().from(foundryDeclaredPlatform).limit(1);
+            return row ? rowToPlatform(row) : null;
+        },
+        async put(platform) {
+            const reason = validatePlatform(platform);
+            if (reason)
+                throw new PlatformError(reason);
+            const row = platformToRow(platform);
+            await db
+                .insert(foundryDeclaredPlatform)
+                .values(row)
+                .onConflictDoUpdate({ target: foundryDeclaredPlatform.id, set: row });
+        },
+        async getServiceIds() {
+            const [row] = await db
+                .select({ serviceIds: foundryDeclaredPlatform.serviceIds })
+                .from(foundryDeclaredPlatform)
+                .limit(1);
+            return row?.serviceIds ?? {};
+        },
+        async putServiceIds(serviceIds) {
+            await db.update(foundryDeclaredPlatform).set({ serviceIds });
+        },
+    };
+}
+/**
+ * `value`'s own field-specific payload, stripped of its `field` -- that is
+ * a column of its own (`foundryRequestedChanges.field`), not repeated
+ * inside the jsonb.
+ */
+function requestedChangePayload(value) {
+    const { field, ...payload } = value;
+    return payload;
+}
+function rowToRequestedChange(row) {
+    return {
+        id: row.id,
+        orgId: row.orgId,
+        value: { field: row.field, ...row.value },
+        requestedBy: row.requestedBy,
+        createdAt: row.createdAt.toISOString(),
+        state: row.state,
+    };
+}
+/**
+ * `RequestedChangeStore` (`../store.ts`) on Postgres, for #178: classify and
+ * store a company's own requested setting change on its declared org, beside
+ * `createPostgresDeclaredOrgStore` and `createPostgresPlatformStore` above.
+ * `create` classifies with `../requested-changes.js`'s `classifyChange`
+ * against the `org` given to it -- this store never loads the org itself,
+ * the same "caller already has it" choice `PlatformStore.put`'s `platform`
+ * argument makes -- and stores the result as the request's initial `state`.
+ */
+export function createPostgresRequestedChangeStore(db) {
+    return {
+        async create({ orgId, org, value, requestedBy }) {
+            const classification = classifyChange(org, value);
+            const state = classification === 'auto' ? 'auto' : 'needs_approval';
+            const [row] = await db
+                .insert(foundryRequestedChanges)
+                .values({
+                orgId,
+                field: value.field,
+                value: requestedChangePayload(value),
+                requestedBy,
+                state,
+            })
+                .returning();
+            if (!row)
+                throw new RequestedChangeError('insert returned no row');
+            return rowToRequestedChange(row);
+        },
+        async get(id) {
+            const [row] = await db
+                .select()
+                .from(foundryRequestedChanges)
+                .where(eq(foundryRequestedChanges.id, id))
+                .limit(1);
+            return row ? rowToRequestedChange(row) : null;
+        },
+        async listForOrg(orgId) {
+            const rows = await db
+                .select()
+                .from(foundryRequestedChanges)
+                .where(eq(foundryRequestedChanges.orgId, orgId))
+                .orderBy(asc(foundryRequestedChanges.createdAt));
+            return rows.map(rowToRequestedChange);
+        },
+    };
+}