@jini-ai/cms 0.5.4 → 0.5.5

package/dist/settings/ensure-definitions.js

@@ -1,91 +0,0 @@
-import { resolveDefinitionRaw } from "./settings.js";
-import { SCOPE_BIT } from "./types.js";
-import { reconcileDefinitionDefault, registerDefinitions } from "./write-service.js";
-/** Boot-time infra work is trusted by construction — mirrors every other
- *  `ensure*SettingDefinitions`'s identical shim. */
-const alwaysAllowBoot = async () => ({ allowed: true, reason: "system_boot" });
-/**
- * Idempotently registers every definition in `input.definitions` under
- * `input.namespace`, and reconciles the stored default of any that already
- * exist to the default source declares. Safe to call on every boot.
- *
- * The reconcile half matters as much as the register half: registration is
- * once-only, so without it a `defaultValue` edited in source never reaches an
- * install that has booted before. Code owns `core` defaults; the stored row
- * does not get to outvote it.
- *
- * All definitions registered here are `ownerKind: "core"` — a settings-dialog
- * tab configures a platform-level capability, not per-site content. Per the
- * namespace-fence CHECK, `owner_kind='core'` requires `workspaceId: null` at
- * the DEFINITION level regardless of which workspace is booting, while the
- * `scopes` bitmask still lets each workspace (or user) hold its own VALUE row.
- *
- * @complexity O(n) in the number of definitions — each is one
- * skip-if-registered lookup plus at most one `registerDefinitions` call.
- */
-export async function ensureSettingDefinitions(deps, input) {
-    const writeDeps = {
-        repo: deps.settingsRepo,
-        clock: deps.clock,
-        ids: deps.ids,
-        authorize: alwaysAllowBoot,
-        principals: deps.principals,
-    };
-    for (const def of input.definitions) {
-        const existing = await resolveDefinitionRaw({ repo: deps.settingsRepo }, { namespace: input.namespace, key: def.key, workspaceId: null });
-        if (existing) {
-            // Registration is once-only, but the DEFAULT is not. Without this, a
-            // `defaultValue` changed in source is unreachable in any install that
-            // has already booted — the stored `default_json` from first boot keeps
-            // winning, for every settings-dialog tab. See `reconcileDefinitionDefault`
-            // for the bug this closes.
-            //
-            // Three slots are deliberately left alone rather than reconciled:
-            // a non-`active` row (deprecated/tombstoned) is not ours to rewrite; a
-            // non-`core` row is operator-owned; and a row whose identity differs
-            // from the slot we asked for means `resolveDefinitionRaw` followed an
-            // alias, so rewriting it would silently change a DIFFERENT definition's
-            // default. `reconcileDefinitionDefault` would throw on the first two —
-            // this skips them quietly because boot must not fail on them.
-            const isSameSlot = existing.namespace === input.namespace && existing.key === def.key;
-            if (existing.status === "active" && existing.ownerKind === "core" && isSameSlot) {
-                await reconcileDefinitionDefault({
-                    deps: writeDeps,
-                    input: {
-                        namespace: input.namespace,
-                        key: def.key,
-                        workspaceId: null,
-                        defaultValue: def.defaultValue,
-                        callerPrincipalId: input.systemPrincipalId,
-                        authWorkspaceId: input.systemPrincipalId,
-                    },
-                });
-            }
-            continue;
-        }
-        await registerDefinitions({
-            deps: writeDeps,
-            input: {
-                callerPrincipalId: input.systemPrincipalId,
-                // Platform (core) definitions aren't scoped to any one workspace, but
-                // `registerDefinitions`'s authorization check still needs a workspace
-                // context to authorize against — the seeded workspace mirrors every
-                // other boot-time registrar's identical `authWorkspaceId` shape.
-                authWorkspaceId: input.systemPrincipalId,
-                definitions: [
-                    {
-                        namespace: input.namespace,
-                        key: def.key,
-                        ownerKind: "core",
-                        workspaceId: null,
-                        schema: def.schema,
-                        defaultValue: def.defaultValue,
-                        scopes: def.scopes ?? SCOPE_BIT.workspace,
-                        secret: false,
-                    },
-                ],
-            },
-        });
-    }
-}
-//# sourceMappingURL=ensure-definitions.js.map

