@pipeline-builder/pipeline-data 4.1.22 → 4.1.24

package/lib/api/keyset-cursor.js

@@ -0,0 +1,82 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Keyset (cursor) pagination primitives for `CrudService.findPaginated`.
+ *
+ * Pure functions over a Drizzle column — no table, no tenant context, no I/O —
+ * which is why they live outside the CRUD base class: the cursor encoding and
+ * its "is this castable / strictly after" rules are the fiddly, test-worthy
+ * part of paging and are easier to reason about on their own.
+ */
+import { sql } from 'drizzle-orm';
+/** Projection alias carrying the sort column's exact DB text for the next cursor. */
+export const CURSOR_SORT_KEY = '__cursorSortKey';
+/**
+ * Opaque keyset cursor: the last row's sort value as Postgres TEXT (full
+ * precision — a JS `Date` would truncate `timestamptz` microseconds to ms, so
+ * `created_at > '<ms>'` re-returns or skips rows in the same millisecond) plus
+ * its `id` as the tie-breaker.
+ */
+export function encodeCursor(sortText, id) {
+    return Buffer.from(JSON.stringify([sortText, id]), 'utf8').toString('base64url');
+}
+/** Decode a cursor produced by {@link encodeCursor}; `null` when malformed. */
+export function decodeCursor(cursor) {
+    try {
+        const parsed = JSON.parse(Buffer.from(cursor, 'base64url').toString('utf8'));
+        if (Array.isArray(parsed) && parsed.length === 2
+            && (parsed[0] === null || typeof parsed[0] === 'string')
+            && typeof parsed[1] === 'string' && parsed[1].length > 0) {
+            return { sortText: parsed[0], id: parsed[1] };
+        }
+    }
+    catch {
+        // fall through
+    }
+    return null;
+}
+const UUID_TEXT = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+/** Postgres `timestamp[tz]::text` / `date::text` (also accepts ISO-8601). */
+const TIMESTAMP_TEXT = /^\d{4}-\d{2}-\d{2}(?:[ T]\d{2}:\d{2}(?::\d{2}(?:\.\d{1,6})?)?(?:Z|[+-]\d{2}(?::?\d{2})?)?)?$/;
+const NUMERIC_TEXT = /^-?\d+(?:\.\d+)?(?:[eE][-+]?\d+)?$/;
+/**
+ * Whether `text` can be cast to `column`'s type. A decoded cursor is still
+ * client input: a value Postgres can't cast (a non-UUID id, a garbage
+ * timestamp) fails the whole query with a 500. Column types this doesn't know
+ * (text, varchar, …) accept any string.
+ */
+export function isCastableTo(column, text) {
+    const { columnType, dataType } = column;
+    const enumValues = column.enumValues;
+    if (columnType === 'PgUUID')
+        return UUID_TEXT.test(text);
+    if ((columnType === 'PgEnumColumn' || columnType === 'PgEnumObjectColumn') && enumValues?.length)
+        return enumValues.includes(text);
+    if (dataType === 'date' || columnType === 'PgTimestampString' || columnType === 'PgDateString')
+        return TIMESTAMP_TEXT.test(text);
+    if (dataType === 'boolean')
+        return text === 'true' || text === 'false';
+    if (dataType === 'number' || dataType === 'bigint')
+        return NUMERIC_TEXT.test(text);
+    return true;
+}
+/**
+ * Keyset predicate "strictly after (sortText, id)" for `ORDER BY sort <dir>, id <dir>`
+ * under Postgres' default null placement (ASC → NULLS LAST, DESC → NULLS FIRST).
+ * The text value is bound as a parameter compared against the column, so Postgres
+ * casts it back to the column's type at full precision.
+ */
+export function keysetAfter(sortColumn, idColumn, sortOrder, sortText, id) {
+    if (sortColumn === idColumn) {
+        return sortOrder === 'desc' ? sql `${idColumn} < ${id}` : sql `${idColumn} > ${id}`;
+    }
+    if (sortOrder === 'asc') {
+        return sortText === null
+            ? sql `(${sortColumn} IS NULL AND ${idColumn} > ${id})`
+            : sql `(${sortColumn} > ${sortText} OR (${sortColumn} = ${sortText} AND ${idColumn} > ${id}) OR ${sortColumn} IS NULL)`;
+    }
+    return sortText === null
+        ? sql `(${sortColumn} IS NOT NULL OR (${sortColumn} IS NULL AND ${idColumn} < ${id}))`
+        : sql `(${sortColumn} < ${sortText} OR (${sortColumn} = ${sortText} AND ${idColumn} < ${id}))`;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"keyset-cursor.js","sourceRoot":"","sources":["../../src/api/keyset-cursor.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Keyset (cursor) pagination primitives for `CrudService.findPaginated`.\n *\n * Pure functions over a Drizzle column — no table, no tenant context, no I/O —\n * which is why they live outside the CRUD base class: the cursor encoding and\n * its \"is this castable / strictly after\" rules are the fiddly, test-worthy\n * part of paging and are easier to reason about on their own.\n */\n\nimport { sql, type SQL } from 'drizzle-orm';\nimport type { AnyColumn } from 'drizzle-orm/column';\n\n/** Projection alias carrying the sort column's exact DB text for the next cursor. */\nexport const CURSOR_SORT_KEY = '__cursorSortKey';\n\n/**\n * Opaque keyset cursor: the last row's sort value as Postgres TEXT (full\n * precision — a JS `Date` would truncate `timestamptz` microseconds to ms, so\n * `created_at > '<ms>'` re-returns or skips rows in the same millisecond) plus\n * its `id` as the tie-breaker.\n */\nexport function encodeCursor(sortText: string | null, id: string): string {\n  return Buffer.from(JSON.stringify([sortText, id]), 'utf8').toString('base64url');\n}\n\n/** Decode a cursor produced by {@link encodeCursor}; `null` when malformed. */\nexport function decodeCursor(cursor: string): { sortText: string | null; id: string } | null {\n  try {\n    const parsed: unknown = JSON.parse(Buffer.from(cursor, 'base64url').toString('utf8'));\n    if (\n      Array.isArray(parsed) && parsed.length === 2\n      && (parsed[0] === null || typeof parsed[0] === 'string')\n      && typeof parsed[1] === 'string' && parsed[1].length > 0\n    ) {\n      return { sortText: parsed[0], id: parsed[1] };\n    }\n  } catch {\n    // fall through\n  }\n  return null;\n}\n\nconst UUID_TEXT = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;\n/** Postgres `timestamp[tz]::text` / `date::text` (also accepts ISO-8601). */\nconst TIMESTAMP_TEXT = /^\\d{4}-\\d{2}-\\d{2}(?:[ T]\\d{2}:\\d{2}(?::\\d{2}(?:\\.\\d{1,6})?)?(?:Z|[+-]\\d{2}(?::?\\d{2})?)?)?$/;\nconst NUMERIC_TEXT = /^-?\\d+(?:\\.\\d+)?(?:[eE][-+]?\\d+)?$/;\n\n/**\n * Whether `text` can be cast to `column`'s type. A decoded cursor is still\n * client input: a value Postgres can't cast (a non-UUID id, a garbage\n * timestamp) fails the whole query with a 500. Column types this doesn't know\n * (text, varchar, …) accept any string.\n */\nexport function isCastableTo(column: AnyColumn, text: string): boolean {\n  const { columnType, dataType } = column;\n  const enumValues = (column as { enumValues?: readonly string[] }).enumValues;\n  if (columnType === 'PgUUID') return UUID_TEXT.test(text);\n  if ((columnType === 'PgEnumColumn' || columnType === 'PgEnumObjectColumn') && enumValues?.length) return enumValues.includes(text);\n  if (dataType === 'date' || columnType === 'PgTimestampString' || columnType === 'PgDateString') return TIMESTAMP_TEXT.test(text);\n  if (dataType === 'boolean') return text === 'true' || text === 'false';\n  if (dataType === 'number' || dataType === 'bigint') return NUMERIC_TEXT.test(text);\n  return true;\n}\n\n/**\n * Keyset predicate \"strictly after (sortText, id)\" for `ORDER BY sort <dir>, id <dir>`\n * under Postgres' default null placement (ASC → NULLS LAST, DESC → NULLS FIRST).\n * The text value is bound as a parameter compared against the column, so Postgres\n * casts it back to the column's type at full precision.\n */\nexport function keysetAfter(\n  sortColumn: AnyColumn,\n  idColumn: AnyColumn,\n  sortOrder: 'asc' | 'desc',\n  sortText: string | null,\n  id: string,\n): SQL {\n  if (sortColumn === idColumn) {\n    return sortOrder === 'desc' ? sql`${idColumn} < ${id}` : sql`${idColumn} > ${id}`;\n  }\n  if (sortOrder === 'asc') {\n    return sortText === null\n      ? sql`(${sortColumn} IS NULL AND ${idColumn} > ${id})`\n      : sql`(${sortColumn} > ${sortText} OR (${sortColumn} = ${sortText} AND ${idColumn} > ${id}) OR ${sortColumn} IS NULL)`;\n  }\n  return sortText === null\n    ? sql`(${sortColumn} IS NOT NULL OR (${sortColumn} IS NULL AND ${idColumn} < ${id}))`\n    : sql`(${sortColumn} < ${sortText} OR (${sortColumn} = ${sortText} AND ${idColumn} < ${id}))`;\n}\n"]}

