@noodleseed/one 0.162.0 → 0.164.0

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

@@ -1,11 +1,14 @@
-import { createHash } from 'node:crypto';
-import { clientAddressBucket, } from '@noodle-borg/admission-limits/portable';
 import { readJsonBody, sendJson } from '@noodle-borg/transport-http';
-import { BusinessGrantCreateRequestSchema, formatWireError, ManagedRecordCreateRequestSchema, ManagedRecordMutationRequestSchema, ManagedRecordStatusSchema, SolutionInstallationCreateRequestSchema, } from '@noodle-borg/wire-contracts';
-import { BUILT_IN_SOLUTION_PROFILES, businessGrantAllows, CursorValidationError, PayloadValidationError, validateProfilePayload, } from '../business-information/portable.js';
+import { BusinessGrantCreateRequestSchema, formatWireError, ManagedRecordCreateRequestSchema, ManagedRecordMutationRequestSchema, ManagedRecordStatusSchema, SolutionInstallationCreateRequestSchema, SolutionInstallationIntakeRequestSchema, } from '@noodle-borg/wire-contracts';
+import { admitBusinessMutation, admitBusinessTarget, authorizeBusinessApi, } from '../business-api-admission.js';
+import { BUILT_IN_SOLUTION_PROFILES, businessGrantAllows, MANAGED_SOLUTION_PROFILE_KEYS, PayloadValidationError, validateCollectionEnabled, } from '../business-information/portable.js';
 import { sendForbidden } from '../http-util.js';