package/dist/settings/errors.d.ts

@@ -1,42 +0,0 @@
-/**
- * @file Typed domain errors for `settings`.
- *
- * Purpose:
- * One class per error this module originates, mirroring the
- * `PresentationSettingsNotFoundError`/`PresentationSettingsValidationError`
- * convention a host's own presentation-settings module may use. Route
- * handlers map these 1:1 to HTTP codes.
- */
-export declare class DefinitionInvalidError extends Error {
-}
-export declare class ScopeNotAllowedError extends Error {
-}
-export declare class SecretNotSupportedError extends Error {
-    constructor({ message }: {
-        message: string;
-    }, optional?: ErrorOptions);
-}
-export declare class ValueValidationFailedError extends Error {
-}
-export declare class RenameRetypeConflictError extends Error {
-}
-export declare class AliasDepthExceededError extends Error {
-}
-export declare class DefinitionTombstonedError extends Error {
-}
-export declare class DefinitionNotFoundError extends Error {
-}
-export declare class PurgeRequiredError extends Error {
-    constructor({ message }: {
-        message: string;
-    }, optional?: ErrorOptions);
-}
-export declare class ForbiddenError extends Error {
-}
-/** : the target `principalId` does not resolve to an active principal in the request's workspace. See docs/decisions/DR-003-settings-ledger-invariants.md. */
-export declare class PrincipalNotFoundError extends Error {
-    readonly principalId: string;
-    readonly workspaceId: string;
-    constructor(message: string, principalId: string, workspaceId: string);
-}
-//# sourceMappingURL=errors.d.ts.map

package/dist/settings/errors.js

@@ -1,46 +0,0 @@
-/**
- * @file Typed domain errors for `settings`.
- *
- * Purpose:
- * One class per error this module originates, mirroring the
- * `PresentationSettingsNotFoundError`/`PresentationSettingsValidationError`
- * convention a host's own presentation-settings module may use. Route
- * handlers map these 1:1 to HTTP codes.
- */
-export class DefinitionInvalidError extends Error {
-}
-export class ScopeNotAllowedError extends Error {
-}
-export class SecretNotSupportedError extends Error {
-    constructor({ message }, optional = {}) {
-        super(message, optional);
-    }
-}
-export class ValueValidationFailedError extends Error {
-}
-export class RenameRetypeConflictError extends Error {
-}
-export class AliasDepthExceededError extends Error {
-}
-export class DefinitionTombstonedError extends Error {
-}
-export class DefinitionNotFoundError extends Error {
-}
-export class PurgeRequiredError extends Error {
-    constructor({ message }, optional = {}) {
-        super(message, optional);
-    }
-}
-export class ForbiddenError extends Error {
-}
-/** : the target `principalId` does not resolve to an active principal in the request's workspace. See docs/decisions/DR-003-settings-ledger-invariants.md. */
-export class PrincipalNotFoundError extends Error {
-    principalId;
-    workspaceId;
-    constructor(message, principalId, workspaceId) {
-        super(message);
-        this.principalId = principalId;
-        this.workspaceId = workspaceId;
-    }
-}
-//# sourceMappingURL=errors.js.map

package/dist/settings/express/cms-adapter.d.ts

@@ -1,20 +0,0 @@
-import { type SettingsWriteServiceDeps, type SettingsRepoPort } from "../index.js";
-import type { SettingsService, SettingsPermissions, SettingsChangeFeed } from "./contracts.js";
-/** Keep the CMS write chokepoint while translating its permission vocabulary to host policy. */
-/** Bind the CMS ledger and write chokepoint without copying their domain logic.
- * Effective reads scan definitions and resolve each namespace key; mutations inherit CMS transactions/errors.
- * @complexity O(1) setup. Per operation: O(definitions + keys) reads, or O(batch size) writes.
- * @example createCmsSettingsService({ deps: cmsPorts, permissions });
- */
-export declare function createCmsSettingsService(required: {
-    deps: SettingsWriteServiceDeps;
-    permissions: SettingsPermissions;
-}): SettingsService;
-/** Adapt the ledger through CMS tenant/principal disclosure rules, returning names and cursors only.
- * @complexity O(1) setup; collect is O(page size), with namespace lookup per visible revision.
- * @example createCmsSettingsChangeFeed({ repo });
- */
-export declare function createCmsSettingsChangeFeed(required: {
-    repo: SettingsRepoPort;
-}): SettingsChangeFeed;
-//# sourceMappingURL=cms-adapter.d.ts.map

