@noodleseed/one 0.162.0 → 0.163.0

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

@@ -0,0 +1,151 @@
+import { publicAdmissionRequestDigest } from '@noodle-borg/admission-limits/portable';
+import { readJsonBody, sendJson } from '@noodle-borg/transport-http';
+import { ManagedRecordCreateRequestSchema } from '@noodle-borg/wire-contracts';
+import { creationPayload } from '../business-information/collection-controls.js';
+import { idempotencyDigest, PayloadValidationError, requestFingerprint, validateManagedPayload, } from '../business-information/portable.js';
+import { createNativeRecord, idempotencyConflict, invalid, methodNotAllowed, now, } from './business-information.js';
+import { consumePublicIntakeQuota } from './business-information-admission.js';
+import { requestIdempotencyKey } from './business-information-request.js';
+import { collectionToPublicWire } from './business-information-wire.js';
+const MAX_PUBLIC_INTAKE_BODY_BYTES = 32 * 1024;
+/** Anonymous, quota-bound creation for an installation's explicitly enabled native collection. */
+export async function handlePublicSolutionIntake(req, res, ref, deps) {
+    if (deps.publicIntakeEnabled === false) {
+        return sendJson(res, 503, {
+            error: 'public intake is temporarily disabled',
+            code: 'intake_disabled',
+        });
+    }
+    const installation = await deps.store.resolveInstallationByPublicId(ref.publicId);
+    if (installation === undefined)
+        return sendJson(res, 404, { error: 'solution not found' });
+    if (deps.businessOnboarding && !(await deps.businessOnboarding.ready(installation)))
+        return sendJson(res, 409, {
+            code: 'business_setup_required',
+            error: 'This business has not completed application setup.',
+        });
+    if (!installation.intakeActive && req.method === 'GET') {
+        return sendJson(res, 503, { error: 'public intake is paused', code: 'intake_paused' });
+    }
+    const publicCollection = installation.definition.collections.find((candidate) => installation.managedCollections.includes(candidate.key) &&
+        candidate.authority.authority === 'native');
+    if (req.method === 'GET' && ref.collection === undefined) {
+        const notice = await deps.store.getBusinessNotice(installation.scope);
+        if (publicCollection === undefined)
+            return sendJson(res, 404, { error: 'public intake unavailable' });
+        return sendJson(res, 200, {
+            ok: true,
+            data: {
+                publicId: installation.publicId,
+                ...(notice ? { businessNotice: notice.notice } : {}),
+                title: installation.definition.title,
+                description: installation.definition.description.slice(0, 240),
+                collection: collectionToPublicWire(publicCollection),
+            },
+        });
+    }
+    if (req.method === 'POST' && ref.collection !== undefined) {
+        if (publicCollection === undefined || publicCollection.key !== ref.collection) {
+            return sendJson(res, 404, { error: 'public intake unavailable' });
+        }
+        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, Math.min(deps.maxBody, MAX_PUBLIC_INTAKE_BODY_BYTES));
+        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);
+        let payload;
+        try {
+            creationPayload(publicCollection, parsed.data.payload, true);
+            payload = validateManagedPayload(parsed.data.payload);
+        }
+        catch (error) {
+            if (!(error instanceof PayloadValidationError))
+                throw error;
+            return sendJson(res, 400, {
+                error: error.message,
+                code: error.code,
+            });
+        }
+        const origin = { kind: 'embedded', reference: 'public-intake' };
+        const requestInput = {
+            scope: installation.scope,
+            collectionKey: ref.collection,
+            idempotencyKey,
+            payload,
+            origin,
+            actorSubject: 'anonymous',
+        };
+        const completed = await deps.store.probeRequest(requestInput);
+        if (completed.disposition === 'conflict')
+            return idempotencyConflict(res);
+        if (completed.disposition === 'replayed') {
+            return sendJson(res, 200, {
+                ok: true,
+                data: { recordId: completed.record.id, receivedAt: completed.record.createdAt },
+            });
+        }
+        const quota = await consumePublicIntakeQuota(req, ref.publicId, {
+            key: `solution-intake:logical:${ref.publicId}:${idempotencyDigest(idempotencyKey)}`,
+            fingerprint: requestFingerprint({
+                collectionKey: ref.collection,
+                payload,
+                origin,
+                actorSubject: 'anonymous',
+            }),
+        }, deps, {
+            surfaceId: ref.publicId,
+            installationId: installation.scope.installationId,
+            route: new URL(req.url ?? '/', 'http://localhost').pathname,
+            method: 'POST',
+            idempotencyKey,
+            requestDigest: publicAdmissionRequestDigest(JSON.stringify(body.value)),
+        });
+        if (!quota.allowed) {
+            if (quota.reason === 'invalid_attribution')
+                return sendJson(res, 403, {
+                    error: 'public admission attribution is invalid',
+                    code: 'invalid_attribution',
+                });
+            if (quota.reason === 'admission_unavailable') {
+                return sendJson(res, 503, {
+                    error: 'public intake admission is temporarily unavailable',
+                    code: 'admission_unavailable',
+                });
+            }
+            if (quota.reason === 'idempotency_conflict')
+                return idempotencyConflict(res);
+            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',
+                limits: quota.limits.map((limit) => ({ ...limit, resetAt: limit.resetAt.toISOString() })),
+            });
+        }
+        const result = await createNativeRecord(res, deps, {
+            installation,
+            collection: requestInput.collectionKey,
+            idempotencyKey: requestInput.idempotencyKey,
+            payload: requestInput.payload,
+            origin: requestInput.origin,
+            actorSubject: requestInput.actorSubject,
+        });
+        if (result === undefined)
+            return;
+        if (result.disposition === 'conflict')
+            return idempotencyConflict(res);
+        if (result.disposition === 'paused') {
+            return sendJson(res, 503, { error: 'public intake is paused', code: 'intake_paused' });
+        }
+        return sendJson(res, result.disposition === 'created' ? 201 : 200, {
+            ok: true,
+            data: { recordId: result.record.id, receivedAt: result.record.createdAt },
+        });
+    }
+    return methodNotAllowed(res);
+}
+//# sourceMappingURL=business-information-public.js.map

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