package/lib/api/plugin-advisories.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Advisory matching: does a published advisory's `affectedRange` cover a given
+ * version, and which advisories block a resolution under the org's policy.
+ *
+ * The range grammar is npm-style and deliberately re-implemented here rather
+ * than pulled from `semver`: advisory ranges are OPERATOR SETS
+ * (`>=1.0.0 <1.2.3`, `1.0.0 - 1.2.0`, `^1.2`, `1.x`, `||`), a different shape
+ * from the install/reference version SPECS in ./semver-range.ts.
+ */
+import type { ConsumptionPolicy } from './plugin-consumption-policy.js';
+import type { AdvisorySeverity, BlockOnAdvisory, PluginAdvisory } from '../database/drizzle-schema.js';
+/** Severities each `blockOnAdvisory` setting blocks. */
+export declare const ADVISORY_BLOCK_SEVERITIES: Readonly<Record<BlockOnAdvisory, readonly AdvisorySeverity[]>>;
+/**
+ * Whether an advisory's `affectedRange` covers `version`: `||`-separated
+ * comparator sets, each either the lookup spec forms (`^`, `~`, partial,
+ * exact) or space-separated comparators (`>=1.0.0 <1.2.3`) or a hyphen range.
+ * `*` covers everything; an unparseable range covers nothing.
+ */
+export declare function advisoryRangeCovers(range: string, version: string): boolean;
+/**
+ * Why `range` isn't a usable advisory range (the forms {@link advisoryRangeCovers}
+ * understands), or null when it is. An advisory whose range parses as nothing
+ * would silently cover nothing, so drafts are refused instead.
+ */
+export declare function advisoryRangeProblem(range: string): string | null;
+/** The PUBLISHED advisories whose range covers `version` (any severity), most severe first. */
+export declare function advisoriesCovering<A extends Pick<PluginAdvisory, 'severity' | 'state' | 'affectedRange'>>(advisories: readonly A[], version: string): A[];
+/** The PUBLISHED advisories the policy blocks `version` for. */
+export declare function blockingAdvisories(advisories: readonly Pick<PluginAdvisory, 'id' | 'severity' | 'state' | 'affectedRange' | 'fixedVersion' | 'summary'>[], version: string, policy: Pick<ConsumptionPolicy, 'blockOnAdvisory'>): Array<Pick<PluginAdvisory, 'id' | 'severity' | 'state' | 'affectedRange' | 'fixedVersion' | 'summary'>>;