package/dist/settings/express/cms-adapter.js

@@ -1,124 +0,0 @@
-import { getEffective, resolveDefinition, set, clear, resetNamespace, registerDefinitions, NON_REGISTER_DEFINITION_OPS, parseNonRegisterDefinitionOp, collectChangedNamespaces, } from "../index.js";
-/** Keep the CMS write chokepoint while translating its permission vocabulary to host policy. */
-/** Bind the CMS ledger and write chokepoint without copying their domain logic.
- * Effective reads scan definitions and resolve each namespace key; mutations inherit CMS transactions/errors.
- * @complexity O(1) setup. Per operation: O(definitions + keys) reads, or O(batch size) writes.
- * @example createCmsSettingsService({ deps: cmsPorts, permissions });
- */
-export function createCmsSettingsService(required) {
-    const { deps: original, permissions } = required;
-    const permissionMap = new Map([
-        ["settings.definitions.manage", permissions.manageDefinitions],
-        ["settings.global.write", permissions.writeGlobal],
-        ["settings.workspace.write", permissions.writeWorkspace],
-        ["settings.user.self.write", permissions.writeUserSelf],
-        ["settings.user.write", permissions.writeUserOther],
-        ["settings.reset.global", permissions.reset.global],
-        ["settings.reset.workspace", permissions.reset.workspace],
-        ["settings.reset.user", permissions.reset.user],
-    ]);
-    const deps = { ...original,
-        authorize: (input) => {
-            const permission = permissionMap.get(input.permission);
-            if (permission === undefined)
-                return Promise.resolve({ allowed: false, reason: "unknown_settings_permission" });
-            return original.authorize({ ...input, permission });
-        },
-    };
-    const repo = deps.repo;
-    const listDefinitions = async ({ workspaceId }) => {
-        const [platform, workspace] = await Promise.all([
-            repo.listActiveDefinitions({ workspaceId: null }), repo.listActiveDefinitions({ workspaceId }),
-        ]);
-        return [...platform, ...workspace];
-    };
-    return {
-        listDefinitions,
-        effective: async ({ namespace, workspaceId, principalId }) => {
-            const defs = await listDefinitions({ workspaceId });
-            const keys = new Set(defs.filter((d) => d.namespace === namespace).map((d) => d.key));
-            const data = [];
-            for (const key of keys) {
-                const result = await getEffective({ repo }, { namespace, key, scopeContext: { workspaceId, principalId } });
-                if (result)
-                    data.push({ key, value: result.value, sourceLayer: result.sourceLayer, defVersion: result.defVersion });
-            }
-            return data;
-        },
-        raw: async ({ namespace, key, workspaceId, principalId }) => {
-            const definition = await resolveDefinition({ repo }, { namespace, key, workspaceId });
-            if (!definition)
-                return null;
-            const settingId = definition.settingId;
-            const records = await Promise.all([
-                repo.getGlobalValue(settingId), repo.getWorkspaceValue({ workspaceId, settingId }),
-                principalId ? repo.getUserValue({ workspaceId, principalId, settingId }) : Promise.resolve(null),
-            ]);
-            const values = records.map((r) => r?.state === "set" ? r.valueJson : null);
-            return { key: `${namespace}.${key}`, global: values[0], workspace: values[1], user: values[2], default: definition.defaultValue };
-        },
-        set: (input) => set({ deps, input }),
-        clear: (input) => clear({ deps, input }),
-        reset: async (input) => {
-            const definitions = await repo.listActiveDefinitions({ workspaceId: input.scope === "global" ? null : (input.workspaceId ?? input.authWorkspaceId ?? null) });
-            const keys = definitions.filter((d) => d.namespace === input.namespace).map((d) => d.key);
-            return resetNamespace({ deps, input }, keys);
-        },
-        definitions: ({ items, callerPrincipalId, authWorkspaceId }) => applyDefinitions({ deps, items, callerPrincipalId, authWorkspaceId }),
-    };
-}
-/** Preserve register batching and ordered non-register writes over existing CMS operation contracts.
- * Unknown operations return their name. Earlier non-register writes are not rolled back by later failures.
- * @complexity O(item count) time/space plus CMS effects; this batch is not atomic.
- */
-async function applyDefinitions(required) {
-    const { deps, items, callerPrincipalId, authWorkspaceId } = required;
-    const toRegister = [];
-    const applied = [];
-    for (const raw of items) {
-        const item = raw;
-        const op = String(item.op ?? "register");
-        const namespace = String(item.namespace ?? "");
-        const key = String(item.key ?? "");
-        const ownerKind = item.ownerKind;
-        const workspaceId = ownerKind === "site" ? authWorkspaceId : null;
-        const defaultValue = (item.defaultJson ?? null);
-        if (op === "register") {
-            toRegister.push({ namespace, key, ownerKind, workspaceId, schema: item.schemaJson,
-                defaultValue, scopes: Number(item.scopes), secret: Boolean(item.secret ?? false) });
-        }
-        else {
-            const parsedOp = parseNonRegisterDefinitionOp({ op });
-            if (!parsedOp)
-                return { unknownOp: op };
-            const opItem = { namespace, key, ownerKind, workspaceId, defaultJson: defaultValue,
-                ...(item.newNamespace === undefined ? {} : { newNamespace: item.newNamespace }),
-                ...(item.newKey === undefined ? {} : { newKey: item.newKey }),
-                ...(item.schemaJson === undefined ? {} : { schemaJson: item.schemaJson }),
-                ...(item.coercionJson === undefined ? {} : { coercionJson: item.coercionJson }),
-            };
-            await NON_REGISTER_DEFINITION_OPS[parsedOp]({ ctx: { deps, callerPrincipalId, authWorkspaceId }, item: opItem });
-        }
-        applied.push({ key: `${namespace}.${key}`, op, status: "applied" });
-    }
-    if (toRegister.length)
-        await registerDefinitions({ deps, input: { definitions: toRegister, callerPrincipalId, authWorkspaceId } });
-    return { applied };
-}
-/** Adapt the ledger through CMS tenant/principal disclosure rules, returning names and cursors only.
- * @complexity O(1) setup; collect is O(page size), with namespace lookup per visible revision.
- * @example createCmsSettingsChangeFeed({ repo });
- */
-export function createCmsSettingsChangeFeed(required) {
-    const { repo } = required;
-    return {
-        head: () => repo.maxRevisionSeq(),
-        collect: async ({ sinceSeq, limit, viewer }) => {
-            const revisions = await repo.listRevisionsSince({ sinceSeq, limit, workspaceId: viewer.workspaceId });
-            // Resolve afresh each batch: a rename must never leave a stale namespace cached forever.
-            const batch = await collectChangedNamespaces({ revisions, viewer, resolveNamespace: async ({ settingId }) => (await repo.findDefinitionBySettingId({ settingId }))?.namespace ?? null });
-            return { ...batch, examinedCount: revisions.length };
-        },
-    };
-}
-//# sourceMappingURL=cms-adapter.js.map

