@noodleseed/one 0.162.0 → 0.164.0

package/node_modules/@noodle-borg/service/dist/application-settings.js

@@ -0,0 +1,210 @@
+import { canonicalJson, MAX_VARIABLE_VALUE_BYTES, sha256Canonical, validateJsonSchema, validateVariableDeclaration, } from '@noodle-borg/compiler';
+import { ApplicationSettingsProjectionSchema, ApplicationSettingsSaveRequestSchema, } from '@noodle-borg/wire-contracts';
+import { scopeChain, } from './store/config-values.js';
+export function installationSettingsTarget(installation) {
+    return {
+        scope: {
+            level: 'env',
+            org: installation.scope.org,
+            app: installation.scope.app,
+            env: installation.scope.env,
+        },
+        releaseDigest: installation.definition.reference.digest,
+        declarations: installation.definition.variables ?? [],
+    };
+}
+export class SettingsError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+    }
+}
+/** Business settings are a validated projection of the existing hierarchical config authority. */
+export class ApplicationSettings {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    async initialize(target) {
+        await this.transaction(target.scope.org, async (transaction) => {
+            const exact = await transaction.listConfigValues('variable', target.scope);
+            const existing = new Set(exact.map((entry) => entry.name));
+            for (const declaration of target.declarations) {
+                if (!Object.hasOwn(declaration, 'default') || existing.has(declaration.name))
+                    continue;
+                validateValue(declaration, declaration.default);
+                await transaction.setConfigValue({
+                    kind: 'variable',
+                    scope: target.scope,
+                    name: declaration.name,
+                    value: canonicalJson(declaration.default),
+                    valueOrigin: 'default',
+                });
+            }
+        });
+    }
+    read(target, canEdit) {
+        return this.transaction(target.scope.org, (transaction) => projectSettings(transaction, target, canEdit));
+    }
+    async save(target, request, actor, resolveTargets) {
+        const parsed = ApplicationSettingsSaveRequestSchema.safeParse(request);
+        if (!parsed.success)
+            throw new SettingsError('settings_invalid', 'Invalid settings update.');
+        return this.transaction(target.scope.org, async (transaction) => {
+            const targets = resolveTargets ? await resolveTargets() : [target];
+            if (!targets.some((entry) => withinScope(target.scope, entry.scope) &&
+                entry.releaseDigest === target.releaseDigest &&
+                sha256Canonical(entry.declarations) === sha256Canonical(target.declarations)))
+                throw new SettingsError('settings_conflict', 'Application release changed. Reload before saving.');
+            const current = await projectSettings(transaction, target, true);
+            if (current.revision !== request.expectedRevision ||
+                current.schemaDigest !== request.schemaDigest) {
+                throw new SettingsError('settings_conflict', 'Settings or application release changed. Reload before saving.');
+            }
+            const declarations = new Map(target.declarations
+                .filter((entry) => entry.portal !== undefined)
+                .map((entry) => [entry.name, entry]));
+            for (const [name, value] of Object.entries(request.values)) {
+                const declaration = declarations.get(name);
+                if (declaration === undefined)
+                    throw new SettingsError('settings_invalid', 'Setting is not exposed to this business.');
+                validateValue(declaration, value);
+                await transaction.setConfigValue({
+                    kind: 'variable',
+                    scope: target.scope,
+                    name,
+                    value: canonicalJson(value),
+                    updatedBySubject: actor,
+                });
+            }
+            for (const name of request.resetKeys ?? []) {
+                const declaration = declarations.get(name);
+                if (declaration === undefined)
+                    throw new SettingsError('settings_invalid', 'Setting is not exposed to this business.');
+                if (Object.hasOwn(declaration, 'default')) {
+                    await transaction.setConfigValue({
+                        kind: 'variable',
+                        scope: target.scope,
+                        name,
+                        value: canonicalJson(declaration.default),
+                        valueOrigin: 'default',
+                        updatedBySubject: actor,
+                    });
+                }
+                else {
+                    await transaction.deleteConfigValue('variable', target.scope, name);
+                }
+            }
+            for (const entry of targets)
+                if (withinScope(target.scope, entry.scope))
+                    await projectSettings(transaction, entry, false);
+            return projectSettings(transaction, target, true);
+        });
+    }
+    /** Technical API/CLI changes share validation and the same hierarchy transaction as Portal. */
+    writeTechnical(targets, input) {
+        return this.transaction(input.scope.org, async (transaction) => {
+            const currentTargets = typeof targets === 'function' ? await targets() : targets;
+            const affected = currentTargets.filter((target) => withinScope(input.scope, target.scope));
+            if (input.kind === 'variable' && input.value !== undefined) {
+                for (const target of affected) {
+                    const declaration = target.declarations.find((entry) => entry.name === input.name);
+                    if (declaration !== undefined)
+                        validateValue(declaration, decodeValue(input.value));
+                }
+            }
+            const result = input.value === undefined
+                ? await transaction.deleteConfigValue(input.kind, input.scope, input.name)
+                : await transaction.setConfigValue({ ...input, value: input.value });
+            if (input.kind === 'variable') {
+                // Includes reset/delete and changes inherited by multiple installed applications.
+                for (const target of affected)
+                    await projectSettings(transaction, target, false);
+            }
+            return result;
+        });
+    }
+    transaction(org, work) {
+        if (this.config.transactConfig === undefined)
+            throw new SettingsError('settings_unavailable', 'Atomic configuration storage is unavailable.');
+        return this.config.transactConfig(org, work);
+    }
+}
+async function projectSettings(config, target, canEdit) {
+    const rows = [];
+    for (const scope of scopeChain(target.scope))
+        rows.push(...(await config.listConfigValues('variable', scope)));
+    const declarations = target.declarations.filter((entry) => entry.portal !== undefined);
+    const declaredNames = new Set(target.declarations.map((entry) => entry.name));
+    const scopedRows = rows.filter((row) => declaredNames.has(row.name));
+    const values = {};
+    const provenance = {};
+    const missing = new Map();
+    for (const declaration of target.declarations) {
+        const { schemaDigest: _digest, ...manifest } = declaration;
+        if (validateVariableDeclaration(manifest).length > 0)
+            throw new SettingsError('settings_invalid', 'Application has an invalid setting declaration.');
+        const candidates = scopedRows.filter((row) => row.name === declaration.name);
+        const chosen = candidates.filter((row) => row.valueOrigin !== 'default').at(-1) ?? candidates.at(-1);
+        const value = chosen?.value === undefined ? declaration.default : decodeValue(chosen.value);
+        if (value !== undefined)
+            validateValue(declaration, value);
+        if (declaration.portal !== undefined) {
+            if (value !== undefined)
+                values[declaration.name] = value;
+            provenance[declaration.name] =
+                chosen?.valueOrigin === 'default' || (chosen === undefined && value !== undefined)
+                    ? 'default'
+                    : chosen?.scope.level === 'org'
+                        ? 'organization'
+                        : chosen?.scope.level === 'app'
+                            ? 'app'
+                            : chosen !== undefined
+                                ? 'operator'
+                                : 'unset';
+            for (const tool of declaration.requiredFor) {
+                const names = missing.get(tool) ?? [];
+                if (value === undefined)
+                    names.push(declaration.name);
+                missing.set(tool, names);
+            }
+        }
+    }
+    const schemaDigest = sha256Canonical(target.declarations);
+    return ApplicationSettingsProjectionSchema.parse({
+        revision: sha256Canonical({ release: target.releaseDigest, schemaDigest, rows: scopedRows }),
+        schemaDigest,
+        releaseDigest: target.releaseDigest,
+        declarations,
+        values,
+        provenance,
+        readiness: [...missing.entries()]
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([tool, names]) => ({ tool, ready: names.length === 0, missing: names })),
+        canEdit,
+    });
+}
+function decodeValue(value) {
+    if (Buffer.byteLength(value) > MAX_VARIABLE_VALUE_BYTES)
+        throw new SettingsError('settings_invalid', 'Setting exceeds the maximum value size.');
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        throw new SettingsError('settings_invalid', 'Declared setting values must be encoded as JSON.');
+    }
+}
+function validateValue(declaration, value) {
+    const serialized = canonicalJson(value);
+    if (Buffer.byteLength(serialized) > MAX_VARIABLE_VALUE_BYTES ||
+        validateJsonSchema(declaration.valueSchema, value).length > 0) {
+        throw new SettingsError('settings_invalid', `Invalid value for ${declaration.portal?.label ?? declaration.name}.`);
+    }
+}
+function withinScope(parent, child) {
+    return (parent.org === child.org &&
+        (parent.level === 'org' ||
+            (parent.app === child.app && (parent.level === 'app' || parent.env === child.env))));
+}
+//# sourceMappingURL=application-settings.js.map