-import { activityToWire, grantToWire, installationToWire, profileToWire, recordToWire, } from './business-information-wire.js';
-import { authorizeControlPlane } from './control-plane.js';
+import { loadExternalRecord, sendExternalRecordPage, sourceBindingKey, unsupportedExternalOperation, } from './business-information-external.js';
+import { resolveInstallDefinition, stableInstallationId, } from './business-information-installation.js';
+import { createNativeRecord } from './business-information-record-create.js';
+import { cursorRequest, sendNativeRecordActivity } from './business-information-record-reads.js';
+import { expectedRevision, mutationPermission, parseNativeRecordQuery, parseBusinessPaging as parsePaging, requestIdempotencyKey, } from './business-information-request.js';
+import { collectionToWire, externalRecordToWire, grantToWire, installationToWire, profileToWire, recordDetailToWire, recordToWire, } from './business-information-wire.js';
 import { canManageMembers } from './org-admin.js';
 export function handleSolutionCatalog(req, res) {
     if (req.method !== 'GET') {
@@ -14,7 +17,9 @@ export function handleSolutionCatalog(req, res) {
     }
     sendJson(res, 200, {
         ok: true,
-        data: { profiles: Object.values(BUILT_IN_SOLUTION_PROFILES).map(profileToWire) },
+        data: {
+            profiles: MANAGED_SOLUTION_PROFILE_KEYS.map((key) => profileToWire(BUILT_IN_SOLUTION_PROFILES[key])),
+        },
     });
 }
 export async function handleSolutionInstallations(req, res, ref, deps) {
@@ -25,13 +30,21 @@ export async function handleSolutionInstallations(req, res, ref, deps) {
         if (!(await canManageMembers(deps.controlPlane, ref.org, identity))) {
             return sendForbidden(res, 'organization owner required');
         }
+        if (!(await admitBusinessTarget(res, ref)))
+            return;
         const body = await readJsonBody(req, deps.maxBody);
         if (!body.ok)
             return sendJson(res, body.status, { error: body.error });
         const parsed = SolutionInstallationCreateRequestSchema.safeParse(body.value);
         if (!parsed.success)
             return invalid(res, parsed.error);
-        const profile = BUILT_IN_SOLUTION_PROFILES[parsed.data.profileId];
+        const definition = await resolveInstallDefinition(parsed.data.definition, ref.org, deps.resolvePrivateDefinition);
+        if (definition === undefined) {
+            return sendJson(res, 404, {
+                error: 'solution definition is unavailable',
+                code: 'definition_unavailable',
+            });
+        }
         const installationId = stableInstallationId(ref.org, parsed.data.appSlug, parsed.data.environment);
         const result = await deps.store.createInstallation({
             scope: {
@@ -40,8 +53,10 @@ export async function handleSolutionInstallations(req, res, ref, deps) {
                 env: parsed.data.environment,
                 installationId,
             },
-            profileKey: parsed.data.profileId,
-            managedCollections: profile.collections.map((collection) => collection.key),
+            ...(parsed.data.definition.kind === 'managed'
+                ? { profileKey: parsed.data.definition.profileId }
+                : { definition }),
+            managedCollections: definition.collections.map((collection) => collection.key),
             retentionDays: parsed.data.retentionDays,
             actorSubject: identity.subject,
             actorEmail: identity.email,
@@ -56,10 +71,32 @@ export async function handleSolutionInstallations(req, res, ref, deps) {
         if (grant === undefined || grant.revokedAt !== undefined) {
             return sendForbidden(res, 'business grant required');
         }
+        if (parsed.data.businessNotice &&
+            !(await deps.store.getBusinessNotice(result.installation.scope))) {
+            await deps.store.setBusinessNotice({
+                scope: result.installation.scope,
+                expectedRevision: 0,
+                notice: parsed.data.businessNotice,
+                actorSubject: identity.subject,
+            });
+        }
+        const activated = await deps.activateInstallation?.({
+            installation: result.installation,
+            actor: identity,
+        });
+        if (activated === undefined || !activated.ok) {
+            return sendJson(res, activated?.status ?? 503, {
+                ok: false,
+                code: activated?.code ?? 'installation_activation_unavailable',
+                error: activated?.message ??
+                    'The installation is saved, but application activation is unavailable. Retry installation when the service is ready.',
+                installationId: result.installation.scope.installationId,
+            });
+        }
         return sendJson(res, result.disposition === 'created' ? 201 : 200, {
             ok: true,
             data: {
-                installation: installationToWire(result.installation, profile, grant.role),
+                installation: installationToWire(result.installation, grant.role),
             },
         });
     }
@@ -72,10 +109,12 @@ export async function handleSolutionInstallations(req, res, ref, deps) {
                 permitted.push({ installation, role: grant.role });
             }
         }
+        if (permitted.length > 0 && !(await admitBusinessTarget(res, ref)))
+            return;
         return sendJson(res, 200, {
             ok: true,
             data: {
-                installations: permitted.map(({ installation, role }) => installationToWire(installation, BUILT_IN_SOLUTION_PROFILES[installation.profileKey], role)),
+                installations: permitted.map(({ installation, role }) => installationToWire(installation, role)),
             },
         });
     }
@@ -86,10 +125,33 @@ export async function handleSolutionInstallations(req, res, ref, deps) {
         return sendJson(res, 200, {
             ok: true,
             data: {
-                installation: installationToWire(authorized.installation, BUILT_IN_SOLUTION_PROFILES[authorized.installation.profileKey], authorized.grant.role),
+                installation: installationToWire(authorized.installation, authorized.grant.role),
             },
         });
     }
+    if (req.method === 'PATCH' && ref.installationId !== undefined) {
+        const authorized = await requireInstallationPermission(res, ref, identity, 'installation:administer', deps);
+        if (authorized === undefined)
+            return;
+        const body = await readJsonBody(req, deps.maxBody);
+        if (!body.ok)
+            return sendJson(res, body.status, { error: body.error });
+        const parsed = SolutionInstallationIntakeRequestSchema.safeParse(body.value);
+        if (!parsed.success)
+            return invalid(res, parsed.error);
+        const result = await deps.store.setIntakeState({
+            scope: authorized.scope,
+            expectedRevision: parsed.data.expectedRevision,
+            active: parsed.data.active,
+            actorSubject: identity.subject,
+        });
+        if (!result.ok)
+            return mutationFailure(res, result);
+        return sendJson(res, 200, {
+            ok: true,
+            data: { installation: installationToWire(result.installation, authorized.grant.role) },
+        });
+    }
     return methodNotAllowed(res);
 }
 export async function handleBusinessGrants(req, res, ref, deps) {
@@ -101,7 +163,7 @@ export async function handleBusinessGrants(req, res, ref, deps) {
         return;
     const { scope } = authorized.installation;
     if (req.method === 'GET' && ref.subject === undefined) {
-        const grants = (await deps.store.listGrants(scope)).filter((grant) => grant.revokedAt === undefined);
+        const grants = await deps.store.listGrants(scope);
         return sendJson(res, 200, { ok: true, data: { grants: grants.map(grantToWire) } });
     }
     if (req.method === 'POST' && ref.subject === undefined) {
@@ -157,23 +219,27 @@ export async function handleManagedRecords(req, res, url, ref, deps) {
         const authorized = await requireInstallationPermission(res, ref, identity, 'records:read', deps);
         if (authorized === undefined)
             return;
-        if (!collectionEnabled(res, authorized.installation, collection))
+        const definition = enabledCollection(res, authorized.installation, collection);
+        if (definition === undefined)
             return;
-        const activities = await deps.store.listActivity(authorized.installation.scope, collection, ref.recordId);
-        return sendJson(res, 200, {
-            ok: true,
-            data: { activities: activities.map(activityToWire) },
-        });
+        if (definition.authority.authority === 'external') {
+            return sendJson(res, 200, { ok: true, data: { activities: [] } });
+        }
+        return sendNativeRecordActivity(res, url, authorized.installation.scope, collection, ref.recordId, deps.store);
     }
     if (ref.action === 'export' && req.method === 'GET') {
         const authorized = await requireInstallationPermission(res, ref, identity, 'records:export', deps);
         if (authorized === undefined)
             return;
-        if (!collectionEnabled(res, authorized.installation, collection))
+        const definition = enabledCollection(res, authorized.installation, collection);
+        if (definition === undefined)
             return;
         const paging = parsePaging(url, 500);
         if (!paging.ok)
             return sendJson(res, 400, { error: paging.error });
+        if (definition.authority.authority === 'external') {
+            return sendExternalRecordPage(res, authorized.installation, definition, { ...paging.value, limit: paging.value.limit ?? 500 }, deps);
+        }
         const page = await cursorRequest(res, () => deps.store.exportRequests({
             scope: authorized.installation.scope,
             collectionKey: collection,
@@ -185,7 +251,10 @@ export async function handleManagedRecords(req, res, url, ref, deps) {
         return sendJson(res, 200, {
             ok: true,
             data: {
-                records: page.records.map(recordToWire),
+                records: page.records.map((record) => ({
+                    ...recordToWire(record),
+                    ...(record.content ? { notes: record.content.notes } : {}),
+                })),
                 ...(page.nextCursor === undefined ? {} : { nextCursor: page.nextCursor }),
             },
         });
@@ -194,11 +263,23 @@ export async function handleManagedRecords(req, res, url, ref, deps) {
         const authorized = await requireInstallationPermission(res, ref, identity, 'records:read', deps);
         if (authorized === undefined)
             return;
-        if (!collectionEnabled(res, authorized.installation, collection))
+        const definition = enabledCollection(res, authorized.installation, collection);
+        if (definition === undefined)
             return;
         const paging = parsePaging(url, 100);
         if (!paging.ok)
             return sendJson(res, 400, { error: paging.error });
+        const query = parseNativeRecordQuery(url);
+        if (!query.ok)
+            return sendJson(res, 400, { error: query.error, code: 'invalid_query' });
+        if (definition.authority.authority === 'external') {
+            if (Object.keys(query.value).length > 0)
+                return sendJson(res, 400, {
+                    error: 'Field and date queries currently require a native collection.',
+                    code: 'invalid_query',
+                });
+            return sendExternalRecordPage(res, authorized.installation, definition, paging.value, deps);
+        }
         const statusValue = url.searchParams.get('status');
         const status = statusValue === null ? undefined : ManagedRecordStatusSchema.safeParse(statusValue);
         if (status !== undefined && !status.success)
@@ -208,6 +289,7 @@ export async function handleManagedRecords(req, res, url, ref, deps) {
             scope: authorized.installation.scope,
             collectionKey: collection,
             ...paging.value,
+            ...query.value,
             ...(status === undefined ? {} : { status: status.data }),
             ...(assigneeSubject === undefined ? {} : { assigneeSubject }),
             includeDeleted: url.searchParams.get('includeDeleted') === 'true',
@@ -226,8 +308,12 @@ export async function handleManagedRecords(req, res, url, ref, deps) {
         const authorized = await requireInstallationPermission(res, ref, identity, 'records:create', deps);
         if (authorized === undefined)
             return;
-        if (!collectionEnabled(res, authorized.installation, collection))
+        const definition = enabledCollection(res, authorized.installation, collection);
+        if (definition === undefined)
             return;
+        if (definition.authority.authority === 'external') {
+            return unsupportedExternalOperation(res, 'create');
+        }
         const idempotencyKey = requestIdempotencyKey(req);
         if (idempotencyKey === undefined) {
             return sendJson(res, 400, { error: 'Idempotency-Key header is required (1-128 characters)' });
@@ -238,19 +324,25 @@ export async function handleManagedRecords(req, res, url, ref, deps) {
         const parsed = ManagedRecordCreateRequestSchema.safeParse(body.value);
         if (!parsed.success)
             return invalid(res, parsed.error);
-        const payload = profilePayload(res, authorized.installation, collection, parsed.data.payload);
-        if (payload === undefined)
-            return;
-        const result = await deps.store.createRequest({
-            scope: authorized.installation.scope,
-            collectionKey: collection,
+        const result = await createNativeRecord(res, deps, {
+            installation: authorized.installation,
+            collection,
             idempotencyKey,
-            payload,
+            payload: parsed.data.payload,
             origin: { kind: 'portal' },
             actorSubject: identity.subject,
+            admit: () => admitBusinessMutation(res, authorized.scope),
         });
+        if (result === undefined)
+            return;
         if (result.disposition === 'conflict')
             return idempotencyConflict(res);
+        if (result.disposition === 'paused') {
+            return sendJson(res, 503, {
+                error: 'Record creation requires an active application.',
+                code: 'application_unavailable',
+            });
+        }
         return sendJson(res, result.disposition === 'created' ? 201 : 200, {
             ok: true,
             data: { record: recordToWire(result.record) },
@@ -260,12 +352,30 @@ export async function handleManagedRecords(req, res, url, ref, deps) {
         const authorized = await requireInstallationPermission(res, ref, identity, 'records:read', deps);
         if (authorized === undefined)
             return;
-        if (!collectionEnabled(res, authorized.installation, collection))
+        const definition = enabledCollection(res, authorized.installation, collection);
+        if (definition === undefined)
             return;
+        if (definition.authority.authority === 'external') {
+            const loaded = await loadExternalRecord(authorized.installation, definition, ref.recordId, deps);
+            if (loaded === undefined)
+                return sendJson(res, 503, { error: 'collection source unavailable' });
+            if (loaded.record === undefined)
+                return sendJson(res, 404, { error: 'record not found' });
+            return sendJson(res, 200, {
+                ok: true,
+                data: {
+                    record: externalRecordToWire(loaded.record, loaded.binding),
+                    collection: collectionToWire(definition),
+                },
+            });
+        }
         const record = await deps.store.getRequest(authorized.installation.scope, collection, ref.recordId);
         if (record === undefined)
             return sendJson(res, 404, { error: 'record not found' });
-        return sendJson(res, 200, { ok: true, data: { record: recordToWire(record) } });
+        return sendJson(res, 200, {
+            ok: true,
+            data: recordDetailToWire(authorized.installation, record),
+        });
     }
     if (ref.recordId !== undefined && req.method === 'PATCH') {
         const body = await readJsonBody(req, deps.maxBody);
@@ -278,20 +388,31 @@ export async function handleManagedRecords(req, res, url, ref, deps) {
         const authorized = await requireInstallationPermission(res, ref, identity, permission, deps);
         if (authorized === undefined)
             return;
-        if (!collectionEnabled(res, authorized.installation, collection))
+        const definition = enabledCollection(res, authorized.installation, collection);
+        if (definition === undefined)
             return;
+        if (definition.authority.authority === 'external') {
+            return unsupportedExternalOperation(res, parsed.data.operation);
+        }
+        if (parsed.data.operation === 'migrate-schema') {
+            const result = await deps.store.migrateLegacyRequest({
+                scope: authorized.installation.scope,
+                collectionKey: collection,
+                id: ref.recordId,
+                expectedRevision: parsed.data.expectedRevision,
+                actorSubject: identity.subject,
+            });
+            if (!result.ok)
+                return mutationFailure(res, result);
+            return sendJson(res, 200, { ok: true, data: { record: recordToWire(result.record) } });
+        }
         let operation;
         if (parsed.data.operation === 'update') {
-            const current = await deps.store.getRequest(authorized.installation.scope, collection, ref.recordId);
-            if (current?.content === undefined)
-                return sendJson(res, 404, { error: 'record not found' });
-            const payload = profilePayload(res, authorized.installation, collection, {
-                ...current.content.payload,
-                ...parsed.data.patch,
-            });
-            if (payload === undefined)
-                return;
-            operation = { kind: 'update', payload };
+            operation = {
+                kind: 'update',
+                payload: parsed.data.patch,
+                ...(parsed.data.unset ? { unset: parsed.data.unset } : {}),
+            };
         }
         else if (parsed.data.operation === 'assign') {
             if (parsed.data.assigneeSubject !== null) {
@@ -316,14 +437,23 @@ export async function handleManagedRecords(req, res, url, ref, deps) {
         else {
             operation = { kind: 'add_note', note: parsed.data.note };
         }
-        const result = await deps.store.mutateRequest({
-            scope: authorized.installation.scope,
-            collectionKey: collection,
-            id: ref.recordId,
-            expectedRevision: parsed.data.expectedRevision,
-            actorSubject: identity.subject,
-            operation,
-        });
+        let result;
+        try {
+            result = await deps.store.mutateRequest({
+                scope: authorized.installation.scope,
+                collectionKey: collection,
+                id: ref.recordId,
+                expectedRevision: parsed.data.expectedRevision,
+                actorSubject: identity.subject,
+                operation,
+            });
+        }
+        catch (error) {
+            if (error instanceof PayloadValidationError) {
+                return sendJson(res, 400, { error: error.message, code: error.code });
+            }
+            throw error;
+        }
         if (!result.ok)
             return mutationFailure(res, result);
         return sendJson(res, 200, { ok: true, data: { record: recordToWire(result.record) } });
@@ -332,7 +462,8 @@ export async function handleManagedRecords(req, res, url, ref, deps) {
         const authorized = await requireInstallationPermission(res, ref, identity, 'records:delete', deps);
         if (authorized === undefined)
             return;
-        if (!collectionEnabled(res, authorized.installation, collection))
+        const definition = enabledCollection(res, authorized.installation, collection);
+        if (definition === undefined)
             return;
         const body = await readJsonBody(req, deps.maxBody);
         if (!body.ok)
@@ -341,6 +472,37 @@ export async function handleManagedRecords(req, res, url, ref, deps) {
         if (revision === undefined) {
             return sendJson(res, 400, { error: 'expectedRevision must be a positive integer' });
         }
+        if (definition.authority.authority === 'external') {
+            const loaded = await loadExternalRecord(authorized.installation, definition, ref.recordId, deps);
+            if (loaded === undefined)
+                return sendJson(res, 503, { error: 'collection source unavailable' });
+            if (loaded.record === undefined)
+                return sendJson(res, 404, { error: 'record not found' });
+            const { record } = loaded;
+            if (record.revision !== revision) {
+                return sendJson(res, 409, {
+                    error: 'record revision conflict',
+                    code: 'revision_conflict',
+                    currentRevision: record.revision,
+                });
+            }
+            await deps.sourceStore?.suppressExternalRecord({
+                ...sourceBindingKey(authorized.installation, definition),
+                sourceId: record.source.id,
+                reason: 'customer_request',
+                now: now(deps),
+            });
+            const deletedAt = now(deps).toISOString();
+            return sendJson(res, 200, {
+                ok: true,
+                data: {
+                    recordId: record.id,
+                    authority: 'external',
+                    disposition: 'suppressed',
+                    deletedAt,
+                },
+            });
+        }
         const result = await deps.store.deleteRequest({
             scope: authorized.installation.scope,
             collectionKey: collection,
@@ -351,72 +513,22 @@ export async function handleManagedRecords(req, res, url, ref, deps) {
         });
         if (!result.ok)
             return mutationFailure(res, result);
-        return sendJson(res, 200, {
-            ok: true,
-            data: { recordId: result.record.id, deletedAt: result.record.deletedAt },
-        });
-    }
-    return methodNotAllowed(res);
-}
-export async function handlePublicSolutionIntake(req, res, ref, deps) {
-    const installation = await deps.store.resolveInstallationByPublicId(ref.publicId);
-    if (installation === undefined)
-        return sendJson(res, 404, { error: 'solution not found' });
-    const profile = BUILT_IN_SOLUTION_PROFILES[installation.profileKey];
-    if (req.method === 'GET' && ref.collection === undefined) {
-        const wire = profileToWire(profile);
         return sendJson(res, 200, {
             ok: true,
             data: {
-                publicId: installation.publicId,
-                title: wire.title,
-                description: wire.description,
-                collection: wire.collection,
+                recordId: result.record.id,
+                authority: 'native',
+                disposition: 'deleted',
+                deletedAt: result.record.deletedAt,
             },
         });
     }
-    if (req.method === 'POST' && ref.collection !== undefined) {
-        if (!collectionEnabled(res, installation, ref.collection))
-            return;
-        const quota = await consumePublicIntakeQuota(req, ref.publicId, deps);
-        if (!quota.allowed) {
-            res.setHeader('retry-after', String(Math.max(1, Math.ceil((quota.resetAt.getTime() - now(deps).getTime()) / 1000))));
-            return sendJson(res, 429, { error: 'public intake limit exceeded', code: 'quota_exceeded' });
-        }
-        const idempotencyKey = requestIdempotencyKey(req);
-        if (idempotencyKey === undefined) {
-            return sendJson(res, 400, { error: 'Idempotency-Key header is required (1-128 characters)' });
-        }
-        const body = await readJsonBody(req, deps.maxBody);
-        if (!body.ok)
-            return sendJson(res, body.status, { error: body.error });
-        const parsed = ManagedRecordCreateRequestSchema.safeParse(body.value);
-        if (!parsed.success)
-            return invalid(res, parsed.error);
-        const payload = profilePayload(res, installation, ref.collection, parsed.data.payload);
-        if (payload === undefined)
-            return;
-        const result = await deps.store.createRequest({
-            scope: installation.scope,
-            collectionKey: ref.collection,
-            idempotencyKey,
-            payload,
-            origin: { kind: 'embedded', reference: 'public-intake' },
-            actorSubject: 'anonymous',
-        });
-        if (result.disposition === 'conflict')
-            return idempotencyConflict(res);
-        return sendJson(res, result.disposition === 'created' ? 201 : 200, {
-            ok: true,
-            data: { recordId: result.record.id, receivedAt: result.record.createdAt },
-        });
-    }
     return methodNotAllowed(res);
 }
-async function requireIdentity(req, res, deps) {
-    return authorizeControlPlane(req, res, deps.gate, { requireIdentity: true });
+export async function requireIdentity(req, res, deps) {
+    return authorizeBusinessApi(req, res, deps);
 }
-async function requireInstallationGrant(res, ref, identity, deps) {
+export async function requireInstallationGrant(res, ref, identity, deps, permission) {
     if (ref.installationId === undefined)
         return undefined;
     const installation = await deps.store.getInstallationById(ref.org, ref.installationId);
@@ -429,59 +541,21 @@ async function requireInstallationGrant(res, ref, identity, deps) {
         sendForbidden(res, 'business grant required');
         return undefined;
     }
-    return { installation, scope: installation.scope, grant };
-}
-async function requireInstallationPermission(res, ref, identity, permission, deps) {
-    const authorized = await requireInstallationGrant(res, ref, identity, deps);
-    if (authorized === undefined)
-        return undefined;
-    if (!businessGrantAllows(authorized.grant, permission)) {
+    if (permission && !businessGrantAllows(grant, permission)) {
         sendForbidden(res, `business permission required: ${permission}`);
         return undefined;
     }
-    return authorized;
-}
-function stableInstallationId(org, app, env) {
-    return `ins-${createHash('sha256').update(`${org}\0${app}\0${env}`).digest('hex').slice(0, 24)}`;
-}
-function requestIdempotencyKey(req) {
-    const value = req.headers['idempotency-key'];
-    if (typeof value !== 'string' || value.length < 1 || value.length > 128)
+    if (!(await admitBusinessTarget(res, installation.scope)))
         return undefined;
-    return value;
-}
-function expectedRevision(value) {
-    if (value === null || typeof value !== 'object')
-        return undefined;
-    const revision = value.expectedRevision;
-    return typeof revision === 'number' && Number.isInteger(revision) && revision > 0
-        ? revision
-        : undefined;
-}
-function parsePaging(url, maximum) {
-    const cursor = url.searchParams.get('cursor') ?? undefined;
-    const rawLimit = url.searchParams.get('limit');
-    if (rawLimit === null)
-        return { ok: true, value: cursor === undefined ? {} : { cursor } };
-    const limit = Number(rawLimit);
-    if (!Number.isInteger(limit) || limit < 1 || limit > maximum) {
-        return { ok: false, error: `limit must be an integer from 1 to ${maximum}` };
-    }
-    return { ok: true, value: { ...(cursor === undefined ? {} : { cursor }), limit } };
+    return { installation, scope: installation.scope, grant };
 }
-function mutationPermission(operation) {
-    if (operation === 'assign')
-        return 'records:assign';
-    if (operation === 'set-status')
-        return 'records:status';
-    if (operation === 'add-note')
-        return 'records:note';
-    return 'records:update';
+export async function requireInstallationPermission(res, ref, identity, permission, deps) {
+    return requireInstallationGrant(res, ref, identity, deps, permission);
 }
-function mutationFailure(res, result) {
+export function mutationFailure(res, result) {
     const status = result.reason === 'not_found'
         ? 404
-        : result.reason === 'conflict' || result.reason === 'last_administrator'
+        : ['conflict', 'last_administrator', 'application_unavailable'].includes(result.reason)
             ? 409
             : 422;
     sendJson(res, status, {
@@ -490,62 +564,29 @@ function mutationFailure(res, result) {
         currentRevision: result.currentRevision,
     });
 }
-function collectionEnabled(res, installation, collection) {
-    if (installation.managedCollections.includes(collection))
-        return true;
-    sendJson(res, 404, { error: 'collection not found' });
-    return false;
-}
-function profilePayload(res, installation, collection, value) {
-    try {
-        return validateProfilePayload(installation.profileKey, collection, value);
-    }
-    catch (error) {
-        if (!(error instanceof PayloadValidationError))
-            throw error;
-        sendJson(res, 400, { error: error.message, code: error.code });
-        return undefined;
-    }
-}
-async function cursorRequest(res, request) {
+export function enabledCollection(res, installation, collection) {
     try {
-        return await request();
+        return validateCollectionEnabled(installation, collection);
     }
-    catch (error) {
-        if (!(error instanceof CursorValidationError))
-            throw error;
-        sendJson(res, 400, { error: 'cursor is invalid', code: 'invalid_cursor' });
+    catch {
+        sendJson(res, 404, { error: 'collection not found' });
         return undefined;
     }
 }
-async function consumePublicIntakeQuota(req, publicId, deps) {
-    const timestamp = now(deps);
-    const address = deps.trustProxy
-        ? typeof req.headers['x-forwarded-for'] === 'string'
-            ? req.headers['x-forwarded-for']
-            : undefined
-        : req.socket.remoteAddress;
-    const bucket = clientAddressBucket(address);
-    if (bucket !== undefined) {
-        const addressOutcome = await deps.publicCounters.consume({ key: `solution-intake:address:${publicId}:${bucket}`, limit: 60, window: 'hour' }, timestamp);
-        if (!addressOutcome.allowed)
-            return addressOutcome;
-    }
-    return deps.publicCounters.consume({ key: `solution-intake:surface:${publicId}`, limit: 10_000, window: 'day' }, timestamp);
-}
-function now(deps) {
+export function now(deps) {
     return deps.now?.() ?? new Date();
 }
-function invalid(res, error) {
+export function invalid(res, error) {
     sendJson(res, 400, { error: formatWireError(error) });
 }
-function idempotencyConflict(res) {
+export function idempotencyConflict(res) {
     sendJson(res, 409, {
         error: 'the idempotency key was already used with different content',
         code: 'idempotency_conflict',
     });
 }
-function methodNotAllowed(res) {
+export function methodNotAllowed(res) {
     sendJson(res, 405, { error: 'method not allowed' });
 }
+export { createNativeRecord } from './business-information-record-create.js';
 //# sourceMappingURL=business-information.js.map

package/node_modules/@noodle-borg/service/dist/routes/config-values-dispatch.js

@@ -25,7 +25,7 @@ export function dispatchConfigValueRequest(req, res, url, deps) {
     deps.applySecurityHeaders(res, deps.tls);
     if (deps.enforceHttps(req, res, deps.tls))
         return true;
-    handleConfigValues(req, res, deps.gate, deps.controlPlane, deps.configStore, deps.registry, deps.maxBody, ref, deps.audit, deps.developerGrants).catch(() => {
+    handleConfigValues(req, res, deps.gate, deps.controlPlane, deps.configStore, deps.registry, deps.maxBody, ref, deps.audit, deps.developerGrants, deps.installations).catch(() => {
         if (!res.headersSent)
             deps.sendJson(res, 500, { error: 'internal error' });
     });