@aglyn/plugins-ai 1.0.0-beta.143

package/src/lib/jobs/ai-job-drafts.js

@@ -0,0 +1,557 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ import { createResourceUid } from "@aglyn/aglyn/app-utils/create-resource-uid";
+import { uniqueDuplicateName } from "@aglyn/aglyn/app-utils/duplicate-resource";
+import { FORM_COMPONENT_ID, normalizeFormSlug } from "@aglyn/aglyn/app-utils/forms";
+import { nameSearchKey } from "@aglyn/aglyn/app-utils/name-search";
+import { checkDatasetQuota, checkEntitlement, checkQuota, resolveEffectivePlan, resolveOrgEntitlements } from "@aglyn/aglyn/app-utils/plan-entitlements";
+import { billableScreenIds, normalizeScreenSlug, reservedScreenRouteSegment, SCREEN_ROOT_PATH } from "@aglyn/aglyn/app-utils/screen-route";
+import { decodeStoredNodes, encodeStoredNodes } from "@aglyn/aglyn/app-utils/stored-nodes";
+import { resolveOrgIdForHost } from "@aglyn/tenant-data-admin/server/organizations";
+import { aiUnrestrictedPlanCapabilities } from "../model/ai-plan-capabilities.js";
+/** The console host resources route's allow-list for each kind. */ export const AI_DRAFT_FIELDS = {
+    layout: [
+        'displayName',
+        'description',
+        'versionId'
+    ],
+    template: [
+        'kind',
+        'displayName',
+        'description',
+        'placeholders',
+        'nodes',
+        'rootId',
+        'props',
+        'slug',
+        'seo'
+    ],
+    form: [
+        'displayName',
+        'slug',
+        'fields',
+        'consentFieldName',
+        'routing',
+        'legacyMatch',
+        'rootId',
+        'nodes'
+    ],
+    component: [
+        'displayName',
+        'description',
+        'rootId',
+        'nodes',
+        'props'
+    ],
+    // `kind` is on the route's list for the email composer; a page has none, and
+    // the writer never sends one.
+    screen: [
+        'displayName',
+        'description',
+        'slug',
+        'seo',
+        'kind',
+        'versionId'
+    ]
+};
+/** The keys a layout's first version is seeded with, all on the versions route's list. */ export const AI_DRAFT_VERSION_FIELDS = [
+    'layoutId',
+    'hostId',
+    'displayName',
+    'nodes'
+];
+/**
+ * The keys a screen's first version is seeded with, all on the versions
+ * route's list: the screen it belongs to, the site, the label, the tree, and
+ * the layout it renders inside when the plan names one the site has.
+ */ export const AI_DRAFT_SCREEN_VERSION_FIELDS = [
+    'screenId',
+    'hostId',
+    'displayName',
+    'nodes',
+    'layoutId'
+];
+/** The label on a generated draft's first version, as on one Use template makes. */ export const AI_DRAFT_VERSION_NAME = 'Initial version';
+/** The route's refusal when the site's plan does not include the kind at all. */ export const AI_DRAFT_ENTITLEMENT_REFUSAL = 'This feature is not included in your plan — see Billing';
+/** Each kind's collection, counter, feature and label, as the create route declares them. */ export const AI_DRAFT_BANDS = {
+    layout: {
+        collection: 'layouts',
+        quotaKey: 'sharedLayoutsPerHost',
+        label: 'shared layouts'
+    },
+    template: {
+        collection: 'templates',
+        quotaKey: 'templatesPerHost',
+        label: 'templates'
+    },
+    form: {
+        collection: 'forms',
+        quotaKey: 'formsPerHost',
+        entitlement: 'reusableComponents',
+        label: 'forms'
+    },
+    component: {
+        collection: 'components',
+        entitlement: 'reusableComponents',
+        label: 'reusable components'
+    },
+    screen: {
+        collection: 'screens',
+        quotaKey: 'screensPerHost',
+        label: 'screens'
+    }
+};
+function draftCollection(firestore, hostId, kind) {
+    return firestore.collection('hosts').doc(hostId).collection(AI_DRAFT_BANDS[kind].collection);
+}
+/** The fields the band, the name, the address and a deletion are read from. */ function siblingsOf(collection) {
+    return collection.select('displayName', 'slug', 'kind', 'source.type', 'deletedAt');
+}
+function siblingRows(snapshot) {
+    return snapshot.docs.map((doc)=>{
+        var _doc_get, _doc_get1;
+        return {
+            id: doc.id,
+            name: String((_doc_get = doc.get('displayName')) != null ? _doc_get : ''),
+            slug: String((_doc_get1 = doc.get('slug')) != null ? _doc_get1 : ''),
+            kind: doc.get('kind'),
+            sourceType: doc.get('source.type'),
+            deletedAt: doc.get('deletedAt'),
+            deleted: doc.get('deletedAt') != null
+        };
+    });
+}
+function subdomainOf(host) {
+    const subdomain = host.get('subdomain');
+    return typeof subdomain === 'string' && subdomain ? subdomain : null;
+}
+/**
+ * The route's refusal when the site's plan does not include the kind, or
+ * holds no more of it; `null` while it does. The feature is asked first, as
+ * the route asks it before it counts.
+ */ export function aiDraftBandRefusal(kind, rows, org, routingMap) {
+    const band = AI_DRAFT_BANDS[kind];
+    if (band.entitlement && !checkEntitlement(org, band.entitlement)) {
+        return AI_DRAFT_ENTITLEMENT_REFUSAL;
+    }
+    if (!band.quotaKey) return null;
+    const used = kind === 'template' ? rows.filter((row)=>row.sourceType !== undefined && row.sourceType !== 'starter').length : kind === 'screen' ? billableScreenIds(rows.map((row)=>({
+            id: row.id,
+            kind: row.kind,
+            deletedAt: row.deletedAt
+        })), routingMap != null ? routingMap : undefined).size : rows.length;
+    const quota = checkQuota(org, band.quotaKey, used);
+    return quota.allowed ? null : `Your plan includes ${quota.limit} ${band.label} — upgrade in Billing for more`;
+}
+/** The draft kinds a plan's creations land as, whose band a plan is told about (AGL-3030). */ const AI_PLAN_DRAFT_KINDS = [
+    'component',
+    'form',
+    'layout',
+    'template'
+];
+/** Every draft kind's plural label made singular, for a band of one. */ function bandLabel(label, count) {
+    return count === 1 ? label.replace(/s$/, '') : label;
+}
+/**
+ * Whether the site may take `used + 1` of a kind, in the create route's
+ * arithmetic: the feature first, then the allowance. `null` for a kind whose
+ * allowance is unlimited or counts nothing, which needs no rows read.
+ */ function planCreation(kind, org, rows) {
+    const band = AI_DRAFT_BANDS[kind];
+    if (band.entitlement && !checkEntitlement(org, band.entitlement)) {
+        return {
+            allowed: false,
+            left: 0,
+            reason: `this workspace's plan does not include ${kind === 'form' ? 'saved forms' : band.label}`
+        };
+    }
+    const limit = band.quotaKey ? resolveOrgEntitlements(org)[band.quotaKey] : Number.POSITIVE_INFINITY;
+    if (!rows || !Number.isFinite(limit)) return {
+        allowed: true,
+        left: null,
+        reason: null
+    };
+    // The route's own arithmetic decides; the count beside it is what is left.
+    const refusal = aiDraftBandRefusal(kind, rows, org);
+    const used = kind === 'template' ? rows.filter((row)=>row.sourceType !== undefined && row.sourceType !== 'starter').length : rows.length;
+    return refusal ? {
+        allowed: false,
+        left: 0,
+        reason: `this site already holds the ${limit} ${bandLabel(band.label, limit)} its plan includes`
+    } : {
+        allowed: true,
+        left: Math.max(0, limit - used),
+        reason: null
+    };
+}
+/** Whether a kind's rows are counted at all on this plan: included, and under a finite allowance. */ function countsRows(kind, org) {
+    const band = AI_DRAFT_BANDS[kind];
+    if (!band.quotaKey) return false;
+    if (band.entitlement && !checkEntitlement(org, band.entitlement)) return false;
+    return Number.isFinite(resolveOrgEntitlements(org)[band.quotaKey]);
+}
+/**
+ * What a plan may create on this site (AGL-3030), from the workspace's plan
+ * and the rows each counted kind already holds — pure, so the specs and the
+ * eval harness hold the arithmetic without a Firestore. A kind whose rows
+ * are not given is counted as having room, which is what an unlimited
+ * allowance means.
+ *
+ * A theme change is a proposal a member applies, never a draft, so it counts
+ * against nothing. A dataset is org data that no job writes; a plan may name
+ * one only where the workspace's plan includes datasets at all. An email
+ * design is written by the email plugin, whose own gate decides.
+ *
+ * A workspace on the Free plan spends the Free taste, a wall of monthly
+ * credits, so its plan is held to the sections that wall pays for (AGL-3070).
+ * The effective plan decides, as it decides the taste's own allowance: a
+ * workspace whose subscription died is Free again.
+ */ export function aiPlanCapabilitiesFrom(org, rows = {}) {
+    var _rows_component, _rows_form, _rows_layout, _rows_template;
+    const unrestricted = aiUnrestrictedPlanCapabilities();
+    const datasets = checkDatasetQuota(org, 0).limit > 0;
+    return _extends({
+        reusableComponents: checkEntitlement(org, 'reusableComponents'),
+        create: _extends({}, unrestricted.create, {
+            component: planCreation('component', org, (_rows_component = rows.component) != null ? _rows_component : null),
+            form: planCreation('form', org, (_rows_form = rows.form) != null ? _rows_form : null),
+            layout: planCreation('layout', org, (_rows_layout = rows.layout) != null ? _rows_layout : null),
+            template: planCreation('template', org, (_rows_template = rows.template) != null ? _rows_template : null),
+            dataset: datasets ? unrestricted.create.dataset : {
+                allowed: false,
+                left: 0,
+                reason: "this workspace's plan does not include datasets"
+            }
+        })
+    }, resolveEffectivePlan(org) === 'free' ? {
+        freeTaste: true
+    } : {});
+}
+/**
+ * What a plan may create on this site, read: the rows of each kind whose
+ * allowance the workspace's plan counts, as the draft writer reads them, and
+ * nothing for a kind the plan leaves out or leaves unlimited.
+ */ export async function readAiPlanCapabilities(firestore, input) {
+    const counted = AI_PLAN_DRAFT_KINDS.filter((kind)=>countsRows(kind, input.org));
+    const snapshots = await Promise.all(counted.map((kind)=>siblingsOf(draftCollection(firestore, input.hostId, kind)).get()));
+    return aiPlanCapabilitiesFrom(input.org, Object.fromEntries(counted.map((kind, index)=>[
+            kind,
+            siblingRows(snapshots[index])
+        ])));
+}
+/**
+ * Whether the site can take one more draft of the kind: a read, for a door
+ * that asks before it spends. The write asks again inside its transaction.
+ */ export async function aiDraftAllowanceRefusal(firestore, input) {
+    const [snapshot, host] = await Promise.all([
+        siblingsOf(draftCollection(firestore, input.hostId, input.kind)).get(),
+        input.kind === 'screen' ? firestore.collection('hosts').doc(input.hostId).get() : Promise.resolve(null)
+    ]);
+    return aiDraftBandRefusal(input.kind, siblingRows(snapshot), input.org, host == null ? void 0 : host.get('screens'));
+}
+/**
+ * A draft screen's one-segment address: the one asked for, else one from its
+ * name, never a reserved segment, and never an address a live screen keeps
+ * or the routing map already serves — so the member's publish at it later
+ * takes nothing from a live page. The root is asked for only while no screen
+ * holds it.
+ */ export function aiDraftScreenSlug(requested, name, rows, routingMap) {
+    var _ref, _usable;
+    const taken = new Set([
+        ...rows.filter((row)=>!row.deleted && row.slug).map((row)=>row.slug),
+        ...Object.values(routingMap != null ? routingMap : {}).filter((path)=>typeof path === 'string')
+    ]);
+    const usable = (value)=>value && !reservedScreenRouteSegment(value) && !(value === SCREEN_ROOT_PATH && taken.has(value)) ? value : undefined;
+    const base = (_ref = (_usable = usable(normalizeScreenSlug(requested != null ? requested : undefined))) != null ? _usable : usable(normalizeScreenSlug(name))) != null ? _ref : 'page';
+    if (base === SCREEN_ROOT_PATH) return base;
+    let slug = base;
+    let attempt = 2;
+    while(taken.has(slug))slug = `${base}-${attempt++}`;
+    return slug;
+}
+function recordOf(id, draft, host) {
+    var _draft_get;
+    const versionId = draft.get('versionId');
+    const seo = draft.get('seo');
+    return _extends({
+        id,
+        versionId: typeof versionId === 'string' && versionId ? versionId : null,
+        name: String((_draft_get = draft.get('displayName')) != null ? _draft_get : ''),
+        hostSubdomain: subdomainOf(host)
+    }, seo && typeof seo === 'object' ? {
+        seo: seo
+    } : {}, draft.get('deletedAt') != null ? {
+        deleted: true
+    } : {});
+}
+/** The draft a job already wrote under `id`, when a run of its step got that far. */ export async function readAiDraft(firestore, input) {
+    const draft = await draftCollection(firestore, input.hostId, input.kind).doc(input.id).get();
+    if (!draft.exists) return null;
+    return recordOf(input.id, draft, await firestore.collection('hosts').doc(input.hostId).get());
+}
+/** The tree a versioned draft's first version holds now, decoded; `null` when there is none. */ export async function readAiDraftNodes(firestore, input) {
+    const draftRef = draftCollection(firestore, input.hostId, input.kind).doc(input.id);
+    const draft = await draftRef.get();
+    const versionId = draft.exists ? draft.get('versionId') : null;
+    if (typeof versionId !== 'string' || !versionId) return null;
+    const version = await draftRef.collection('versions').doc(versionId).get();
+    const nodes = version.exists ? decodeStoredNodes(version.get('nodes')) : null;
+    return nodes ? {
+        versionId,
+        nodes
+    } : null;
+}
+/** Keep only the keys the create route admits for the kind. */ function allowListed(kind, data) {
+    const allowed = new Set(AI_DRAFT_FIELDS[kind]);
+    return Object.fromEntries(Object.entries(data).filter(([key, value])=>allowed.has(key) && value !== undefined));
+}
+/** The node map with its form node captioned with `name`, as Create captions a new form. */ function withFormCaption(nodes, formNodeId, name) {
+    var _node_props;
+    const node = nodes[formNodeId];
+    if (!node || node.componentId !== FORM_COMPONENT_ID) return nodes;
+    return _extends({}, nodes, {
+        [formNodeId]: _extends({}, node, {
+            props: _extends({}, (_node_props = node.props) != null ? _node_props : {}, {
+                formName: name
+            })
+        })
+    });
+}
+/**
+ * Write one draft: the band met, the name made unique among the live
+ * siblings, the node map stored as msgpack, all in one transaction. A
+ * refusal is returned, never thrown; a Firestore failure propagates, so the
+ * machine's retry applies.
+ */ export async function writeAiDraft(firestore, input) {
+    const packed = encodeStoredNodes(input.nodes);
+    if (!packed) throw new Error('an AI draft needs a node map');
+    if (input.kind === 'form' && !input.form) throw new Error('an AI form draft needs its declaration');
+    if (input.kind === 'component' && !(input.rootId && input.nodes[input.rootId])) {
+        throw new Error('a component draft needs a root its node map holds');
+    }
+    const hostRef = firestore.collection('hosts').doc(input.hostId);
+    const collection = draftCollection(firestore, input.hostId, input.kind);
+    const draftRef = collection.doc(input.id);
+    return firestore.runTransaction(async (tx)=>{
+        // Every read before any write, which Firestore requires.
+        const [host, existing, siblings] = await Promise.all([
+            tx.get(hostRef),
+            tx.get(draftRef),
+            tx.get(siblingsOf(collection))
+        ]);
+        if (!host.exists) return {
+            ok: false,
+            status: 404,
+            error: 'Unknown site'
+        };
+        if (existing.exists) {
+            return _extends({
+                ok: true,
+                replayed: true
+            }, recordOf(input.id, existing, host));
+        }
+        const rows = siblingRows(siblings);
+        // Read, never written: the routing map decides which screens count.
+        const routingMap = host.get('screens');
+        const refusal = aiDraftBandRefusal(input.kind, rows, input.org, routingMap);
+        if (refusal) return {
+            ok: false,
+            status: 403,
+            error: refusal
+        };
+        const name = uniqueDuplicateName(input.name, rows.filter((row)=>!row.deleted).map((row)=>row.name));
+        const stamps = {
+            createdAt: input.now,
+            updatedAt: input.now,
+            createdBy: input.uid
+        };
+        const nodes = Buffer.from(packed);
+        let versionId = null;
+        if (input.kind === 'layout') {
+            versionId = createResourceUid();
+            tx.create(draftRef, _extends({}, allowListed('layout', {
+                displayName: name,
+                versionId
+            }), stamps));
+            tx.create(draftRef.collection('versions').doc(versionId), _extends({
+                layoutId: input.id,
+                hostId: input.hostId,
+                displayName: AI_DRAFT_VERSION_NAME,
+                nodes
+            }, stamps));
+        } else if (input.kind === 'screen') {
+            versionId = createResourceUid();
+            const slug = aiDraftScreenSlug(input.slug, name, rows, routingMap);
+            tx.create(draftRef, _extends({}, allowListed('screen', {
+                displayName: name,
+                slug,
+                versionId
+            }), {
+                nameLower: nameSearchKey(name)
+            }, stamps));
+            tx.create(draftRef.collection('versions').doc(versionId), _extends({
+                screenId: input.id,
+                hostId: input.hostId,
+                displayName: AI_DRAFT_VERSION_NAME,
+                nodes
+            }, input.layoutId ? {
+                layoutId: input.layoutId
+            } : {}, stamps));
+        } else if (input.kind === 'template') {
+            tx.create(draftRef, _extends({}, allowListed('template', {
+                kind: 'page',
+                displayName: name,
+                nodes,
+                slug: input.slug || undefined
+            }), {
+                source: {
+                    type: 'authored'
+                }
+            }, stamps));
+        } else if (input.kind === 'component') {
+            var _input_props;
+            tx.create(draftRef, _extends({}, allowListed('component', {
+                displayName: name,
+                rootId: input.rootId,
+                nodes,
+                props: ((_input_props = input.props) == null ? void 0 : _input_props.length) ? [
+                    ...input.props
+                ] : undefined
+            }), stamps));
+        } else {
+            var _encodeStoredNodes, _form_routing;
+            const form = input.form;
+            const captioned = (_encodeStoredNodes = encodeStoredNodes(withFormCaption(input.nodes, form.formNodeId, name))) != null ? _encodeStoredNodes : packed;
+            tx.create(draftRef, _extends({}, allowListed('form', {
+                displayName: name,
+                slug: normalizeFormSlug(name) || input.id,
+                fields: form.fields,
+                consentFieldName: form.consentFieldName || undefined,
+                routing: (_form_routing = form.routing) != null ? _form_routing : undefined,
+                rootId: form.rootId,
+                nodes: Buffer.from(captioned)
+            }), stamps));
+        }
+        return {
+            ok: true,
+            replayed: false,
+            id: input.id,
+            versionId,
+            name,
+            hostSubdomain: subdomainOf(host)
+        };
+    });
+}
+/**
+ * Change the tree of a versioned draft the job wrote, in one transaction:
+ * read the first version as it is stored NOW — a member may have opened and
+ * saved it — hand it to `update`, and store what comes back with a fresh
+ * `updatedAt`, which is what the besigner's save guard compares. `update`
+ * answering `null` changes nothing: a pass run again after its write.
+ */ export async function updateAiDraftNodes(firestore, input) {
+    const draftRef = draftCollection(firestore, input.hostId, input.kind).doc(input.id);
+    return firestore.runTransaction(async (tx)=>{
+        const draft = await tx.get(draftRef);
+        const versionId = draft.exists && draft.get('deletedAt') == null ? draft.get('versionId') : null;
+        if (typeof versionId !== 'string' || !versionId) {
+            return {
+                ok: false,
+                status: 404,
+                error: 'The draft is no longer on the site'
+            };
+        }
+        const versionRef = draftRef.collection('versions').doc(versionId);
+        const version = await tx.get(versionRef);
+        const nodes = version.exists ? decodeStoredNodes(version.get('nodes')) : null;
+        if (!nodes) return {
+            ok: false,
+            status: 404,
+            error: 'The draft is no longer on the site'
+        };
+        const next = input.update(nodes);
+        if (!next) return {
+            ok: true,
+            changed: false
+        };
+        const packed = encodeStoredNodes(next);
+        if (!packed) throw new Error('an AI draft needs a node map');
+        tx.update(versionRef, {
+            nodes: Buffer.from(packed),
+            updatedAt: input.now
+        });
+        return {
+            ok: true,
+            changed: true
+        };
+    });
+}
+/**
+ * Put a search title and description on a draft screen the job wrote, each
+ * only where the draft has none: a value a member typed since is theirs.
+ */ export async function writeAiDraftScreenSeo(firestore, input) {
+    const ref = draftCollection(firestore, input.hostId, 'screen').doc(input.id);
+    await firestore.runTransaction(async (tx)=>{
+        const screen = await tx.get(ref);
+        if (!screen.exists || screen.get('deletedAt') != null) return;
+        const patch = {};
+        for (const key of [
+            'title',
+            'description'
+        ]){
+            var _input_seo_key, _screen_get;
+            const value = String((_input_seo_key = input.seo[key]) != null ? _input_seo_key : '').trim();
+            if (value && !String((_screen_get = screen.get(`seo.${key}`)) != null ? _screen_get : '').trim()) patch[`seo.${key}`] = value;
+        }
+        if (Object.keys(patch).length) tx.update(ref, _extends({}, patch, {
+            updatedAt: input.now
+        }));
+    });
+}
+/** The site's subdomain, which a console link names the site by. */ export async function aiSiteSubdomain(firestore, hostId) {
+    return subdomainOf(await firestore.collection('hosts').doc(hostId).get());
+}
+/**
+ * What a door says before a job that writes a draft of this kind exists: a
+ * site is named, and it is the job's own org's; whatever the kind checks of
+ * its own; then the allowance. `null` admits the job.
+ */ export async function aiDraftAdmissionRefusal(firestore, input) {
+    if (!input.hostId) {
+        var _input_noun;
+        return {
+            status: 400,
+            error: `Open the site the ${(_input_noun = input.noun) != null ? _input_noun : input.kind} is for before starting the job`
+        };
+    }
+    const owner = await resolveOrgIdForHost(input.hostId);
+    if (!owner || owner !== input.orgId) return {
+        status: 404,
+        error: 'Unknown site'
+    };
+    const own = await (input.ownCheck == null ? void 0 : input.ownCheck.call(input, input.hostId));
+    if (own) return own;
+    const refusal = await aiDraftAllowanceRefusal(firestore, {
+        kind: input.kind,
+        hostId: input.hostId,
+        org: input.org
+    });
+    return refusal ? {
+        status: 403,
+        error: refusal
+    } : null;
+}
+
+//# sourceMappingURL=ai-job-drafts.js.map