package/node_modules/@noodle-borg/service/dist/business-api-admission.js

@@ -0,0 +1,121 @@
+import { createHash } from 'node:crypto';
+import { nextReset, } from '@noodle-borg/admission-limits/portable';
+import { sendJson } from '@noodle-borg/transport-http';
+import { parseSolutionInstallationPath } from './routes/business-information-paths.js';
+import { authorizeControlPlane } from './routes/control-plane.js';
+/** Technical HTTP work allowances; they do not spend tool calls or commercial entitlements. */
+export const BUSINESS_API_LIMITS = {
+    read: { subject: 6_000, installation: 30_000, org: 60_000 },
+    mutation: { subject: 1_200, installation: 6_000, org: 12_000 },
+    recovery: { subject: 6_000, installation: 30_000, org: 60_000 },
+};
+const requests = new WeakMap();
+const responses = new WeakMap();
+export function businessApiCounter(lane, bucket, scope) {
+    const digest = createHash('sha256').update(JSON.stringify(scope)).digest('hex');
+    return {
+        key: `business-api:${lane}:${bucket}:${digest}`,
+        limit: BUSINESS_API_LIMITS[lane][bucket],
+        window: 'minute',
+    };
+}
+function laneFor(req) {
+    const ref = parseSolutionInstallationPath(new URL(req.url ?? '/', 'http://service.invalid').pathname);
+    if (req.method === 'DELETE' ||
+        ref?.action === 'export' ||
+        (req.method === 'GET' && ref?.action === 'activity'))
+        return 'recovery';
+    if (req.method === 'GET' || req.method === 'HEAD')
+        return 'read';
+    if ((req.method === 'PATCH' && ref?.installationId && (!ref.action || ref.action === 'channels')) ||
+        ref?.sourceAction ||
+        ref?.connectionAction === 'disconnect' ||
+        (req.method === 'POST' && ref?.action === 'records' && !ref.recordId))
+        return 'recovery';
+    return 'mutation';
+}
+/** One verified identity and one subject attempt per request; invalid targets never spend victim capacity. */
+export async function authorizeBusinessApi(req, res, deps) {
+    let pending = requests.get(req);
+    if (!pending) {
+        pending = (async () => {
+            const identity = await authorizeControlPlane(req, res, deps.gate, { requireIdentity: true });
+            if (identity === false)
+                return false;
+            const context = {
+                identity,
+                counters: deps.publicCounters,
+                lane: laneFor(req),
+                now: deps.now?.() ?? new Date(),
+                admissions: new Map(),
+            };
+            return (await subject(context, res, context.lane)) ? context : false;
+        })();
+        requests.set(req, pending);
+    }
+    responses.set(res, pending);
+    const context = await pending;
+    return context === false ? false : context.identity;
+}
+/** Invoke only after the existing live grant/permission or organization-owner check succeeds. */
+export async function admitBusinessTarget(res, target) {
+    const context = await responses.get(res);
+    return context ? targetAdmission(context, res, target, context.lane) : unavailable(res);
+}
+/** A validated missing native receipt needs an additional mutation admission; completed receipts do not. */
+export async function admitBusinessMutation(res, target) {
+    const context = await responses.get(res);
+    return context
+        ? (await subject(context, res, 'mutation')) &&
+            (await targetAdmission(context, res, target, 'mutation'))
+        : unavailable(res);
+}
+function subject(context, res, lane) {
+    return consume(context, res, lane, `${lane}:subject`, [
+        businessApiCounter(lane, 'subject', context.identity.subject),
+    ]);
+}
+function targetAdmission(context, res, target, lane) {
+    const counters = [businessApiCounter(lane, 'org', target.org)];
+    if (target.installationId)
+        counters.push(businessApiCounter(lane, 'installation', [target.org, target.installationId]));
+    return consume(context, res, lane, `${lane}:${counters.map((counter) => counter.key).join(':')}`, counters);
+}
+function consume(context, res, lane, key, batch) {
+    const existing = context.admissions.get(key);
+    if (existing)
+        return existing;
+    const pending = (async () => {
+        const store = context.counters;
+        if (typeof store.consumeAll !== 'function')
+            return unavailable(res);
+        try {
+            if (await store.consumeAll(batch, context.now))
+                return true;
+        }
+        catch {
+            return unavailable(res);
+        }
+        const resetAt = nextReset(context.now, 'minute');
+        res.setHeader('Retry-After', String(Math.max(1, Math.ceil((resetAt.getTime() - context.now.getTime()) / 1000))));
+        sendJson(res, 429, {
+            error: 'This business API allowance is temporarily exhausted. Retry after the indicated time.',
+            code: 'business_api_rate_limited',
+            resetAt: resetAt.toISOString(),
+            category: lane,
+            limits: BUSINESS_API_LIMITS[lane],
+        });
+        return false;
+    })();
+    context.admissions.set(key, pending);
+    return pending;
+}
+function unavailable(res) {
+    if (!res.writableEnded)
+        sendJson(res, 503, {
+            error: 'Business API admission is temporarily unavailable. Retry later.',
+            code: 'business_api_admission_unavailable',
+        });
+    return false;
+}
+//# sourceMappingURL=business-api-admission.js.map

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