@@ -0,0 +1,15 @@
+import { sendJson } from '@noodle-borg/transport-http';
+import { proveManagedReaderFloor } from '../business-information/reader-floor.js';
+import { authorizeControlPlane } from './control-plane.js';
+/** Release-only compatibility proof. The response exposes counts and a digest, never tenant identities. */
+export async function handleBusinessInformationReaderFloor(req, res, deps) {
+    if (req.method !== 'GET') {
+        return sendJson(res, 405, { error: 'method not allowed' });
+    }
+    const identity = await authorizeControlPlane(req, res, deps.gate, { requireIdentity: true });
+    if (identity === false)
+        return;
+    const proof = await proveManagedReaderFloor(deps.store);
+    sendJson(res, 200, { ok: true, ...proof });
+}
+//# sourceMappingURL=business-information-reader-floor.js.map

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

@@ -0,0 +1,29 @@
+import { sendJson } from '@noodle-borg/transport-http';
+import { PayloadValidationError, } from '../business-information/portable.js';
+export async function createNativeRecord(res, deps, input) {
+    try {
+        const request = {
+            scope: input.installation.scope,
+            collectionKey: input.collection,
+            idempotencyKey: input.idempotencyKey,
+            payload: input.payload,
+            origin: input.origin,
+            actorSubject: input.actorSubject,
+        };
+        if (input.admit) {
+            const receipt = await deps.store.probeRequest(request);
+            if (receipt.disposition !== 'missing')
+                return receipt;
+            if (!(await input.admit()))
+                return undefined;
+        }
+        return await deps.store.createRequest(request);
+    }
+    catch (error) {
+        if (!(error instanceof PayloadValidationError))
+            throw error;
+        sendJson(res, 400, { error: error.message, code: error.code });
+        return undefined;
+    }
+}
+//# sourceMappingURL=business-information-record-create.js.map

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