package/dist/settings/express/contracts.d.ts

@@ -1,135 +0,0 @@
-import type { Request, Response, Express } from "express";
-import type { SettingScope, SettingDefinitionRecord, SetValueRequired, ClearValueRequired, ResetNamespaceRequired, ChangeFeedViewer, ChangeFeedBatch } from "../index.js";
-export type Authorize = (required: {
-    principalId: string;
-    workspaceId: string;
-    permission: string;
-    entityType: string;
-}) => Promise<{
-    allowed: boolean;
-    reason: string;
-}>;
-export type PrincipalResolver = (required: {
-    request: Request;
-    response: Response;
-}) => Promise<{
-    id: string;
-} | null> | {
-    id: string;
-} | null;
-export interface Scheduler {
-    /** Return an idempotent cancellation callback. */
-    every(required: {
-        intervalMs: number;
-        callback: () => void;
-    }): () => void;
-}
-export interface SettingsPermissions {
-    read: string;
-    readRaw: string;
-    readDefinitions: string;
-    readOtherUser: string;
-    manageDefinitions: string;
-    writeGlobal: string;
-    writeWorkspace: string;
-    writeUserSelf: string;
-    writeUserOther: string;
-    reset: Record<SettingScope, string>;
-}
-export interface SettingsRoutes {
-    definitions: string;
-    effective: string;
-    raw: string;
-    value: string;
-    reset: string;
-    events: string;
-    workspaceParam: string;
-}
-export type EffectiveSettingRow = {
-    key: string;
-    value: unknown;
-    sourceLayer: string;
-    defVersion: number;
-};
-export type RawSetting = {
-    key: string;
-    global: unknown;
-    workspace: unknown;
-    user: unknown;
-    default: unknown;
-};
-export type DefinitionResult = {
-    applied: Array<{
-        key: string;
-        op: string;
-        status: string;
-    }>;
-} | {
-    unknownOp: string;
-};
-export interface SettingsService {
-    listDefinitions(required: {
-        workspaceId: string;
-    }): Promise<SettingDefinitionRecord[]>;
-    effective(required: {
-        namespace: string;
-        workspaceId: string;
-        principalId: string | undefined;
-    }): Promise<EffectiveSettingRow[]>;
-    raw(required: {
-        namespace: string;
-        key: string;
-        workspaceId: string;
-        principalId: string | undefined;
-    }): Promise<RawSetting | null>;
-    set(required: SetValueRequired["input"]): Promise<{
-        value: unknown;
-        revisionSeq: number;
-    }>;
-    clear(required: ClearValueRequired["input"]): Promise<{
-        revisionSeq: number;
-    }>;
-    reset(required: ResetNamespaceRequired["input"]): Promise<{
-        clearedCount: number;
-        revisionSeqs: number[];
-    }>;
-    definitions(required: {
-        items: readonly unknown[];
-        callerPrincipalId: string;
-        authWorkspaceId: string;
-    }): Promise<DefinitionResult>;
-}
-export interface SettingsChangeFeed {
-    head(required: Record<string, never>): Promise<number>;
-    /** Cursor advances across invisible rows. The emitted id MUST use batch.cursor, never head. */
-    collect(required: {
-        sinceSeq: number;
-        limit: number;
-        viewer: ChangeFeedViewer;
-    }): Promise<ChangeFeedBatch & {
-        examinedCount: number;
-    }>;
-}
-export interface SettingsHttpRequired {
-    app: Pick<Express, "get" | "post" | "put" | "delete">;
-    workspaceId: string;
-    ready: Promise<void>;
-    service: SettingsService;
-    changeFeed: SettingsChangeFeed;
-    principalResolver: PrincipalResolver;
-    authorize: Authorize;
-    scheduler: Scheduler;
-    routes: SettingsRoutes;
-    permissions: SettingsPermissions;
-}
-export interface SettingsHttpOptions {
-    pollIntervalMs?: number;
-    keepaliveIntervalMs?: number;
-    reauthorizeIntervalMs?: number;
-    revisionPageSize?: number;
-    onError?: (required: {
-        operation: string;
-        error: unknown;
-    }) => void;
-}
-//# sourceMappingURL=contracts.d.ts.map

package/dist/settings/express/contracts.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=contracts.js.map

package/dist/settings/express/http.d.ts

@@ -1,10 +0,0 @@
-import type { SettingsHttpRequired, SettingsHttpOptions } from "./contracts.js";
-/** Mount all eight endpoints. The returned disposer closes active feeds and cancels their schedules. */
-/** Injected policy and services preserve the settings HTTP response envelopes.
- * O(1) mounting; read/mutation work is delegated. Feed resources are bounded per connection.
- * @example registerSettingsRoutes({ app, workspaceId, ready, service, changeFeed, principalResolver, authorize, scheduler, routes, permissions });
- */
-export declare function registerSettingsRoutes(required: SettingsHttpRequired, optional?: SettingsHttpOptions): {
-    dispose(): void;
-};
-//# sourceMappingURL=http.d.ts.map