@@ -0,0 +1,73 @@
+import { cloneActivity } from './model.js';
+import { scopeKey } from './pagination.js';
+import { boundedPageSize, CursorValidationError, validateScalar } from './validation.js';
+export function activityPaging(scope, collection, record, input = {}) {
+    const limit = boundedPageSize(input.limit);
+    if (input.cursor === undefined)
+        return { limit };
+    try {
+        const value = JSON.parse(Buffer.from(validateScalar('cursor', input.cursor, 2048), 'base64url').toString('utf8'));
+        if (typeof value !== 'object' ||
+            value === null ||
+            !('version' in value) ||
+            value.version !== 1 ||
+            !('kind' in value) ||
+            value.kind !== 'record-activity' ||
+            !('scope' in value) ||
+            value.scope !== scopeKey(scope) ||
+            !('collection' in value) ||
+            value.collection !== collection ||
+            !('record' in value) ||
+            value.record !== record ||
+            !('before' in value) ||
+            typeof value.before !== 'number' ||
+            !Number.isSafeInteger(value.before) ||
+            value.before < 1)
+            throw new CursorValidationError();
+        return { limit, before: value.before };
+    }
+    catch {
+        throw new CursorValidationError('cursor does not belong to this record history');
+    }
+}
+export function activityPage(scope, collection, record, rows, limit) {
+    const activities = rows.slice(0, limit);
+    const last = activities.at(-1);
+    return {
+        activities,
+        ...(rows.length > limit && last !== undefined
+            ? {
+                nextCursor: Buffer.from(JSON.stringify({
+                    version: 1,
+                    kind: 'record-activity',
+                    scope: scopeKey(scope),
+                    collection,
+                    record,
+                    before: last.revision,
+                })).toString('base64url'),
+            }
+            : {}),
+    };
+}
+/** History is append-only in revision order; select a bounded window without copying the full array. */
+export function memoryActivityPage(scope, collection, record, history, input) {
+    const paging = activityPaging(scope, collection, record, input);
+    let end = history.length;
+    if (paging.before !== undefined) {
+        let low = 0;
+        while (low < end) {
+            const middle = Math.floor((low + end) / 2);
+            const entry = history[middle];
+            if (entry !== undefined && entry.revision < paging.before)
+                low = middle + 1;
+            else
+                end = middle;
+        }
+    }
+    const selected = history
+        .slice(Math.max(0, end - paging.limit - 1), end)
+        .reverse()
+        .map(cloneActivity);
+    return activityPage(scope, collection, record, selected, paging.limit);
+}
+//# sourceMappingURL=activity-pagination.js.map