@@ -0,0 +1,36 @@
+import { sendJson } from '@noodle-borg/transport-http';
+import { NativeQueryError } from '../business-information/native-query.js';
+import { CursorValidationError } from '../business-information/validation.js';
+import { parseBusinessPaging } from './business-information-request.js';
+import { activityToWire } from './business-information-wire.js';
+export async function sendNativeRecordActivity(res, url, scope, collection, id, store) {
+    const paging = parseBusinessPaging(url, 100);
+    if (!paging.ok)
+        return sendJson(res, 400, { error: paging.error });
+    const history = await cursorRequest(res, () => store.listActivity(scope, collection, id, paging.value));
+    if (history === undefined)
+        return;
+    return sendJson(res, 200, {
+        ok: true,
+        data: { ...history, activities: history.activities.map(activityToWire) },
+    });
+}
+export async function cursorRequest(res, request) {
+    try {
+        return await request();
+    }
+    catch (error) {
+        if (error instanceof NativeQueryError) {
+            sendJson(res, error.code === 'query_limit_exceeded' ? 422 : 400, {
+                error: error.message,
+                code: error.code,
+            });
+            return undefined;
+        }
+        if (!(error instanceof CursorValidationError))
+            throw error;
+        sendJson(res, 400, { error: 'cursor is invalid', code: 'invalid_cursor' });
+        return undefined;
+    }
+}
+//# sourceMappingURL=business-information-record-reads.js.map

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

@@ -0,0 +1,64 @@
+import { ManagedRecordQuerySchema } from '@noodle-borg/wire-contracts';
+export function mutationPermission(operation) {
+    if (operation === 'migrate-schema')
+        return 'installation:administer';
+    if (operation === 'assign')
+        return 'records:assign';
+    if (operation === 'set-status')
+        return 'records:status';
+    if (operation === 'add-note')
+        return 'records:note';
+    return 'records:update';
+}
+export function requestIdempotencyKey(req) {
+    const value = req.headers['idempotency-key'];
+    if (typeof value !== 'string' || value.length < 1 || value.length > 128)
+        return undefined;
+    return value;
+}
+export 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;
+}
+export function parseBusinessPaging(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 } };
+}
+export function parseNativeRecordQuery(url) {
+    try {
+        const raw = {};
+        for (const key of ['filters', 'sortField', 'sortDirection', 'createdAtFrom', 'createdAtTo']) {
+            const values = url.searchParams.getAll(key);
+            if (values.length > 1)
+                throw new Error();
+            const value = values[0];
+            if (value === undefined)
+                continue;
+            if (value.length > 32768)
+                throw new Error();
+            raw[key] = key === 'filters' ? JSON.parse(value) : value;
+        }
+        const parsed = ManagedRecordQuerySchema.safeParse(raw);
+        if (!parsed.success)
+            throw new Error();
+        return { ok: true, value: parsed.data };
+    }
+    catch {
+        return {
+            ok: false,
+            error: 'Invalid collection query. Use declared scalar filters, sort fields and valid creation date bounds.',
+        };
+    }
+}
+//# sourceMappingURL=business-information-request.js.map

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