package/lib/api/plugin-advisories.js

@@ -0,0 +1,89 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { compareSemver, parseSemver, parseVersionSpec, satisfiesVersionSpec } from './semver-range.js';
+/** Severities each `blockOnAdvisory` setting blocks. */
+export const ADVISORY_BLOCK_SEVERITIES = {
+    critical: ['critical'],
+    high: ['critical', 'high'],
+    never: [],
+};
+const COMPARATOR = /^(>=|<=|>|<|=)?\s*v?(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?)$/;
+/** One comparator set (`>=1.0.0 <1.2.3`, `^1.2`, `1.x`, `1.0.0 - 1.2.0`) against `version`. */
+function comparatorSetCovers(set, version) {
+    const hyphen = /^(\S+)\s+-\s+(\S+)$/.exec(set);
+    if (hyphen)
+        return compareSemver(version, hyphen[1]) >= 0 && compareSemver(version, hyphen[2]) <= 0;
+    const parts = set.split(/\s+/).filter(Boolean);
+    if (parts.length === 1 && parseVersionSpec(parts[0]))
+        return satisfiesVersionSpec(version, parts[0]);
+    return parts.every((p) => {
+        const m = COMPARATOR.exec(p);
+        if (!m)
+            return false;
+        const c = compareSemver(version, m[2]);
+        switch (m[1] ?? '=') {
+            case '>=': return c >= 0;
+            case '<=': return c <= 0;
+            case '>': return c > 0;
+            case '<': return c < 0;
+            default: return c === 0;
+        }
+    });
+}
+/**
+ * Whether an advisory's `affectedRange` covers `version`: `||`-separated
+ * comparator sets, each either the lookup spec forms (`^`, `~`, partial,
+ * exact) or space-separated comparators (`>=1.0.0 <1.2.3`) or a hyphen range.
+ * `*` covers everything; an unparseable range covers nothing.
+ */
+export function advisoryRangeCovers(range, version) {
+    if (!parseSemver(version))
+        return false;
+    return range.split('||').map((s) => s.trim()).some((set) => set === '*' || (set !== '' && comparatorSetCovers(set, version)));
+}
+/**
+ * Why `range` isn't a usable advisory range (the forms {@link advisoryRangeCovers}
+ * understands), or null when it is. An advisory whose range parses as nothing
+ * would silently cover nothing, so drafts are refused instead.
+ */
+export function advisoryRangeProblem(range) {
+    const trimmed = range.trim();
+    if (trimmed === '')
+        return 'the affected range is empty';
+    if (trimmed.length > 255)
+        return 'the affected range is longer than 255 characters';
+    for (const set of trimmed.split('||').map((x) => x.trim())) {
+        if (set === '*')
+            continue;
+        if (set === '')
+            return 'the affected range has an empty "||" alternative';
+        const hyphen = /^(\S+)\s+-\s+(\S+)$/.exec(set);
+        if (hyphen) {
+            if (!parseSemver(hyphen[1]) || !parseSemver(hyphen[2]))
+                return `"${set}" is not a valid hyphen range`;
+            continue;
+        }
+        const parts = set.split(/\s+/).filter(Boolean);
+        if (parts.length === 1 && parts[0] !== 'latest' && parseVersionSpec(parts[0]))
+            continue;
+        const bad = parts.find((x) => !COMPARATOR.test(x));
+        if (bad !== undefined)
+            return `"${bad}" is not a version, a ^/~ range or a comparator (>=, <=, >, <, =)`;
+    }
+    return null;
+}
+/** The PUBLISHED advisories whose range covers `version` (any severity), most severe first. */
+export function advisoriesCovering(advisories, version) {
+    const rank = { critical: 0, high: 1, medium: 2, low: 3 };
+    return advisories
+        .filter((a) => a.state === 'published' && advisoryRangeCovers(a.affectedRange, version))
+        .sort((a, b) => rank[a.severity] - rank[b.severity]);
+}
+/** The PUBLISHED advisories the policy blocks `version` for. */
+export function blockingAdvisories(advisories, version, policy) {
+    const severities = ADVISORY_BLOCK_SEVERITIES[policy.blockOnAdvisory];
+    if (severities.length === 0)
+        return [];
+    return advisories.filter((a) => a.state === 'published' && severities.includes(a.severity) && advisoryRangeCovers(a.affectedRange, version));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin-advisories.js","sourceRoot":"","sources":["../../src/api/plugin-advisories.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Advisory matching: does a published advisory's `affectedRange` cover a given\n * version, and which advisories block a resolution under the org's policy.\n *\n * The range grammar is npm-style and deliberately re-implemented here rather\n * than pulled from `semver`: advisory ranges are OPERATOR SETS\n * (`>=1.0.0 <1.2.3`, `1.0.0 - 1.2.0`, `^1.2`, `1.x`, `||`), a different shape\n * from the install/reference version SPECS in ./semver-range.ts.\n */\n\nimport type { ConsumptionPolicy } from './plugin-consumption-policy.js';\nimport { compareSemver, parseSemver, parseVersionSpec, satisfiesVersionSpec } from './semver-range.js';\nimport type {\n  AdvisorySeverity,\n  BlockOnAdvisory,\n  PluginAdvisory,\n} from '../database/drizzle-schema.js';\n\n\n/** Severities each `blockOnAdvisory` setting blocks. */\nexport const ADVISORY_BLOCK_SEVERITIES: Readonly<Record<BlockOnAdvisory, readonly AdvisorySeverity[]>> = {\n  critical: ['critical'],\n  high: ['critical', 'high'],\n  never: [],\n};\n\nconst COMPARATOR = /^(>=|<=|>|<|=)?\\s*v?(\\d+\\.\\d+\\.\\d+(?:-[0-9A-Za-z.-]+)?(?:\\+[0-9A-Za-z.-]+)?)$/;\n\n/** One comparator set (`>=1.0.0 <1.2.3`, `^1.2`, `1.x`, `1.0.0 - 1.2.0`) against `version`. */\nfunction comparatorSetCovers(set: string, version: string): boolean {\n  const hyphen = /^(\\S+)\\s+-\\s+(\\S+)$/.exec(set);\n  if (hyphen) return compareSemver(version, hyphen[1]!) >= 0 && compareSemver(version, hyphen[2]!) <= 0;\n  const parts = set.split(/\\s+/).filter(Boolean);\n  if (parts.length === 1 && parseVersionSpec(parts[0]!)) return satisfiesVersionSpec(version, parts[0]!);\n  return parts.every((p) => {\n    const m = COMPARATOR.exec(p);\n    if (!m) return false;\n    const c = compareSemver(version, m[2]!);\n    switch (m[1] ?? '=') {\n      case '>=': return c >= 0;\n      case '<=': return c <= 0;\n      case '>': return c > 0;\n      case '<': return c < 0;\n      default: return c === 0;\n    }\n  });\n}\n\n/**\n * Whether an advisory's `affectedRange` covers `version`: `||`-separated\n * comparator sets, each either the lookup spec forms (`^`, `~`, partial,\n * exact) or space-separated comparators (`>=1.0.0 <1.2.3`) or a hyphen range.\n * `*` covers everything; an unparseable range covers nothing.\n */\nexport function advisoryRangeCovers(range: string, version: string): boolean {\n  if (!parseSemver(version)) return false;\n  return range.split('||').map((s) => s.trim()).some((set) => set === '*' || (set !== '' && comparatorSetCovers(set, version)));\n}\n\n/**\n * Why `range` isn't a usable advisory range (the forms {@link advisoryRangeCovers}\n * understands), or null when it is. An advisory whose range parses as nothing\n * would silently cover nothing, so drafts are refused instead.\n */\nexport function advisoryRangeProblem(range: string): string | null {\n  const trimmed = range.trim();\n  if (trimmed === '') return 'the affected range is empty';\n  if (trimmed.length > 255) return 'the affected range is longer than 255 characters';\n  for (const set of trimmed.split('||').map((x) => x.trim())) {\n    if (set === '*') continue;\n    if (set === '') return 'the affected range has an empty \"||\" alternative';\n    const hyphen = /^(\\S+)\\s+-\\s+(\\S+)$/.exec(set);\n    if (hyphen) {\n      if (!parseSemver(hyphen[1]!) || !parseSemver(hyphen[2]!)) return `\"${set}\" is not a valid hyphen range`;\n      continue;\n    }\n    const parts = set.split(/\\s+/).filter(Boolean);\n    if (parts.length === 1 && parts[0] !== 'latest' && parseVersionSpec(parts[0]!)) continue;\n    const bad = parts.find((x) => !COMPARATOR.test(x));\n    if (bad !== undefined) return `\"${bad}\" is not a version, a ^/~ range or a comparator (>=, <=, >, <, =)`;\n  }\n  return null;\n}\n\n/** The PUBLISHED advisories whose range covers `version` (any severity), most severe first. */\nexport function advisoriesCovering<A extends Pick<PluginAdvisory, 'severity' | 'state' | 'affectedRange'>>(\n  advisories: readonly A[],\n  version: string,\n): A[] {\n  const rank: Record<AdvisorySeverity, number> = { critical: 0, high: 1, medium: 2, low: 3 };\n  return advisories\n    .filter((a) => a.state === 'published' && advisoryRangeCovers(a.affectedRange, version))\n    .sort((a, b) => rank[a.severity] - rank[b.severity]);\n}\n\n/** The PUBLISHED advisories the policy blocks `version` for. */\nexport function blockingAdvisories(\n  advisories: readonly Pick<PluginAdvisory, 'id' | 'severity' | 'state' | 'affectedRange' | 'fixedVersion' | 'summary'>[],\n  version: string,\n  policy: Pick<ConsumptionPolicy, 'blockOnAdvisory'>,\n): Array<Pick<PluginAdvisory, 'id' | 'severity' | 'state' | 'affectedRange' | 'fixedVersion' | 'summary'>> {\n  const severities = ADVISORY_BLOCK_SEVERITIES[policy.blockOnAdvisory];\n  if (severities.length === 0) return [];\n  return advisories.filter((a) => a.state === 'published' && severities.includes(a.severity) && advisoryRangeCovers(a.affectedRange, version));\n}\n"]}

package/lib/api/plugin-consumption-policy.d.ts

@@ -0,0 +1,44 @@
+/**
+ * An org's plugin CONSUMPTION POLICY: which publisher tiers it trusts, which
+ * listings it blocks, which advisory severities block a resolution, and which
+ * tiers may receive secrets. Applied at every resolution (see
+ * ./plugin-resolution.ts) and edited through the org's policy row.
+ *
+ * Pure functions over the stored row — no I/O — so the same rules run in the
+ * resolver, in the policy-update route, and in tests.
+ */
+import { type BlockedListingRef, type BlockOnAdvisory, type OfficialInstalls, type PluginInstallPolicy, type PublisherTier } from '../database/drizzle-schema.js';
+/** An org's consumption policy, as the resolver applies it. */
+export interface ConsumptionPolicy {
+    allowedTiers: PublisherTier[];
+    requireApprovalTiers: PublisherTier[];
+    secretsAllowedTiers: PublisherTier[];
+    blockOnAdvisory: BlockOnAdvisory;
+    officialInstalls: OfficialInstalls;
+    blockedListings: BlockedListingRef[];
+}
+/** The defaults (and the column defaults of `plugin_install_policies`). */
+export declare const DEFAULT_CONSUMPTION_POLICY: Readonly<ConsumptionPolicy>;
+/** At most this many blocked listings per policy. */
+export declare const MAX_BLOCKED_LISTINGS = 500;
+/** A stored policy row (or none) as a {@link ConsumptionPolicy}. */
+export declare function policyOf(row: Partial<PluginInstallPolicy> | null | undefined): ConsumptionPolicy;
+/**
+ * A team's policy under its root org's: each field takes the STRICTER of
+ * the two, so a team can narrow what its root allows but never widen it.
+ */
+export declare function mergeConsumptionPolicies(root: ConsumptionPolicy, team: ConsumptionPolicy): ConsumptionPolicy;
+/**
+ * The policy an org's resolution runs under. A root org: its own row (or the
+ * defaults). A team (`rootOrgId` set): its root's policy, merged with the
+ * team's own row when it has one.
+ */
+export declare function effectiveConsumptionPolicy(rows: ReadonlyArray<Partial<PluginInstallPolicy> & {
+    orgId?: string;
+}>, orgId: string, rootOrgId?: string): ConsumptionPolicy;
+/**
+ * Validate a (partial) policy update over `base`. Returns the full new policy,
+ * or an error message. `blockedListings` entries are `{ publisher, name }` or
+ * `"publisher/name"`.
+ */
+export declare function applyPolicyUpdate(base: ConsumptionPolicy, input: unknown): ConsumptionPolicy | string;

package/lib/api/plugin-consumption-policy.js

@@ -0,0 +1,133 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * An org's plugin CONSUMPTION POLICY: which publisher tiers it trusts, which
+ * listings it blocks, which advisory severities block a resolution, and which
+ * tiers may receive secrets. Applied at every resolution (see
+ * ./plugin-resolution.ts) and edited through the org's policy row.
+ *
+ * Pure functions over the stored row — no I/O — so the same rules run in the
+ * resolver, in the policy-update route, and in tests.
+ */
+import { PUBLISHER_TIERS, } from '../database/drizzle-schema.js';
+/** The defaults (and the column defaults of `plugin_install_policies`). */
+export const DEFAULT_CONSUMPTION_POLICY = Object.freeze({
+    allowedTiers: ['official', 'verified'],
+    requireApprovalTiers: ['community', 'unverified'],
+    secretsAllowedTiers: ['official', 'verified'],
+    blockOnAdvisory: 'critical',
+    officialInstalls: 'implicit',
+    blockedListings: [],
+});
+/** At most this many blocked listings per policy. */
+export const MAX_BLOCKED_LISTINGS = 500;
+const BLOCK_ORDER = ['never', 'critical', 'high'];
+const sortTiers = (tiers) => PUBLISHER_TIERS.filter((t) => new Set(tiers).has(t));
+const listingKey = (r) => `${r.publisher}/${r.name}`;
+function uniqueListings(refs) {
+    const seen = new Map();
+    for (const r of refs)
+        seen.set(listingKey(r), { publisher: r.publisher, name: r.name });
+    return [...seen.values()].sort((a, b) => listingKey(a).localeCompare(listingKey(b)));
+}
+/** A stored policy row (or none) as a {@link ConsumptionPolicy}. */
+export function policyOf(row) {
+    const d = DEFAULT_CONSUMPTION_POLICY;
+    return {
+        allowedTiers: sortTiers(row?.allowedTiers ?? d.allowedTiers),
+        requireApprovalTiers: sortTiers(row?.requireApprovalTiers ?? d.requireApprovalTiers),
+        secretsAllowedTiers: sortTiers(row?.secretsAllowedTiers ?? d.secretsAllowedTiers),
+        blockOnAdvisory: row?.blockOnAdvisory ?? d.blockOnAdvisory,
+        officialInstalls: row?.officialInstalls ?? d.officialInstalls,
+        blockedListings: uniqueListings(row?.blockedListings ?? d.blockedListings),
+    };
+}
+/**
+ * A team's policy under its root org's: each field takes the STRICTER of
+ * the two, so a team can narrow what its root allows but never widen it.
+ */
+export function mergeConsumptionPolicies(root, team) {
+    const intersect = (a, b) => sortTiers(a.filter((t) => b.includes(t)));
+    const union = (a, b) => sortTiers([...a, ...b]);
+    const stricterBlock = BLOCK_ORDER.indexOf(root.blockOnAdvisory) >= BLOCK_ORDER.indexOf(team.blockOnAdvisory)
+        ? root.blockOnAdvisory : team.blockOnAdvisory;
+    return {
+        allowedTiers: intersect(root.allowedTiers, team.allowedTiers),
+        requireApprovalTiers: union(root.requireApprovalTiers, team.requireApprovalTiers),
+        secretsAllowedTiers: intersect(root.secretsAllowedTiers, team.secretsAllowedTiers),
+        blockOnAdvisory: stricterBlock,
+        officialInstalls: root.officialInstalls === 'explicit' || team.officialInstalls === 'explicit' ? 'explicit' : 'implicit',
+        blockedListings: uniqueListings([...root.blockedListings, ...team.blockedListings]),
+    };
+}
+/**
+ * The policy an org's resolution runs under. A root org: its own row (or the
+ * defaults). A team (`rootOrgId` set): its root's policy, merged with the
+ * team's own row when it has one.
+ */
+export function effectiveConsumptionPolicy(rows, orgId, rootOrgId) {
+    const own = rows.find((r) => r.orgId === orgId) ?? null;
+    if (!rootOrgId || rootOrgId === orgId)
+        return policyOf(own);
+    const root = policyOf(rows.find((r) => r.orgId === rootOrgId) ?? null);
+    return own ? mergeConsumptionPolicies(root, policyOf(own)) : root;
+}
+const HANDLE_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+const NAME_RE = /^[a-z0-9][a-z0-9._-]*$/;
+function tierList(v, field) {
+    if (!Array.isArray(v))
+        return `${field} must be an array of tiers`;
+    const bad = v.filter((t) => !PUBLISHER_TIERS.includes(t));
+    if (bad.length)
+        return `${field} has unknown tiers: ${bad.map(String).join(', ')}`;
+    return sortTiers(v);
+}
+/**
+ * Validate a (partial) policy update over `base`. Returns the full new policy,
+ * or an error message. `blockedListings` entries are `{ publisher, name }` or
+ * `"publisher/name"`.
+ */
+export function applyPolicyUpdate(base, input) {
+    if (!input || typeof input !== 'object' || Array.isArray(input))
+        return 'body must be an object';
+    const b = input;
+    const next = { ...base };
+    for (const field of ['allowedTiers', 'requireApprovalTiers', 'secretsAllowedTiers']) {
+        if (b[field] === undefined)
+            continue;
+        const tiers = tierList(b[field], field);
+        if (typeof tiers === 'string')
+            return tiers;
+        next[field] = tiers;
+    }
+    if (b.blockOnAdvisory !== undefined) {
+        if (!BLOCK_ORDER.includes(b.blockOnAdvisory))
+            return 'blockOnAdvisory must be critical, high or never';
+        next.blockOnAdvisory = b.blockOnAdvisory;
+    }
+    if (b.officialInstalls !== undefined) {
+        if (b.officialInstalls !== 'implicit' && b.officialInstalls !== 'explicit')
+            return 'officialInstalls must be implicit or explicit';
+        next.officialInstalls = b.officialInstalls;
+    }
+    if (b.blockedListings !== undefined) {
+        if (!Array.isArray(b.blockedListings))
+            return 'blockedListings must be an array';
+        if (b.blockedListings.length > MAX_BLOCKED_LISTINGS)
+            return `at most ${MAX_BLOCKED_LISTINGS} blocked listings`;
+        const refs = [];
+        for (const raw of b.blockedListings) {
+            const ref = typeof raw === 'string'
+                ? (() => { const [publisher, name, extra] = raw.split('/'); return extra === undefined ? { publisher, name } : null; })()
+                : raw && typeof raw === 'object' ? { publisher: raw.publisher, name: raw.name } : null;
+            if (!ref || typeof ref.publisher !== 'string' || typeof ref.name !== 'string'
+                || !HANDLE_RE.test(ref.publisher) || !NAME_RE.test(ref.name)) {
+                return 'each blocked listing must be { publisher, name } (or "publisher/name")';
+            }
+            refs.push({ publisher: ref.publisher, name: ref.name });
+        }
+        next.blockedListings = uniqueListings(refs);
+    }
+    return next;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin-consumption-policy.js","sourceRoot":"","sources":["../../src/api/plugin-consumption-policy.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * An org's plugin CONSUMPTION POLICY: which publisher tiers it trusts, which\n * listings it blocks, which advisory severities block a resolution, and which\n * tiers may receive secrets. Applied at every resolution (see\n * ./plugin-resolution.ts) and edited through the org's policy row.\n *\n * Pure functions over the stored row — no I/O — so the same rules run in the\n * resolver, in the policy-update route, and in tests.\n */\n\nimport {\n  type BlockedListingRef,\n  type BlockOnAdvisory,\n  type OfficialInstalls,\n  type PluginInstallPolicy,\n  type PublisherTier,\n  PUBLISHER_TIERS,\n} from '../database/drizzle-schema.js';\n\n\n/** An org's consumption policy, as the resolver applies it. */\nexport interface ConsumptionPolicy {\n  allowedTiers: PublisherTier[];\n  requireApprovalTiers: PublisherTier[];\n  secretsAllowedTiers: PublisherTier[];\n  blockOnAdvisory: BlockOnAdvisory;\n  officialInstalls: OfficialInstalls;\n  blockedListings: BlockedListingRef[];\n}\n\n/** The defaults (and the column defaults of `plugin_install_policies`). */\nexport const DEFAULT_CONSUMPTION_POLICY: Readonly<ConsumptionPolicy> = Object.freeze<ConsumptionPolicy>({\n  allowedTiers: ['official', 'verified'],\n  requireApprovalTiers: ['community', 'unverified'],\n  secretsAllowedTiers: ['official', 'verified'],\n  blockOnAdvisory: 'critical',\n  officialInstalls: 'implicit',\n  blockedListings: [],\n});\n\n/** At most this many blocked listings per policy. */\nexport const MAX_BLOCKED_LISTINGS = 500;\n\nconst BLOCK_ORDER: readonly BlockOnAdvisory[] = ['never', 'critical', 'high'];\n\nconst sortTiers = (tiers: Iterable<PublisherTier>): PublisherTier[] =>\n  PUBLISHER_TIERS.filter((t) => new Set(tiers).has(t));\n\nconst listingKey = (r: BlockedListingRef): string => `${r.publisher}/${r.name}`;\n\nfunction uniqueListings(refs: readonly BlockedListingRef[]): BlockedListingRef[] {\n  const seen = new Map<string, BlockedListingRef>();\n  for (const r of refs) seen.set(listingKey(r), { publisher: r.publisher, name: r.name });\n  return [...seen.values()].sort((a, b) => listingKey(a).localeCompare(listingKey(b)));\n}\n\n/** A stored policy row (or none) as a {@link ConsumptionPolicy}. */\nexport function policyOf(row: Partial<PluginInstallPolicy> | null | undefined): ConsumptionPolicy {\n  const d = DEFAULT_CONSUMPTION_POLICY;\n  return {\n    allowedTiers: sortTiers(row?.allowedTiers ?? d.allowedTiers),\n    requireApprovalTiers: sortTiers(row?.requireApprovalTiers ?? d.requireApprovalTiers),\n    secretsAllowedTiers: sortTiers(row?.secretsAllowedTiers ?? d.secretsAllowedTiers),\n    blockOnAdvisory: row?.blockOnAdvisory ?? d.blockOnAdvisory,\n    officialInstalls: row?.officialInstalls ?? d.officialInstalls,\n    blockedListings: uniqueListings(row?.blockedListings ?? d.blockedListings),\n  };\n}\n\n/**\n * A team's policy under its root org's: each field takes the STRICTER of\n * the two, so a team can narrow what its root allows but never widen it.\n */\nexport function mergeConsumptionPolicies(root: ConsumptionPolicy, team: ConsumptionPolicy): ConsumptionPolicy {\n  const intersect = (a: PublisherTier[], b: PublisherTier[]) => sortTiers(a.filter((t) => b.includes(t)));\n  const union = (a: PublisherTier[], b: PublisherTier[]) => sortTiers([...a, ...b]);\n  const stricterBlock = BLOCK_ORDER.indexOf(root.blockOnAdvisory) >= BLOCK_ORDER.indexOf(team.blockOnAdvisory)\n    ? root.blockOnAdvisory : team.blockOnAdvisory;\n  return {\n    allowedTiers: intersect(root.allowedTiers, team.allowedTiers),\n    requireApprovalTiers: union(root.requireApprovalTiers, team.requireApprovalTiers),\n    secretsAllowedTiers: intersect(root.secretsAllowedTiers, team.secretsAllowedTiers),\n    blockOnAdvisory: stricterBlock,\n    officialInstalls: root.officialInstalls === 'explicit' || team.officialInstalls === 'explicit' ? 'explicit' : 'implicit',\n    blockedListings: uniqueListings([...root.blockedListings, ...team.blockedListings]),\n  };\n}\n\n/**\n * The policy an org's resolution runs under. A root org: its own row (or the\n * defaults). A team (`rootOrgId` set): its root's policy, merged with the\n * team's own row when it has one.\n */\nexport function effectiveConsumptionPolicy(\n  rows: ReadonlyArray<Partial<PluginInstallPolicy> & { orgId?: string }>,\n  orgId: string,\n  rootOrgId?: string,\n): ConsumptionPolicy {\n  const own = rows.find((r) => r.orgId === orgId) ?? null;\n  if (!rootOrgId || rootOrgId === orgId) return policyOf(own);\n  const root = policyOf(rows.find((r) => r.orgId === rootOrgId) ?? null);\n  return own ? mergeConsumptionPolicies(root, policyOf(own)) : root;\n}\n\nconst HANDLE_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;\nconst NAME_RE = /^[a-z0-9][a-z0-9._-]*$/;\n\nfunction tierList(v: unknown, field: string): PublisherTier[] | string {\n  if (!Array.isArray(v)) return `${field} must be an array of tiers`;\n  const bad = v.filter((t) => !(PUBLISHER_TIERS as readonly unknown[]).includes(t));\n  if (bad.length) return `${field} has unknown tiers: ${bad.map(String).join(', ')}`;\n  return sortTiers(v as PublisherTier[]);\n}\n\n/**\n * Validate a (partial) policy update over `base`. Returns the full new policy,\n * or an error message. `blockedListings` entries are `{ publisher, name }` or\n * `\"publisher/name\"`.\n */\nexport function applyPolicyUpdate(base: ConsumptionPolicy, input: unknown): ConsumptionPolicy | string {\n  if (!input || typeof input !== 'object' || Array.isArray(input)) return 'body must be an object';\n  const b = input as Record<string, unknown>;\n  const next: ConsumptionPolicy = { ...base };\n  for (const field of ['allowedTiers', 'requireApprovalTiers', 'secretsAllowedTiers'] as const) {\n    if (b[field] === undefined) continue;\n    const tiers = tierList(b[field], field);\n    if (typeof tiers === 'string') return tiers;\n    next[field] = tiers;\n  }\n  if (b.blockOnAdvisory !== undefined) {\n    if (!BLOCK_ORDER.includes(b.blockOnAdvisory as BlockOnAdvisory)) return 'blockOnAdvisory must be critical, high or never';\n    next.blockOnAdvisory = b.blockOnAdvisory as BlockOnAdvisory;\n  }\n  if (b.officialInstalls !== undefined) {\n    if (b.officialInstalls !== 'implicit' && b.officialInstalls !== 'explicit') return 'officialInstalls must be implicit or explicit';\n    next.officialInstalls = b.officialInstalls;\n  }\n  if (b.blockedListings !== undefined) {\n    if (!Array.isArray(b.blockedListings)) return 'blockedListings must be an array';\n    if (b.blockedListings.length > MAX_BLOCKED_LISTINGS) return `at most ${MAX_BLOCKED_LISTINGS} blocked listings`;\n    const refs: BlockedListingRef[] = [];\n    for (const raw of b.blockedListings) {\n      const ref = typeof raw === 'string'\n        ? (() => { const [publisher, name, extra] = raw.split('/'); return extra === undefined ? { publisher, name } : null; })()\n        : raw && typeof raw === 'object' ? { publisher: (raw as BlockedListingRef).publisher, name: (raw as BlockedListingRef).name } : null;\n      if (!ref || typeof ref.publisher !== 'string' || typeof ref.name !== 'string'\n        || !HANDLE_RE.test(ref.publisher) || !NAME_RE.test(ref.name)) {\n        return 'each blocked listing must be { publisher, name } (or \"publisher/name\")';\n      }\n      refs.push({ publisher: ref.publisher, name: ref.name });\n    }\n    next.blockedListings = uniqueListings(refs);\n  }\n  return next;\n}\n"]}

package/lib/api/plugin-resolution.d.ts

@@ -33,41 +33,8 @@
  */
 import { type VulnFlaggedWarning } from '@pipeline-builder/api-core';
 import type { CrudTx } from './crud-service.js';
-import { type AdvisorySeverity, type BlockedListingRef, type BlockOnAdvisory, type OfficialInstalls, type PluginAdvisory, type PluginInstall, type PluginInstallPolicy, type PluginListing, type PluginListingVersion, type Publisher, type PublisherTier } from '../database/drizzle-schema.js';
-/** An org's consumption policy, as the resolver applies it. */
-export interface ConsumptionPolicy {
-    allowedTiers: PublisherTier[];
-    requireApprovalTiers: PublisherTier[];
-    secretsAllowedTiers: PublisherTier[];
-    blockOnAdvisory: BlockOnAdvisory;
-    officialInstalls: OfficialInstalls;
-    blockedListings: BlockedListingRef[];
-}
-/** The defaults (and the column defaults of `plugin_install_policies`). */
-export declare const DEFAULT_CONSUMPTION_POLICY: Readonly<ConsumptionPolicy>;
-/** At most this many blocked listings per policy. */
-export declare const MAX_BLOCKED_LISTINGS = 500;
-/** A stored policy row (or none) as a {@link ConsumptionPolicy}. */
-export declare function policyOf(row: Partial<PluginInstallPolicy> | null | undefined): ConsumptionPolicy;
-/**
- * A team's policy under its root org's: each field takes the STRICTER of
- * the two, so a team can narrow what its root allows but never widen it.
- */
-export declare function mergeConsumptionPolicies(root: ConsumptionPolicy, team: ConsumptionPolicy): ConsumptionPolicy;
-/**
- * The policy an org's resolution runs under. A root org: its own row (or the
- * defaults). A team (`rootOrgId` set): its root's policy, merged with the
- * team's own row when it has one.
- */
-export declare function effectiveConsumptionPolicy(rows: ReadonlyArray<Partial<PluginInstallPolicy> & {
-    orgId?: string;
-}>, orgId: string, rootOrgId?: string): ConsumptionPolicy;
-/**
- * Validate a (partial) policy update over `base`. Returns the full new policy,
- * or an error message. `blockedListings` entries are `{ publisher, name }` or
- * `"publisher/name"`.
- */
-export declare function applyPolicyUpdate(base: ConsumptionPolicy, input: unknown): ConsumptionPolicy | string;
+import { type ConsumptionPolicy } from './plugin-consumption-policy.js';
+import { type PluginAdvisory, type PluginInstall, type PluginInstallPolicy, type PluginListing, type PluginListingVersion, type Publisher } from '../database/drizzle-schema.js';
 /** Why a reference can't resolve; `code` is an api-core `ErrorCode` name. */
 export interface ResolutionRefusal {
     code: 'NOT_FOUND' | 'PLUGIN_NOT_INSTALLED' | 'PLUGIN_BLOCKED_BY_POLICY' | 'PLUGIN_UNAVAILABLE' | 'PLUGIN_VERSION_VULN_BLOCKED';
@@ -89,25 +56,6 @@ export interface ListingBlock {
 export declare function listingBlock(policy: ConsumptionPolicy, publisher: Pick<Publisher, 'handle' | 'tier' | 'suspendedAt'>, listing: Pick<PluginListing, 'name' | 'state'>): ListingBlock | null;
 /** The refusal a {@link ListingBlock} becomes. */
 export declare function blockRefusal(block: ListingBlock): ResolutionRefusal;
-/** Severities each `blockOnAdvisory` setting blocks. */
-export declare const ADVISORY_BLOCK_SEVERITIES: Readonly<Record<BlockOnAdvisory, readonly AdvisorySeverity[]>>;
-/**
- * Whether an advisory's `affectedRange` covers `version`: `||`-separated
- * comparator sets, each either the lookup spec forms (`^`, `~`, partial,
- * exact) or space-separated comparators (`>=1.0.0 <1.2.3`) or a hyphen range.
- * `*` covers everything; an unparseable range covers nothing.
- */
-export declare function advisoryRangeCovers(range: string, version: string): boolean;
-/**
- * Why `range` isn't a usable advisory range (the forms {@link advisoryRangeCovers}
- * understands), or null when it is. An advisory whose range parses as nothing
- * would silently cover nothing, so drafts are refused instead.
- */
-export declare function advisoryRangeProblem(range: string): string | null;
-/** The PUBLISHED advisories whose range covers `version` (any severity), most severe first. */
-export declare function advisoriesCovering<A extends Pick<PluginAdvisory, 'severity' | 'state' | 'affectedRange'>>(advisories: readonly A[], version: string): A[];
-/** The PUBLISHED advisories the policy blocks `version` for. */
-export declare function blockingAdvisories(advisories: readonly Pick<PluginAdvisory, 'id' | 'severity' | 'state' | 'affectedRange' | 'fixedVersion' | 'summary'>[], version: string, policy: Pick<ConsumptionPolicy, 'blockOnAdvisory'>): Array<Pick<PluginAdvisory, 'id' | 'severity' | 'state' | 'affectedRange' | 'fixedVersion' | 'summary'>>;
 /** How the org reaches a listing: an explicit install row, or the implicit Official one. */
 export type InstallMode = {
     kind: 'explicit';