package/node_modules/@noodle-borg/service/dist/business-information/business-notice.d.ts

@@ -0,0 +1,24 @@
+import { type BusinessNotice } from '@noodle-borg/wire-contracts';
+import type { InstallationScope } from './contracts.js';
+export interface BusinessNoticeRecord {
+    readonly notice: BusinessNotice;
+    readonly revision: number;
+    readonly updatedAt: string;
+    readonly updatedBySubject: string;
+}
+export interface BusinessNoticeInput {
+    readonly scope: InstallationScope;
+    readonly notice: BusinessNotice;
+    readonly expectedRevision: number;
+    readonly actorSubject: string;
+}
+export interface BusinessNoticeStore {
+    getBusinessNotice(scope: InstallationScope): Promise<BusinessNoticeRecord | undefined>;
+    setBusinessNotice(input: BusinessNoticeInput): Promise<BusinessNoticeRecord>;
+}
+export declare class BusinessNoticeError extends Error {
+    readonly code: 'business_notice_forbidden' | 'business_notice_conflict';
+    constructor(code: 'business_notice_forbidden' | 'business_notice_conflict');
+}
+export declare function validatedNotice(input: BusinessNoticeInput): BusinessNotice;
+//# sourceMappingURL=business-notice.d.ts.map

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

@@ -0,0 +1,18 @@
+import { BusinessNoticeSaveRequestSchema } from '@noodle-borg/wire-contracts';
+export class BusinessNoticeError extends Error {
+    code;
+    constructor(code) {
+        super(code === 'business_notice_forbidden'
+            ? 'Installation administrator required.'
+            : 'Business notice changed. Reload before saving.');
+        this.code = code;
+        this.name = 'BusinessNoticeError';
+    }
+}
+export function validatedNotice(input) {
+    return BusinessNoticeSaveRequestSchema.parse({
+        expectedRevision: input.expectedRevision,
+        notice: input.notice,
+    }).notice;
+}
+//# sourceMappingURL=business-notice.js.map

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