@@ -0,0 +1,64 @@
+import { readJsonBody, sendJson } from '@noodle-borg/transport-http';
+import { ApplicationSettingsResponseSchema, ApplicationSettingsSaveRequestSchema, } from '@noodle-borg/wire-contracts';
+import { ApplicationSettings, installationSettingsTarget, SettingsError, } from '../application-settings.js';
+import { resolveSettingsTargets } from '../application-settings-targets.js';
+import { businessGrantAllows } from '../business-information/model.js';
+import { requireIdentity, requireInstallationPermission, } from './business-information.js';
+export async function handleBusinessSettings(req, res, ref, deps) {
+    if (req.method !== 'GET' && req.method !== 'PATCH') {
+        res.setHeader('allow', 'GET, PATCH');
+        return sendJson(res, 405, { error: 'method not allowed' });
+    }
+    const identity = await requireIdentity(req, res, deps);
+    if (identity === false)
+        return;
+    const authorized = await requireInstallationPermission(res, ref, identity, req.method === 'PATCH' ? 'installation:administer' : 'records:read', deps);
+    if (authorized === undefined)
+        return;
+    if (deps.configStore?.transactConfig === undefined)
+        return sendJson(res, 503, {
+            code: 'settings_unavailable',
+            error: 'Atomic configuration storage is unavailable.',
+        });
+    const target = installationSettingsTarget(authorized.installation);
+    const settings = new ApplicationSettings(deps.configStore);
+    const canEdit = businessGrantAllows(authorized.grant, 'installation:administer');
+    res.setHeader('cache-control', 'private, no-store');
+    try {
+        if (req.method === 'GET') {
+            await settings.initialize(target);
+            return sendJson(res, 200, ApplicationSettingsResponseSchema.parse({
+                ok: true,
+                data: await settings.read(target, canEdit),
+            }));
+        }
+        const body = await readJsonBody(req, deps.maxBody);
+        if (!body.ok)
+            return sendJson(res, body.status, { error: body.error });
+        const parsed = ApplicationSettingsSaveRequestSchema.safeParse(body.value);
+        if (!parsed.success)
+            return sendJson(res, 400, { code: 'settings_invalid', error: 'Invalid settings update.' });
+        const registry = deps.registry;
+        const data = await settings.save(target, parsed.data, identity.subject, registry ? () => resolveSettingsTargets(registry, target.scope, deps.store) : undefined);
+        await deps.audit?.emit({
+            eventType: 'config.variable.business_settings_changed',
+            org: authorized.scope.org,
+            app: authorized.scope.app,
+            env: authorized.scope.env,
+            actorSubject: identity.subject,
+            details: {
+                revision: data.revision,
+                changedKeys: [...Object.keys(parsed.data.values), ...(parsed.data.resetKeys ?? [])]
+                    .sort()
+                    .join(','),
+            },
+        });
+        sendJson(res, 200, ApplicationSettingsResponseSchema.parse({ ok: true, data }));
+    }
+    catch (error) {
+        if (!(error instanceof SettingsError))
+            throw error;
+        sendJson(res, error.code === 'settings_conflict' ? 409 : error.code === 'settings_unavailable' ? 503 : 400, { code: error.code, error: error.message });
+    }
+}
+//# sourceMappingURL=business-information-settings.js.map

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

