@noodleseed/one 0.162.0 → 0.163.0

package/node_modules/@noodle-borg/service/dist/routes/business-information-staff.js

@@ -0,0 +1,258 @@
+import { randomUUID } from 'node:crypto';
+import { readJsonBody, sendJson } from '@noodle-borg/transport-http';
+import { BusinessInvitationCreateRequestSchema, BusinessInvitationRevokeRequestSchema, formatWireError, } from '@noodle-borg/wire-contracts';
+import { hashToken } from '../oauth/tokens.js';
+import { requireIdentity, requireInstallationPermission, } from './business-information.js';
+import { parseBusinessPaging } from './business-information-request.js';
+import { grantToWire, installationToWire, invitationToWire } from './business-information-wire.js';
+const HOUR_MS = 60 * 60 * 1_000;
+export async function handleMySolutionInstallations(req, res, deps) {
+    if (req.method !== 'GET')
+        return methodNotAllowed(res);
+    const identity = await requireIdentity(req, res, deps);
+    if (identity === false)
+        return;
+    const paging = parseBusinessPaging(new URL(req.url ?? '/', 'http://service.invalid'), 100);
+    if (!paging.ok)
+        return sendJson(res, 400, { error: paging.error });
+    const after = paging.value.cursor === undefined ? undefined : decodeDiscoveryCursor(paging.value.cursor);
+    if (paging.value.cursor !== undefined && after === undefined) {
+        return sendJson(res, 400, { error: 'cursor is invalid' });
+    }
+    const limit = paging.value.limit ?? 100;
+    const joined = [...(await deps.store.listInstallationsForSubject(identity.subject))]
+        .sort((left, right) => compareDiscoveryRows(left, right))
+        .filter((item) => after === undefined || discoveryOrderKey(item) > after)
+        .slice(0, limit + 1);
+    const visible = joined.slice(0, limit);
+    sendJson(res, 200, {
+        ok: true,
+        data: {
+            installations: visible.map(({ installation, grant }) => installationToWire(installation, grant.role)),
+            ...(joined.length > limit && visible.at(-1) !== undefined
+                ? { nextCursor: encodeDiscoveryCursor(visible.at(-1)) }
+                : {}),
+        },
+    });
+}
+export async function handleBusinessInvitations(req, res, ref, deps) {
+    const identity = await requireIdentity(req, res, deps);
+    if (identity === false)
+        return;
+    const authorized = await requireInstallationPermission(res, ref, identity, 'grants:manage', deps);
+    if (authorized === undefined)
+        return;
+    res.setHeader('cache-control', 'no-store');
+    const now = deps.now?.() ?? new Date();
+    if (req.method === 'GET' && ref.invitationId === undefined) {
+        const invitations = await deps.store.listInvitations(authorized.scope);
+        return sendJson(res, 200, {
+            ok: true,
+            data: { invitations: invitations.slice(0, 100).map((item) => invitationToWire(item, now)) },
+        });
+    }
+    if (req.method === 'POST' && ref.invitationId === undefined) {
+        const body = await readJsonBody(req, deps.maxBody);
+        if (!body.ok)
+            return sendJson(res, body.status, { error: body.error });
+        const parsed = BusinessInvitationCreateRequestSchema.safeParse(body.value);
+        if (!parsed.success) {
+            return sendJson(res, 400, { error: formatWireError(parsed.error) });
+        }
+        const result = await deps.store.createInvitation({
+            scope: authorized.scope,
+            invitationId: `binv_${randomUUID().replaceAll('-', '')}`,
+            email: parsed.data.email,
+            role: parsed.data.role,
+            tokenDigest: hashToken(parsed.data.token),
+            idempotencyKey: parsed.data.idempotencyKey,
+            expiresAt: new Date(now.getTime() + parsed.data.expiresInHours * HOUR_MS),
+            actorSubject: identity.subject,
+        });
+        if (result.disposition === 'conflict') {
+            return sendJson(res, 409, {
+                error: 'idempotency key was already used for a different invitation',
+                code: 'idempotency_conflict',
+            });
+        }
+        await emitStaffAudit(deps, {
+            eventType: 'business.invitation.created',
+            org: authorized.scope.org,
+            subject: identity.subject,
+            email: identity.email,
+            details: {
+                installationId: authorized.scope.installationId,
+                invitationId: result.invitation.invitationId,
+                invitedEmail: result.invitation.email,
+                role: result.invitation.role,
+                replayed: result.disposition === 'replayed' ? 1 : 0,
+            },
+        });
+        return sendJson(res, result.disposition === 'created' ? 201 : 200, {
+            ok: true,
+            data: {
+                invitation: invitationToWire(result.invitation, now),
+                acceptPath: `/portal-invitations/${encodeURIComponent(parsed.data.token)}`,
+                replayed: result.disposition === 'replayed',
+            },
+        });
+    }
+    if (req.method === 'DELETE' && ref.invitationId !== undefined) {
+        const body = await readJsonBody(req, deps.maxBody);
+        if (!body.ok)
+            return sendJson(res, body.status, { error: body.error });
+        const parsed = BusinessInvitationRevokeRequestSchema.safeParse(body.value);
+        if (!parsed.success) {
+            return sendJson(res, 400, { error: formatWireError(parsed.error) });
+        }
+        const result = await deps.store.revokeInvitation({
+            scope: authorized.scope,
+            invitationId: ref.invitationId,
+            expectedRevision: parsed.data.expectedRevision,
+            actorSubject: identity.subject,
+        });
+        if (!result.ok) {
+            const status = result.reason === 'not_found' ? 404 : result.reason === 'conflict' ? 409 : 422;
+            return sendJson(res, status, {
+                error: result.reason.replaceAll('_', ' '),
+                code: result.reason,
+                currentRevision: result.currentRevision,
+            });
+        }
+        await emitStaffAudit(deps, {
+            eventType: 'business.invitation.revoked',
+            org: authorized.scope.org,
+            subject: identity.subject,
+            email: identity.email,
+            details: {
+                installationId: authorized.scope.installationId,
+                invitationId: result.invitation.invitationId,
+            },
+        });
+        return sendJson(res, 200, {
+            ok: true,
+            data: { invitation: invitationToWire(result.invitation, now) },
+        });
+    }
+    methodNotAllowed(res);
+}
+export async function handleBusinessInvitationAccept(req, res, rawToken, deps) {
+    if (req.method !== 'POST')
+        return methodNotAllowed(res);
+    if (!/^[A-Za-z0-9_-]{43,128}$/.test(rawToken)) {
+        return sendJson(res, 404, {
+            error: 'invitation is unavailable',
+            code: 'invitation_unavailable',
+        });
+    }
+    const identity = await requireIdentity(req, res, deps);
+    if (identity === false)
+        return;
+    res.setHeader('cache-control', 'no-store');
+    const result = await deps.store.claimInvitation({
+        tokenDigest: hashToken(rawToken),
+        subject: identity.subject,
+        email: identity.email,
+    });
+    if (!result.ok) {
+        if (result.reason === 'last_administrator') {
+            return sendJson(res, 409, {
+                error: 'another administrator is required before accepting this role',
+                code: 'last_administrator',
+            });
+        }
+        const status = result.reason === 'email_mismatch' ? 403 : result.reason === 'not_found' ? 404 : 410;
+        return sendJson(res, status, {
+            error: result.reason === 'email_mismatch'
+                ? 'sign in with the invited email address'
+                : 'invitation is unavailable',
+            code: result.reason === 'email_mismatch' ? result.reason : 'invitation_unavailable',
+        });
+    }
+    const installation = await deps.store.getInstallation(result.grant.scope);
+    if (installation === undefined)
+        throw new Error('claimed invitation installation is missing');
+    await emitStaffAudit(deps, {
+        eventType: 'business.invitation.accepted',
+        org: result.grant.scope.org,
+        subject: identity.subject,
+        email: identity.email,
+        details: {
+            installationId: result.grant.scope.installationId,
+            invitationId: result.invitation.invitationId,
+            role: result.grant.role,
+        },
+    });
+    sendJson(res, 201, {
+        ok: true,
+        data: {
+            installation: installationToWire(installation, result.grant.role),
+            grant: grantToWire(result.grant),
+        },
+    });
+}
+export async function handleEligibleBusinessAssignees(req, res, ref, deps) {
+    if (req.method !== 'GET')
+        return methodNotAllowed(res);
+    const identity = await requireIdentity(req, res, deps);
+    if (identity === false)
+        return;
+    const authorized = await requireInstallationPermission(res, ref, identity, 'records:assign', deps);
+    if (authorized === undefined)
+        return;
+    const grants = await deps.store.listEligibleAssignees(authorized.scope);
+    sendJson(res, 200, {
+        ok: true,
+        data: {
+            assignees: grants
+                .map((grant) => ({ subject: grant.subject, email: grant.email, role: grant.role }))
+                .slice(0, 100),
+        },
+    });
+}
+function methodNotAllowed(res) {
+    res.setHeader('allow', 'GET, POST, DELETE');
+    sendJson(res, 405, { error: 'method not allowed' });
+}
+function discoveryOrderKey(item) {
+    return `${item.installation.createdAt}\0${item.installation.scope.org}\0${item.installation.scope.installationId}`;
+}
+function compareDiscoveryRows(left, right) {
+    const leftKey = discoveryOrderKey(left);
+    const rightKey = discoveryOrderKey(right);
+    return leftKey < rightKey ? -1 : leftKey > rightKey ? 1 : 0;
+}
+function encodeDiscoveryCursor(item) {
+    return Buffer.from(discoveryOrderKey(item), 'utf8').toString('base64url');
+}
+function decodeDiscoveryCursor(raw) {
+    if (!/^[A-Za-z0-9_-]{1,1024}$/.test(raw))
+        return undefined;
+    try {
+        const decoded = Buffer.from(raw, 'base64url').toString('utf8');
+        const parts = decoded.split('\0');
+        if (parts.length !== 3 ||
+            Number.isNaN(Date.parse(parts[0] ?? '')) ||
+            !/^[a-z0-9][a-z0-9-]{0,62}$/.test(parts[1] ?? '') ||
+            (parts[2]?.length ?? 0) < 1 ||
+            (parts[2]?.length ?? 0) > 256) {
+            return undefined;
+        }
+        return decoded;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function emitStaffAudit(deps, event) {
+    await deps.audit?.emit({
+        eventType: event.eventType,
+        org: event.org,
+        decision: 'allow',
+        status: 200,
+        actorSubject: event.subject,
+        actorEmail: event.email,
+        details: event.details,
+    });
+}
+//# sourceMappingURL=business-information-staff.js.map

package/node_modules/@noodle-borg/service/dist/routes/business-information-wire.js

@@ -1,41 +1,113 @@
+import { projectManagedCollectionControls } from '@noodle-borg/compiler';
+import { collectionPublicFields } from '../business-information/collection-controls.js';
+import { invitationStatus } from '../business-information/invitations.js';
+import { collectionForStoredRecord } from '../business-information/managed-releases.js';
+import { validateCollectionEnabled } from '../business-information/model.js';
+import { builtInDefinitionAtRelease } from '../business-information/profiles.js';
+/** Exact accepted schema with current presentation and operator edit restrictions. */
+export function recordDetailToWire(installation, record) {
+    const accepted = collectionForStoredRecord(installation, record);
+    const current = validateCollectionEnabled(installation, record.collectionKey);
+    const projected = recordToWire(record);
+    if (!('payload' in projected))
+        throw new Error('deleted records have no editable detail');
+    const names = new Set(Object.keys(accepted.recordSchema.properties));
+    const select = (fields) => fields.filter((name) => names.has(name));
+    return {
+        record: projected,
+        collection: collectionToWire({
+            ...current,
+            schemaVersion: accepted.schemaVersion,
+            schemaDigest: accepted.schemaDigest,
+            recordSchema: accepted.recordSchema,
+            summaryFields: select(current.summaryFields),
+            editableFields: select(current.editableFields ?? [...names]),
+            ...(current.publicFields === undefined ? {} : { publicFields: select(current.publicFields) }),
+            ...(current.filterFields === undefined ? {} : { filterFields: select(current.filterFields) }),
+            ...(current.sortFields === undefined ? {} : { sortFields: select(current.sortFields) }),
+            ...(current.fields === undefined
+                ? {}
+                : {
+                    fields: Object.fromEntries(Object.entries(current.fields).filter(([name]) => names.has(name))),
+                }),
+        }),
+    };
+}
 export function profileToWire(profile) {
-    const collection = profile.collections[0];
-    if (collection === undefined)
-        throw new Error(`solution profile "${profile.key}" has no collection`);
     return {
-        id: profile.key,
+        id: managedProfileId(profile.key),
         title: profile.label,
-        description: `Receive and operate ${collection.labels.plural.toLowerCase()}.`,
-        collection: collectionToWire(collection),
+        description: `Receive and operate ${profile.collections[0]?.labels.plural.toLowerCase() ?? 'business records'}.`,
+        collections: builtInDefinitionAtRelease(profile.key, profile.version).collections.map(collectionToWire),
     };
 }
 export function collectionToWire(collection) {
-    return {
+    const common = {
         key: collection.key,
-        title: collection.labels.plural,
-        singularTitle: collection.labels.singular,
+        title: collection.title,
+        singularTitle: collection.singularTitle,
         schemaVersion: collection.schemaVersion,
         schemaDigest: collection.schemaDigest.replace(/^sha256:/, ''),
-        recordSchema: { ...collection.schema },
-        summaryFields: collection.schema.required.slice(0, 6),
+        recordSchema: { ...collection.recordSchema },
+        ...projectManagedCollectionControls(collection),
+        summaryFields: [...collection.summaryFields],
+    };
+    if (collection.authority.authority === 'external') {
+        return {
+            authority: 'external',
+            ...common,
+            capabilities: {
+                read: true,
+                create: false,
+                update: false,
+                erase: true,
+                sourceControls: true,
+            },
+            source: {
+                connector: collection.authority.connectorAlias,
+                scanOperation: collection.authority.scanOperation,
+            },
+        };
+    }
+    return {
+        authority: 'native',
+        ...common,
+        capabilities: {
+            read: true,
+            create: true,
+            update: true,
+            erase: true,
+            sourceControls: false,
+        },
+        ...(collection.behavior?.kind === 'request'
+            ? {
+                requestBehavior: {
+                    statuses: ['new', 'in_progress', 'resolved', 'closed'],
+                    assignment: true,
+                    notes: true,
+                },
+            }
+            : {}),
     };
 }
-export function installationToWire(installation, profile, currentRole) {
-    const collection = profile.collections.find((candidate) => installation.managedCollections.includes(candidate.key));
-    if (collection === undefined)
-        throw new Error('solution installation has no active collection');
+export function installationToWire(installation, currentRole) {
     return {
         id: installation.scope.installationId,
         organizationId: installation.scope.org,
-        profileId: installation.profileKey,
         appSlug: installation.scope.app,
         environment: installation.scope.env,
         retentionDays: installation.retentionDays,
         publicId: installation.publicId,
-        active: true,
+        active: installation.intakeActive,
         currentRole,
         revision: installation.revision,
-        collection: collectionToWire(collection),
+        definition: definitionToWire(installation.definition.reference),
+        collections: installation.definition.collections
+            .filter((collection) => installation.managedCollections.includes(collection.key))
+            .map(collectionToWire),
+        ...(installation.definition.reference.kind === 'legacy'
+            ? { profileId: installation.definition.reference.definitionId }
+            : {}),
         createdAt: installation.createdAt,
         updatedAt: installation.updatedAt,
         createdBySubject: installation.createdBySubject,
@@ -55,30 +127,52 @@ export function grantToWire(grant) {
         ...(grant.revokedAt === undefined ? {} : { revokedAt: grant.revokedAt }),
     };
 }
+export function invitationToWire(invitation, now) {
+    return {
+        invitationId: invitation.invitationId,
+        installationId: invitation.scope.installationId,
+        email: invitation.email,
+        role: invitation.role,
+        status: invitationStatus(invitation, now),
+        revision: invitation.revision,
+        createdAt: invitation.createdAt,
+        expiresAt: invitation.expiresAt,
+        createdBySubject: invitation.createdBySubject,
+        ...(invitation.acceptedAt === undefined ? {} : { acceptedAt: invitation.acceptedAt }),
+        ...(invitation.revokedAt === undefined ? {} : { revokedAt: invitation.revokedAt }),
+    };
+}
 export function recordToWire(record) {
+    const scope = wireRecordScope(record);
     if (record.deletedAt !== undefined || record.content === undefined) {
         if (record.deletedAt === undefined || record.deletionReason === undefined) {
             throw new Error('managed record tombstone is incomplete');
         }
         return {
-            id: record.id,
-            installationId: record.scope.installationId,
-            collection: record.collectionKey,
-            status: record.status,
+            authority: 'native',
+            ...scope,
             revision: record.revision,
             deletedAt: record.deletedAt,
             deletionReason: record.deletionReason,
         };
     }
     return {
-        id: record.id,
-        installationId: record.scope.installationId,
-        collection: record.collectionKey,
+        authority: 'native',
+        ...scope,
         schemaVersion: record.schemaVersion,
         schemaDigest: record.schemaDigest.replace(/^sha256:/, ''),
         payload: record.content.payload,
-        status: record.status,
         ...(record.assigneeSubject === undefined ? {} : { assigneeSubject: record.assigneeSubject }),
+        ...(record.status === undefined
+            ? {}
+            : {
+                request: {
+                    status: record.status,
+                    ...(record.assigneeSubject === undefined
+                        ? {}
+                        : { assigneeSubject: record.assigneeSubject }),
+                },
+            }),
         revision: record.revision,
         origin: {
             surface: record.origin.kind === 'embedded'
@@ -93,11 +187,43 @@ export function recordToWire(record) {
         retentionExpiresAt: record.retentionExpiresAt,
     };
 }
+export function externalRecordToWire(record, binding) {
+    if (record.record === undefined || record.lastSuccessfulSyncAt === undefined) {
+        throw new Error('incomplete external record cannot be projected');
+    }
+    return {
+        authority: 'external',
+        id: record.id,
+        organizationId: record.scope.org,
+        appSlug: record.scope.app,
+        environment: record.scope.env,
+        installationId: record.scope.installationId,
+        collection: record.collectionKey,
+        schemaVersion: record.schemaVersion,
+        schemaDigest: record.schemaDigest.replace(/^sha256:/, ''),
+        payload: record.record,
+        revision: record.revision,
+        createdAt: record.createdAt,
+        updatedAt: record.updatedAt,
+        retentionExpiresAt: record.retentionExpiresAt,
+        source: {
+            bindingReference: record.source.bindingId,
+            bindingGeneration: record.source.bindingGeneration,
+            sourceRecordId: record.source.id,
+            ...(record.source.version === undefined ? {} : { sourceVersion: record.source.version }),
+            observedAt: record.observedAt,
+            lastCompletedSyncAt: record.lastSuccessfulSyncAt,
+            health: sourceHealth(binding),
+            completeness: binding.completeness === 'complete' ? 'complete' : 'partial',
+        },
+    };
+}
 const ACTIVITY_OPERATION = {
     created: 'create',
     updated: 'update',
     assigned: 'assign',
     status_changed: 'set-status',
+    schema_migrated: 'schema-migrated',
     note_added: 'add-note',
     deleted: 'delete',
     retention_expired: 'delete',
@@ -114,4 +240,78 @@ export function activityToWire(activity) {
         ...(note === undefined ? {} : { note }),
     };
 }
+function definitionToWire(reference) {
+    if (reference.kind !== 'private')
+        return reference;
+    return {
+        kind: 'private',
+        publisherOrg: reference.publisherOrg,
+        app: reference.app,
+        environment: reference.env,
+        deploymentId: reference.deploymentId,
+        version: reference.version,
+        digest: reference.digest,
+    };
+}
+function wireRecordScope(record) {
+    return {
+        id: record.id,
+        organizationId: record.scope.org,
+        appSlug: record.scope.app,
+        environment: record.scope.env,
+        installationId: record.scope.installationId,
+        collection: record.collectionKey,
+    };
+}
+function sourceHealth(binding) {
+    if (binding.health === 'initializing')
+        return 'pending';
+    if (binding.health === 'current')
+        return 'healthy';
+    if (binding.health === 'stale')
+        return 'degraded';
+    if (binding.health === 'reauth_required')
+        return 'authorization_required';
+    if (binding.health === 'paused')
+        return 'paused';
+    return 'unavailable';
+}
+function managedProfileId(key) {
+    if (key === 'b2b_saas')
+        throw new Error('legacy B2B SaaS profile is not in the managed catalog');
+    return key;
+}
+export function collectionToPublicWire(collection) {
+    const wire = collectionToWire(collection);
+    if (wire.authority !== 'native')
+        throw new Error('public intake requires a native collection');
+    const allowed = new Set(collectionPublicFields(collection));
+    const { requestBehavior, management, editableFields, filterFields, sortFields, fields, ...publicWire } = wire;
+    void requestBehavior;
+    void management;
+    void editableFields;
+    void filterFields;
+    void sortFields;
+    const schema = collection.recordSchema;
+    const properties = schema.properties;
+    return {
+        ...publicWire,
+        ...(fields === undefined
+            ? {}
+            : {
+                fields: Object.fromEntries(Object.entries(fields).filter(([name]) => allowed.has(name))),
+            }),
+        recordSchema: {
+            type: 'object',
+            additionalProperties: false,
+            properties: Object.fromEntries(Object.entries(properties !== null && typeof properties === 'object' && !Array.isArray(properties)
+                ? properties
+                : {}).filter(([name]) => allowed.has(name))),
+            required: Array.isArray(schema.required)
+                ? schema.required.filter((name) => typeof name === 'string' && allowed.has(name))
+                : [],
+        },
+        summaryFields: wire.summaryFields.filter((name) => allowed.has(name)),
+    };
+}
 //# sourceMappingURL=business-information-wire.js.map