@@ -0,0 +1,51 @@
+import { validateJsonSchemaWithDefaults } from '@noodle-borg/compiler';
+import { PayloadValidationError, validateManagedPayload } from './validation.js';
+export function collectionControlEnabled(collection, control) {
+    if (collection.authority.authority !== 'native')
+        return false;
+    if (collection.management !== undefined)
+        return collection.management[control] === true;
+    return collection.behavior?.kind === 'request';
+}
+export function collectionPublicFields(collection) {
+    return (collection.publicFields ??
+        (collection.behavior?.kind === 'request' ? Object.keys(recordProperties(collection)) : []));
+}
+export function creationPayload(collection, value, publicInput) {
+    const payload = validateManagedPayload(value);
+    if (publicInput)
+        assertFields(payload, collectionPublicFields(collection), 'public');
+    const defaulted = validateJsonSchemaWithDefaults(collection.recordSchema, payload);
+    if (defaulted.issues.length > 0)
+        throw new PayloadValidationError('invalid_json', 'managed payload does not match collection schema');
+    return validateManagedPayload(defaulted.value);
+}
+export function patchedPayload(collection, current, patch, unset = []) {
+    const admitted = validateManagedPayload(patch);
+    if (!Array.isArray(unset) ||
+        unset.length > 128 ||
+        new Set(unset).size !== unset.length ||
+        unset.some((name) => typeof name !== 'string' ||
+            name.length < 1 ||
+            name.length > 64 ||
+            Object.hasOwn(admitted, name) ||
+            (Array.isArray(collection.recordSchema.required) &&
+                collection.recordSchema.required.includes(name))))
+        throw new PayloadValidationError('invalid_json', 'Removal keys must be unique optional fields outside the patch.');
+    assertFields({ ...admitted, ...Object.fromEntries(unset.map((name) => [name, null])) }, collection.editableFields ?? Object.keys(recordProperties(collection)), 'editable');
+    const result = { ...current, ...admitted };
+    for (const name of unset)
+        delete result[name];
+    return validateManagedPayload(result);
+}
+function assertFields(payload, allowed, label) {
+    if (Object.keys(payload).some((name) => !allowed.includes(name)))
+        throw new PayloadValidationError('prohibited_field', `managed payload includes a field outside the ${label} field set`);
+}
+function recordProperties(collection) {
+    const properties = collection.recordSchema.properties;
+    return properties !== null && typeof properties === 'object' && !Array.isArray(properties)
+        ? properties
+        : {};
+}
+//# sourceMappingURL=collection-controls.js.map