@@ -0,0 +1,249 @@
+import { createHash } from 'node:crypto';
+import { readJsonBody, sendJson } from '@noodle-borg/transport-http';
+import { CollectionSourceConfigureRequestSchema, CollectionSourceRefreshRequestSchema, CollectionSourceRevisionRequestSchema, } from '@noodle-borg/wire-contracts';
+import { SourceCapacityError } from '../business-information/source-custody-budget.js';
+import { sourceOperationSignatureDigest } from '../business-information/source-ingestion-validation.js';
+import { enabledCollection, invalid, methodNotAllowed, mutationFailure, now, requireIdentity, requireInstallationPermission, } from './business-information.js';
+/** Operate a collection's generic external source without introducing provider-specific routes. */
+export async function handleCollectionSource(req, res, ref, deps) {
+    const identity = await requireIdentity(req, res, deps);
+    if (identity === false)
+        return;
+    const sourcePermission = req.method === 'GET'
+        ? 'records:read'
+        : ref.sourceAction === 'refresh'
+            ? 'records:update'
+            : 'installation:administer';
+    const authorized = await requireInstallationPermission(res, ref, identity, sourcePermission, deps);
+    if (authorized === undefined || ref.collection === undefined)
+        return;
+    const collection = enabledCollection(res, authorized.installation, ref.collection);
+    if (collection === undefined)
+        return;
+    if (collection.authority.authority !== 'external') {
+        return sendJson(res, 405, {
+            error: 'native collections do not have source controls',
+            code: 'operation_not_supported',
+        });
+    }
+    if (deps.sourceStore === undefined) {
+        return sendJson(res, 503, { error: 'collection source persistence is unavailable' });
+    }
+    const key = sourceBindingKey(authorized.installation, collection);
+    const current = await deps.sourceStore.getBinding(key);
+    if (ref.sourceAction === undefined && req.method === 'GET') {
+        return sendJson(res, 200, {
+            ok: true,
+            data: { source: collectionSourceToWire(authorized.installation, collection, current) },
+        });
+    }
+    if (ref.sourceAction === undefined && req.method === 'PATCH') {
+        const definitionReference = authorized.installation.definition.reference;
+        if (definitionReference.kind === 'private' &&
+            authorized.installation.scope.org !== definitionReference.publisherOrg) {
+            return sendJson(res, 409, {
+                error: 'cross-organization source account binding is unavailable',
+                code: 'source_cross_org_binding_unavailable',
+            });
+        }
+        const body = await readJsonBody(req, deps.maxBody);
+        if (!body.ok)
+            return sendJson(res, body.status, { error: body.error });
+        const parsed = CollectionSourceConfigureRequestSchema.safeParse(body.value);
+        if (!parsed.success)
+            return invalid(res, parsed.error);
+        const expected = current?.revision ?? authorized.installation.revision;
+        if (parsed.data.expectedRevision !== expected) {
+            return sendJson(res, 409, {
+                error: 'source revision conflict',
+                code: 'revision_conflict',
+                currentRevision: expected,
+            });
+        }
+        const bindingInput = {
+            ...key,
+            bindingReference: parsed.data.binding.reference,
+            configurationReference: parsed.data.configurationReference,
+            generation: parsed.data.binding.generation,
+            schemaVersion: collection.schemaVersion,
+            schemaDigest: collection.schemaDigest.replace(/^sha256:/, ''),
+            queryFingerprint: createHash('sha256')
+                .update(parsed.data.binding.reference)
+                .update('\0')
+                .update(parsed.data.configurationReference)
+                .digest('hex'),
+            scan: {
+                connector: collection.authority.connectorId,
+                connectorVersion: collection.authority.connectorVersion,
+                operation: collection.authority.scanOperation,
+                signatureDigest: sourceOperationSignatureDigest(collection.authority.scanSignatureHash),
+            },
+            retentionDays: authorized.installation.retentionDays,
+            pollIntervalMs: 60_000,
+        };
+        let binding;
+        try {
+            if (current === undefined) {
+                if (parsed.data.replace === true) {
+                    return sendJson(res, 404, { error: 'source is not configured' });
+                }
+                binding = await deps.sourceStore.createBinding(bindingInput);
+            }
+            else {
+                if (parsed.data.replace !== true) {
+                    return sendJson(res, 409, {
+                        error: 'source replacement requires explicit replace consent',
+                        code: 'source_replacement_required',
+                        currentRevision: current.revision,
+                    });
+                }
+                const replaced = await deps.sourceStore.replaceBinding({
+                    ...bindingInput,
+                    expectedRevision: parsed.data.expectedRevision,
+                    now: now(deps),
+                });
+                if (!replaced.ok)
+                    return mutationFailure(res, replaced);
+                binding = replaced.binding;
+            }
+        }
+        catch (error) {
+            if (!isSourceConfigurationConflict(error))
+                throw error;
+            return sendJson(res, 409, {
+                error: 'source configuration conflict',
+                code: 'source_configuration_conflict',
+            });
+        }
+        return sendJson(res, current === undefined ? 201 : 200, {
+            ok: true,
+            data: { source: collectionSourceToWire(authorized.installation, collection, binding) },
+        });
+    }
+    if ((ref.sourceAction === 'pause' || ref.sourceAction === 'resume') && req.method === 'POST') {
+        const body = await readJsonBody(req, deps.maxBody);
+        if (!body.ok)
+            return sendJson(res, body.status, { error: body.error });
+        const parsed = CollectionSourceRevisionRequestSchema.safeParse(body.value);
+        if (!parsed.success)
+            return invalid(res, parsed.error);
+        const result = await deps.sourceStore.setBindingState({
+            ...key,
+            expectedRevision: parsed.data.expectedRevision,
+            state: ref.sourceAction === 'pause' ? 'paused' : 'active',
+            now: now(deps),
+        });
+        if (!result.ok)
+            return mutationFailure(res, result);
+        return sendJson(res, 200, {
+            ok: true,
+            data: {
+                source: collectionSourceToWire(authorized.installation, collection, result.binding),
+            },
+        });
+    }
+    if (ref.sourceAction === 'refresh' && req.method === 'POST') {
+        const body = await readJsonBody(req, deps.maxBody);
+        if (!body.ok)
+            return sendJson(res, body.status, { error: body.error });
+        const parsed = CollectionSourceRefreshRequestSchema.safeParse(body.value);
+        if (!parsed.success)
+            return invalid(res, parsed.error);
+        if (current === undefined)
+            return sendJson(res, 404, { error: 'source is not configured' });
+        const refresh = await deps.sourceStore.requestRefresh({
+            ...key,
+            expectedRevision: parsed.data.expectedRevision,
+            idempotencyKey: parsed.data.idempotencyKey,
+            now: now(deps),
+        });
+        if (!refresh.ok)
+            return mutationFailure(res, refresh);
+        const runSourceIngestion = deps.runSourceIngestion;
+        if (runSourceIngestion !== undefined) {
+            res.once('finish', () => {
+                setImmediate(() => void runSourceIngestion().catch(() => undefined));
+            });
+        }
+        sendJson(res, 202, {
+            ok: true,
+            data: {
+                source: collectionSourceToWire(authorized.installation, collection, refresh.binding),
+                job: refresh.receipt,
+            },
+        });
+        return;
+    }
+    return methodNotAllowed(res);
+}
+function isSourceConfigurationConflict(error) {
+    return (error instanceof Error &&
+        error.message === 'source binding already exists with different immutable configuration');
+}
+function sourceBindingKey(installation, collection) {
+    return {
+        scope: installation.scope,
+        collectionKey: collection.key,
+        id: collection.key,
+    };
+}
+function collectionSourceToWire(installation, collection, binding) {
+    const common = {
+        installationId: installation.scope.installationId,
+        collection: collection.key,
+        authority: 'external',
+    };
+    if (binding === undefined) {
+        return { ...common, revision: installation.revision, state: 'unconfigured' };
+    }
+    return {
+        ...common,
+        revision: binding.revision,
+        state: binding.state === 'paused'
+            ? 'paused'
+            : binding.health === 'failed' || binding.health === 'reauth_required'
+                ? 'error'
+                : 'active',
+        binding: {
+            reference: binding.bindingReference ?? binding.id,
+            generation: binding.generation,
+        },
+        configurationReference: binding.configurationReference ?? binding.id,
+        enabled: true,
+        health: binding.health === 'initializing'
+            ? 'pending'
+            : binding.health === 'current'
+                ? 'healthy'
+                : binding.health === 'stale'
+                    ? 'degraded'
+                    : binding.health === 'reauth_required'
+                        ? 'authorization_required'
+                        : binding.health === 'paused'
+                            ? 'paused'
+                            : 'unavailable',
+        completeness: binding.scanMode !== undefined
+            ? 'rebuilding'
+            : binding.completeness === 'complete'
+                ? 'complete'
+                : binding.lastSuccessfulSyncAt === undefined
+                    ? 'unknown'
+                    : 'partial',
+        ...(binding.lastSuccessfulSyncAt === undefined
+            ? {}
+            : { lastCompletedSyncAt: binding.lastSuccessfulSyncAt }),
+        ...(binding.nextAttemptAt === undefined ? {} : { nextRefreshAt: binding.nextAttemptAt }),
+        ...(binding.errorCode === undefined
+            ? {}
+            : {
+                error: {
+                    code: binding.errorCode,
+                    message: binding.errorCode === 'source_capacity_exceeded'
+                        ? new SourceCapacityError().message
+                        : 'The external source could not be refreshed.',
+                    retryable: binding.health !== 'reauth_required' &&
+                        binding.errorCode !== 'source_capacity_exceeded',
+                },
+            }),
+    };
+}
+//# sourceMappingURL=business-information-source.js.map