@pipeline-builder/api-core 0.0.1

package/lib/types/quota-tiers.d.ts

@@ -0,0 +1,79 @@
+/** Available quota tier identifiers.
+ *
+ * `unlimited` is a special tier: every quota is `-1` (uncapped) and it includes
+ * every feature/add-on bundle. It is the DEFAULT when billing is disabled (no
+ * metering/enforcement surface exists, so nothing is capped), and it is NEVER
+ * shown or selectable when billing is enabled — see `STANDARD_TIERS`. */
+export type QuotaTier = 'developer' | 'pro' | 'team' | 'enterprise' | 'unlimited';
+/** Limit values for each quota type within a tier. */
+export interface QuotaTierLimits {
+    plugins: number;
+    pipelines: number;
+    apiCalls: number;
+    aiCalls: number;
+    /**
+     * Aggregate registry storage cap in BYTES. Counted across every repo
+     * under the org's `org-{orgId}/` namespace. -1 means unlimited.
+     * push-gate reads this; the image-registry rejects token issuance for
+     * `push` scope when the org's measured usage exceeds the limit.
+     */
+    storageBytes: number;
+    /** Count-quotas on the user-editable feature tables added to close per-org
+     *  DoS via spam. -1 means unlimited. */
+    dashboards: number;
+    alertRules: number;
+    alertDestinations: number;
+    idpConfigs: number;
+    /**
+     * Max org members (active users / seats). -1 = unlimited. This is the "Team"
+     * tier differentiator — enforced at member-invite time (an invite is blocked
+     * when active members + pending invites would exceed this).
+     */
+    seats: number;
+    /**
+     * Reporting retention in DAYS — NOT a flow quota (never decremented, absent
+     * from `VALID_QUOTA_TYPES`): these ride the tier-baseline + bundle-grant math
+     * purely as an entitlement the billing service syncs to reporting's
+     * `dora_settings`. -1 = unlimited (the sweep skips the org entirely).
+     *   `eventRetentionDays` — non-deploy `pipeline_events` (STAGE/ACTION/build).
+     *   `doraRetentionDays`  — deploy events + `deployment_outcomes` + `incidents`,
+     *                          and the per-org report-query window for DORA routes.
+     * Extendable via the `retention_pack` / `dora_history_pack` add-on bundles.
+     */
+    eventRetentionDays: number;
+    doraRetentionDays: number;
+}
+/** Full preset for a single tier (label + limits). */
+export interface QuotaTierPreset {
+    label: string;
+    limits: QuotaTierLimits;
+}
+export declare const QUOTA_TIERS: Record<QuotaTier, QuotaTierPreset>;
+/** All valid tier names (incl. `unlimited`). Used for validation of a *stored*
+ *  tier — `unlimited` is a valid value even though it's never offered for sale. */
+export declare const VALID_TIERS: readonly QuotaTier[];
+/** The standard, billing-selectable tiers — the ones offered as purchasable plans
+ *  and shown in tier pickers. Derived as "every valid tier except `unlimited`",
+ *  which is the billing-DISABLED default and is never displayed/selectable when
+ *  billing is enabled. Kept DRY off `VALID_TIERS` so adding a tier flows through. */
+export declare const STANDARD_TIERS: readonly QuotaTier[];
+/** Tiers that permit the org → team hierarchy (nesting teams under a root). The
+ *  billing-off `unlimited` tier is team-capable (it's the most permissive); the
+ *  entry-level `developer`/`pro` tiers are not. Single source for the parent-
+ *  eligibility + downgrade-overcap checks so they can't drift. */
+export declare const TEAM_CAPABLE_TIERS: readonly QuotaTier[];
+export declare function tierAllowsTeams(tier: string | undefined | null): boolean;
+/** Whether the billing service is enabled in this deployment (`BILLING_ENABLED`,
+ *  opt-out default-on — mirrors the billing/platform configs). With billing OFF
+ *  there's no metering/enforcement surface, so the default tier is `unlimited`. */
+export declare function isBillingEnabled(): boolean;
+/**
+ * Default tier assigned to new organizations.
+ * - Billing DISABLED → `unlimited` (nothing is metered, so everything is uncapped).
+ * - Billing ENABLED  → `DEFAULT_QUOTA_TIER` if it's a valid standard tier, else `developer`.
+ */
+export declare const DEFAULT_TIER: QuotaTier;
+/** Check whether a string is a valid QuotaTier. */
+export declare function isValidTier(value: string): value is QuotaTier;
+/** Get the default limits for a given tier (falls back to developer). */
+export declare function getTierLimits(tier: string): QuotaTierLimits;

package/lib/types/quota-tiers.js

@@ -0,0 +1,221 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Preset limits for each tier. -1 means unlimited.
+ *
+ * AI calls are sized much smaller than `apiCalls` because each call has
+ * external provider cost (~$0.01$0.10/call). Developer tier allows light
+ * exploration (50/period); Pro lifts to 2,500; Enterprise is capped high
+ * (25,000) — fair-use, not literally unlimited.
+ *
+ * `storageBytes` is the aggregate registry cap per org. Sized
+ * around plugin-image realities: a typical plugin image is 200500 MB;
+ * Developer's 2 GB holds ~4 versions × ~500 MB, Pro's 50 GB covers a
+ * mature catalog. Operators can override per-org via the quota CRUD API.
+ */
+const GB = 1024 * 1024 * 1024;
+/**
+ * Code-default limits per tier — the fallback when no env override is set.
+ * -1 means unlimited. (Counts sized to "comfortably enough for one team, not
+ * script spam": 20 dashboards, 50 alert rules, 10 destinations, 1 IdP config
+ * for Developer; scaled up for Pro; -1 (uncapped) for the cheap count-quotas
+ * on Team/Enterprise while cost-driving quotas — incl. apiCalls — stay finite.)
+ */
+const DEFAULT_TIER_LIMITS = {
+    // Free tier: single seat, 2 pipelines, apiCalls CAPPED (was unlimited — a
+    // DoS/abuse hole on a shared resource); aiCalls small (each has ~$0.01-0.10
+    // external cost). Lean base — growth happens by upgrading, not stacking here.
+    developer: {
+        plugins: 25,
+        pipelines: 2,
+        apiCalls: 25_000,
+        aiCalls: 25,
+        storageBytes: 2 * GB,
+        dashboards: 20,
+        alertRules: 50,
+        alertDestinations: 10,
+        idpConfigs: 1,
+        seats: 1,
+        eventRetentionDays: 30,
+        doraRetentionDays: 180,
+    },
+    // Pro = individual power user, single seat, individual pricing. A 2nd seat (or
+    // team collaboration) requires the Team tier — the `seat` add-on is Team+ only,
+    // keeping Team the collaboration tier. Pro's value over Developer is its richer
+    // call/storage/plugin ceilings + feature add-ons (SSO/audit/DORA), not seats.
+    pro: {
+        plugins: 50,
+        pipelines: 5,
+        apiCalls: 250_000,
+        aiCalls: 1_000,
+        storageBytes: 25 * GB,
+        dashboards: 200,
+        alertRules: 500,
+        alertDestinations: 50,
+        idpConfigs: 5,
+        seats: 1,
+        eventRetentionDays: 30,
+        doraRetentionDays: 180,
+    },
+    // Team = collaboration tier; the seat limit (3) is the real differentiator over
+    // Pro (single-seat) — it's the multi-seat collaboration floor. Lean base ($79):
+    // growth rides the seat/pipeline/etc add-ons (land-and-expand). Limits sit
+    // between Pro and Enterprise.
+    team: {
+        plugins: 75,
+        pipelines: 6,
+        apiCalls: 500_000,
+        aiCalls: 2_500,
+        storageBytes: 60 * GB,
+        dashboards: -1,
+        alertRules: -1,
+        alertDestinations: -1,
+        idpConfigs: 5,
+        seats: 3,
+        eventRetentionDays: 30,
+        doraRetentionDays: 180,
+    },
+    // Enterprise ($599, held): the all-inclusive tier — 15 seats, 30 pipelines, ALL
+    // premium features included (see TIER_FEATURES). FAIR-USE — cost drivers (apiCalls,
+    // aiCalls, storageBytes) capped so one account can't run up unbounded
+    // compute/provider/storage cost on a flat price; cheap count-quotas stay -1.
+    enterprise: {
+        plugins: 150,
+        pipelines: 30,
+        apiCalls: 900_000,
+        aiCalls: 9_000,
+        storageBytes: 250 * GB,
+        dashboards: -1,
+        alertRules: -1,
+        alertDestinations: -1,
+        idpConfigs: -1,
+        seats: 15,
+        eventRetentionDays: 30,
+        doraRetentionDays: 180,
+    },
+    // Unlimited: EVERY quota uncapped (-1). The default when billing is disabled
+    // (no enforcement surface) — never shown/selectable when billing is enabled.
+    unlimited: {
+        plugins: -1,
+        pipelines: -1,
+        apiCalls: -1,
+        aiCalls: -1,
+        storageBytes: -1,
+        dashboards: -1,
+        alertRules: -1,
+        alertDestinations: -1,
+        idpConfigs: -1,
+        seats: -1,
+        eventRetentionDays: -1,
+        doraRetentionDays: -1,
+    },
+};
+/**
+ * Read an integer env var, falling back to the code default. `-1` = unlimited.
+ * Rejects (→ fallback) anything that isn't a clean integer string and any value
+ * `< -1`: a decimal (`50.5`) or a nonsense negative (`-5`) would otherwise ship a
+ * broken finite limit (parity with `envCents`'s rigor for prices).
+ */
+function envInt(name, fallback) {
+    const raw = process.env[name];
+    if (raw === undefined || raw === '')
+        return fallback;
+    const trimmed = raw.trim();
+    if (!/^-?\d+$/.test(trimmed))
+        return fallback; // no decimals / non-numeric
+    const n = parseInt(trimmed, 10);
+    return Number.isNaN(n) || n < -1 ? fallback : n;
+}
+/** Read a string env var, falling back to the code default. */
+function envStr(name, fallback) {
+    const raw = process.env[name];
+    return raw === undefined || raw === '' ? fallback : raw;
+}
+/**
+ * Per-tier limits, each overridable via `QUOTA_TIER_<TIER>_<LIMIT>` env vars
+ * (e.g. `QUOTA_TIER_PRO_PIPELINES=250`, `QUOTA_TIER_DEVELOPER_STORAGE_BYTES=...`).
+ * Unset/empty → the code default. `-1` = unlimited. Read once at module load —
+ * on k8s these flow in via the `app-env` ConfigMap (built from `.env`).
+ */
+function tierLimits(tier) {
+    // `unlimited` is uncapped BY DEFINITION: EVERY quota is -1 and it is NOT
+    // env-overridable. Reading QUOTA_TIER_UNLIMITED_* here would let a stray env
+    // var silently cap the billing-DISABLED default tier — surfacing as a spurious
+    // "quota exceeded" on a deploy that meters nothing. Derive -1 for every field
+    // from the limits shape so a newly-added quota is uncapped here automatically.
+    if (tier === 'unlimited') {
+        const uncapped = { ...DEFAULT_TIER_LIMITS.unlimited };
+        for (const k of Object.keys(uncapped))
+            uncapped[k] = -1;
+        return uncapped;
+    }
+    const d = DEFAULT_TIER_LIMITS[tier];
+    const T = tier.toUpperCase();
+    return {
+        plugins: envInt(`QUOTA_TIER_${T}_PLUGINS`, d.plugins),
+        pipelines: envInt(`QUOTA_TIER_${T}_PIPELINES`, d.pipelines),
+        apiCalls: envInt(`QUOTA_TIER_${T}_API_CALLS`, d.apiCalls),
+        aiCalls: envInt(`QUOTA_TIER_${T}_AI_CALLS`, d.aiCalls),
+        storageBytes: envInt(`QUOTA_TIER_${T}_STORAGE_BYTES`, d.storageBytes),
+        dashboards: envInt(`QUOTA_TIER_${T}_DASHBOARDS`, d.dashboards),
+        alertRules: envInt(`QUOTA_TIER_${T}_ALERT_RULES`, d.alertRules),
+        alertDestinations: envInt(`QUOTA_TIER_${T}_ALERT_DESTINATIONS`, d.alertDestinations),
+        idpConfigs: envInt(`QUOTA_TIER_${T}_IDP_CONFIGS`, d.idpConfigs),
+        seats: envInt(`QUOTA_TIER_${T}_SEATS`, d.seats),
+        eventRetentionDays: envInt(`QUOTA_TIER_${T}_EVENT_RETENTION_DAYS`, d.eventRetentionDays),
+        doraRetentionDays: envInt(`QUOTA_TIER_${T}_DORA_RETENTION_DAYS`, d.doraRetentionDays),
+    };
+}
+// Labels are overridable via `QUOTA_TIER_<TIER>_LABEL` (display name only).
+export const QUOTA_TIERS = {
+    developer: { label: envStr('QUOTA_TIER_DEVELOPER_LABEL', 'Developer'), limits: tierLimits('developer') },
+    pro: { label: envStr('QUOTA_TIER_PRO_LABEL', 'Pro'), limits: tierLimits('pro') },
+    team: { label: envStr('QUOTA_TIER_TEAM_LABEL', 'Team'), limits: tierLimits('team') },
+    enterprise: { label: envStr('QUOTA_TIER_ENTERPRISE_LABEL', 'Enterprise'), limits: tierLimits('enterprise') },
+    unlimited: { label: envStr('QUOTA_TIER_UNLIMITED_LABEL', 'Unlimited'), limits: tierLimits('unlimited') },
+};
+/** All valid tier names (incl. `unlimited`). Used for validation of a *stored*
+ *  tier — `unlimited` is a valid value even though it's never offered for sale. */
+export const VALID_TIERS = Object.keys(QUOTA_TIERS);
+/** The standard, billing-selectable tiers — the ones offered as purchasable plans
+ *  and shown in tier pickers. Derived as "every valid tier except `unlimited`",
+ *  which is the billing-DISABLED default and is never displayed/selectable when
+ *  billing is enabled. Kept DRY off `VALID_TIERS` so adding a tier flows through. */
+export const STANDARD_TIERS = VALID_TIERS.filter((t) => t !== 'unlimited');
+/** Tiers that permit the org → team hierarchy (nesting teams under a root). The
+ *  billing-off `unlimited` tier is team-capable (it's the most permissive); the
+ *  entry-level `developer`/`pro` tiers are not. Single source for the parent-
+ *  eligibility + downgrade-overcap checks so they can't drift. */
+export const TEAM_CAPABLE_TIERS = ['team', 'enterprise', 'unlimited'];
+export function tierAllowsTeams(tier) {
+    return !!tier && TEAM_CAPABLE_TIERS.includes(tier);
+}
+/** Whether the billing service is enabled in this deployment (`BILLING_ENABLED`,
+ *  opt-out default-on — mirrors the billing/platform configs). With billing OFF
+ *  there's no metering/enforcement surface, so the default tier is `unlimited`. */
+export function isBillingEnabled() {
+    return (process.env.BILLING_ENABLED || 'true').toLowerCase() !== 'false';
+}
+/**
+ * Default tier assigned to new organizations.
+ * - Billing DISABLED → `unlimited` (nothing is metered, so everything is uncapped).
+ * - Billing ENABLED  → `DEFAULT_QUOTA_TIER` if it's a valid standard tier, else `developer`.
+ */
+export const DEFAULT_TIER = !isBillingEnabled()
+    ? 'unlimited'
+    : (isValidTier(process.env.DEFAULT_QUOTA_TIER ?? '') && process.env.DEFAULT_QUOTA_TIER !== 'unlimited'
+        ? process.env.DEFAULT_QUOTA_TIER
+        : 'developer');
+/** Check whether a string is a valid QuotaTier. */
+export function isValidTier(value) {
+    // Use the explicit tuple, not `value in QUOTA_TIERS`: `in` walks the prototype
+    // chain, so inherited Object keys ('toString', 'constructor', …) would return
+    // true and then `getTierLimits` would read `.limits` off a function → crash.
+    // `tier` is attacker-influenceable (JWT / request body / DEFAULT_QUOTA_TIER env).
+    return VALID_TIERS.includes(value);
+}
+/** Get the default limits for a given tier (falls back to developer). */
+export function getTierLimits(tier) {
+    return isValidTier(tier) ? QUOTA_TIERS[tier].limits : QUOTA_TIERS.developer.limits;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"quota-tiers.js","sourceRoot":"","sources":["../../src/types/quota-tiers.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/** Available quota tier identifiers.\n *\n * `unlimited` is a special tier: every quota is `-1` (uncapped) and it includes\n * every feature/add-on bundle. It is the DEFAULT when billing is disabled (no\n * metering/enforcement surface exists, so nothing is capped), and it is NEVER\n * shown or selectable when billing is enabled — see `STANDARD_TIERS`. */\nexport type QuotaTier = 'developer' | 'pro' | 'team' | 'enterprise' | 'unlimited';\n\n/** Limit values for each quota type within a tier. */\nexport interface QuotaTierLimits {\n  plugins: number;\n  pipelines: number;\n  apiCalls: number;\n  aiCalls: number;\n  /**\n   * Aggregate registry storage cap in BYTES. Counted across every repo\n   * under the org's `org-{orgId}/` namespace. -1 means unlimited.\n   * push-gate reads this; the image-registry rejects token issuance for\n   * `push` scope when the org's measured usage exceeds the limit.\n   */\n  storageBytes: number;\n  /** Count-quotas on the user-editable feature tables added to close per-org\n   *  DoS via spam. -1 means unlimited. */\n  dashboards: number;\n  alertRules: number;\n  alertDestinations: number;\n  idpConfigs: number;\n  /**\n   * Max org members (active users / seats). -1 = unlimited. This is the \"Team\"\n   * tier differentiator — enforced at member-invite time (an invite is blocked\n   * when active members + pending invites would exceed this).\n   */\n  seats: number;\n  /**\n   * Reporting retention in DAYS — NOT a flow quota (never decremented, absent\n   * from `VALID_QUOTA_TYPES`): these ride the tier-baseline + bundle-grant math\n   * purely as an entitlement the billing service syncs to reporting's\n   * `dora_settings`. -1 = unlimited (the sweep skips the org entirely).\n   *   `eventRetentionDays` — non-deploy `pipeline_events` (STAGE/ACTION/build).\n   *   `doraRetentionDays`  — deploy events + `deployment_outcomes` + `incidents`,\n   *                          and the per-org report-query window for DORA routes.\n   * Extendable via the `retention_pack` / `dora_history_pack` add-on bundles.\n   */\n  eventRetentionDays: number;\n  doraRetentionDays: number;\n}\n\n/** Full preset for a single tier (label + limits). */\nexport interface QuotaTierPreset {\n  label: string;\n  limits: QuotaTierLimits;\n}\n\n/**\n * Preset limits for each tier. -1 means unlimited.\n *\n * AI calls are sized much smaller than `apiCalls` because each call has\n * external provider cost (~$0.01$0.10/call). Developer tier allows light\n * exploration (50/period); Pro lifts to 2,500; Enterprise is capped high\n * (25,000) — fair-use, not literally unlimited.\n *\n * `storageBytes` is the aggregate registry cap per org. Sized\n * around plugin-image realities: a typical plugin image is 200500 MB;\n * Developer's 2 GB holds ~4 versions × ~500 MB, Pro's 50 GB covers a\n * mature catalog. Operators can override per-org via the quota CRUD API.\n */\nconst GB = 1024 * 1024 * 1024;\n\n/**\n * Code-default limits per tier — the fallback when no env override is set.\n * -1 means unlimited. (Counts sized to \"comfortably enough for one team, not\n * script spam\": 20 dashboards, 50 alert rules, 10 destinations, 1 IdP config\n * for Developer; scaled up for Pro; -1 (uncapped) for the cheap count-quotas\n * on Team/Enterprise while cost-driving quotas — incl. apiCalls — stay finite.)\n */\nconst DEFAULT_TIER_LIMITS: Record<QuotaTier, QuotaTierLimits> = {\n  // Free tier: single seat, 2 pipelines, apiCalls CAPPED (was unlimited — a\n  // DoS/abuse hole on a shared resource); aiCalls small (each has ~$0.01-0.10\n  // external cost). Lean base — growth happens by upgrading, not stacking here.\n  developer: {\n    plugins: 25,\n    pipelines: 2,\n    apiCalls: 25_000,\n    aiCalls: 25,\n    storageBytes: 2 * GB,\n    dashboards: 20,\n    alertRules: 50,\n    alertDestinations: 10,\n    idpConfigs: 1,\n    seats: 1,\n    eventRetentionDays: 30,\n    doraRetentionDays: 180,\n  },\n  // Pro = individual power user, single seat, individual pricing. A 2nd seat (or\n  // team collaboration) requires the Team tier — the `seat` add-on is Team+ only,\n  // keeping Team the collaboration tier. Pro's value over Developer is its richer\n  // call/storage/plugin ceilings + feature add-ons (SSO/audit/DORA), not seats.\n  pro: {\n    plugins: 50,\n    pipelines: 5,\n    apiCalls: 250_000,\n    aiCalls: 1_000,\n    storageBytes: 25 * GB,\n    dashboards: 200,\n    alertRules: 500,\n    alertDestinations: 50,\n    idpConfigs: 5,\n    seats: 1,\n    eventRetentionDays: 30,\n    doraRetentionDays: 180,\n  },\n  // Team = collaboration tier; the seat limit (3) is the real differentiator over\n  // Pro (single-seat) — it's the multi-seat collaboration floor. Lean base ($79):\n  // growth rides the seat/pipeline/etc add-ons (land-and-expand). Limits sit\n  // between Pro and Enterprise.\n  team: {\n    plugins: 75,\n    pipelines: 6,\n    apiCalls: 500_000,\n    aiCalls: 2_500,\n    storageBytes: 60 * GB,\n    dashboards: -1,\n    alertRules: -1,\n    alertDestinations: -1,\n    idpConfigs: 5,\n    seats: 3,\n    eventRetentionDays: 30,\n    doraRetentionDays: 180,\n  },\n  // Enterprise ($599, held): the all-inclusive tier — 15 seats, 30 pipelines, ALL\n  // premium features included (see TIER_FEATURES). FAIR-USE — cost drivers (apiCalls,\n  // aiCalls, storageBytes) capped so one account can't run up unbounded\n  // compute/provider/storage cost on a flat price; cheap count-quotas stay -1.\n  enterprise: {\n    plugins: 150,\n    pipelines: 30,\n    apiCalls: 900_000,\n    aiCalls: 9_000,\n    storageBytes: 250 * GB,\n    dashboards: -1,\n    alertRules: -1,\n    alertDestinations: -1,\n    idpConfigs: -1,\n    seats: 15,\n    eventRetentionDays: 30,\n    doraRetentionDays: 180,\n  },\n  // Unlimited: EVERY quota uncapped (-1). The default when billing is disabled\n  // (no enforcement surface) — never shown/selectable when billing is enabled.\n  unlimited: {\n    plugins: -1,\n    pipelines: -1,\n    apiCalls: -1,\n    aiCalls: -1,\n    storageBytes: -1,\n    dashboards: -1,\n    alertRules: -1,\n    alertDestinations: -1,\n    idpConfigs: -1,\n    seats: -1,\n    eventRetentionDays: -1,\n    doraRetentionDays: -1,\n  },\n};\n\n/**\n * Read an integer env var, falling back to the code default. `-1` = unlimited.\n * Rejects (→ fallback) anything that isn't a clean integer string and any value\n * `< -1`: a decimal (`50.5`) or a nonsense negative (`-5`) would otherwise ship a\n * broken finite limit (parity with `envCents`'s rigor for prices).\n */\nfunction envInt(name: string, fallback: number): number {\n  const raw = process.env[name];\n  if (raw === undefined || raw === '') return fallback;\n  const trimmed = raw.trim();\n  if (!/^-?\\d+$/.test(trimmed)) return fallback; // no decimals / non-numeric\n  const n = parseInt(trimmed, 10);\n  return Number.isNaN(n) || n < -1 ? fallback : n;\n}\n\n/** Read a string env var, falling back to the code default. */\nfunction envStr(name: string, fallback: string): string {\n  const raw = process.env[name];\n  return raw === undefined || raw === '' ? fallback : raw;\n}\n\n/**\n * Per-tier limits, each overridable via `QUOTA_TIER_<TIER>_<LIMIT>` env vars\n * (e.g. `QUOTA_TIER_PRO_PIPELINES=250`, `QUOTA_TIER_DEVELOPER_STORAGE_BYTES=...`).\n * Unset/empty → the code default. `-1` = unlimited. Read once at module load —\n * on k8s these flow in via the `app-env` ConfigMap (built from `.env`).\n */\nfunction tierLimits(tier: QuotaTier): QuotaTierLimits {\n  // `unlimited` is uncapped BY DEFINITION: EVERY quota is -1 and it is NOT\n  // env-overridable. Reading QUOTA_TIER_UNLIMITED_* here would let a stray env\n  // var silently cap the billing-DISABLED default tier — surfacing as a spurious\n  // \"quota exceeded\" on a deploy that meters nothing. Derive -1 for every field\n  // from the limits shape so a newly-added quota is uncapped here automatically.\n  if (tier === 'unlimited') {\n    const uncapped = { ...DEFAULT_TIER_LIMITS.unlimited };\n    for (const k of Object.keys(uncapped) as (keyof QuotaTierLimits)[]) uncapped[k] = -1;\n    return uncapped;\n  }\n  const d = DEFAULT_TIER_LIMITS[tier];\n  const T = tier.toUpperCase();\n  return {\n    plugins: envInt(`QUOTA_TIER_${T}_PLUGINS`, d.plugins),\n    pipelines: envInt(`QUOTA_TIER_${T}_PIPELINES`, d.pipelines),\n    apiCalls: envInt(`QUOTA_TIER_${T}_API_CALLS`, d.apiCalls),\n    aiCalls: envInt(`QUOTA_TIER_${T}_AI_CALLS`, d.aiCalls),\n    storageBytes: envInt(`QUOTA_TIER_${T}_STORAGE_BYTES`, d.storageBytes),\n    dashboards: envInt(`QUOTA_TIER_${T}_DASHBOARDS`, d.dashboards),\n    alertRules: envInt(`QUOTA_TIER_${T}_ALERT_RULES`, d.alertRules),\n    alertDestinations: envInt(`QUOTA_TIER_${T}_ALERT_DESTINATIONS`, d.alertDestinations),\n    idpConfigs: envInt(`QUOTA_TIER_${T}_IDP_CONFIGS`, d.idpConfigs),\n    seats: envInt(`QUOTA_TIER_${T}_SEATS`, d.seats),\n    eventRetentionDays: envInt(`QUOTA_TIER_${T}_EVENT_RETENTION_DAYS`, d.eventRetentionDays),\n    doraRetentionDays: envInt(`QUOTA_TIER_${T}_DORA_RETENTION_DAYS`, d.doraRetentionDays),\n  };\n}\n\n// Labels are overridable via `QUOTA_TIER_<TIER>_LABEL` (display name only).\nexport const QUOTA_TIERS: Record<QuotaTier, QuotaTierPreset> = {\n  developer: { label: envStr('QUOTA_TIER_DEVELOPER_LABEL', 'Developer'), limits: tierLimits('developer') },\n  pro: { label: envStr('QUOTA_TIER_PRO_LABEL', 'Pro'), limits: tierLimits('pro') },\n  team: { label: envStr('QUOTA_TIER_TEAM_LABEL', 'Team'), limits: tierLimits('team') },\n  enterprise: { label: envStr('QUOTA_TIER_ENTERPRISE_LABEL', 'Enterprise'), limits: tierLimits('enterprise') },\n  unlimited: { label: envStr('QUOTA_TIER_UNLIMITED_LABEL', 'Unlimited'), limits: tierLimits('unlimited') },\n};\n\n/** All valid tier names (incl. `unlimited`). Used for validation of a *stored*\n *  tier — `unlimited` is a valid value even though it's never offered for sale. */\nexport const VALID_TIERS: readonly QuotaTier[] = Object.keys(QUOTA_TIERS) as QuotaTier[];\n\n/** The standard, billing-selectable tiers — the ones offered as purchasable plans\n *  and shown in tier pickers. Derived as \"every valid tier except `unlimited`\",\n *  which is the billing-DISABLED default and is never displayed/selectable when\n *  billing is enabled. Kept DRY off `VALID_TIERS` so adding a tier flows through. */\nexport const STANDARD_TIERS: readonly QuotaTier[] = VALID_TIERS.filter((t) => t !== 'unlimited');\n\n/** Tiers that permit the org → team hierarchy (nesting teams under a root). The\n *  billing-off `unlimited` tier is team-capable (it's the most permissive); the\n *  entry-level `developer`/`pro` tiers are not. Single source for the parent-\n *  eligibility + downgrade-overcap checks so they can't drift. */\nexport const TEAM_CAPABLE_TIERS: readonly QuotaTier[] = ['team', 'enterprise', 'unlimited'];\nexport function tierAllowsTeams(tier: string | undefined | null): boolean {\n  return !!tier && (TEAM_CAPABLE_TIERS as readonly string[]).includes(tier);\n}\n\n/** Whether the billing service is enabled in this deployment (`BILLING_ENABLED`,\n *  opt-out default-on — mirrors the billing/platform configs). With billing OFF\n *  there's no metering/enforcement surface, so the default tier is `unlimited`. */\nexport function isBillingEnabled(): boolean {\n  return (process.env.BILLING_ENABLED || 'true').toLowerCase() !== 'false';\n}\n\n/**\n * Default tier assigned to new organizations.\n * - Billing DISABLED → `unlimited` (nothing is metered, so everything is uncapped).\n * - Billing ENABLED  → `DEFAULT_QUOTA_TIER` if it's a valid standard tier, else `developer`.\n */\nexport const DEFAULT_TIER: QuotaTier = !isBillingEnabled()\n  ? 'unlimited'\n  : (isValidTier(process.env.DEFAULT_QUOTA_TIER ?? '') && process.env.DEFAULT_QUOTA_TIER !== 'unlimited'\n    ? (process.env.DEFAULT_QUOTA_TIER as QuotaTier)\n    : 'developer');\n\n/** Check whether a string is a valid QuotaTier. */\nexport function isValidTier(value: string): value is QuotaTier {\n  // Use the explicit tuple, not `value in QUOTA_TIERS`: `in` walks the prototype\n  // chain, so inherited Object keys ('toString', 'constructor', …) would return\n  // true and then `getTierLimits` would read `.limits` off a function → crash.\n  // `tier` is attacker-influenceable (JWT / request body / DEFAULT_QUOTA_TIER env).\n  return (VALID_TIERS as readonly string[]).includes(value);\n}\n\n/** Get the default limits for a given tier (falls back to developer). */\nexport function getTierLimits(tier: string): QuotaTierLimits {\n  return isValidTier(tier) ? QUOTA_TIERS[tier].limits: QUOTA_TIERS.developer.limits;\n}\n"]}

package/lib/types/visibility.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The single sharing model for every catalog entity: pipelines, plugins,
+ * pipeline templates, and dashboards.
+ *
+ * Three rungs, widening left to right:
+ *
+ * - `private` — only the AUTHOR (`createdBy`) can see or edit it. A personal
+ *   draft: somewhere to iterate before anyone else is affected.
+ * - `org`     — everyone in the owning org can see it; the resource's `:write`
+ *   permission edits it. This is the default working state for shared content.
+ * - `public`  — shared beyond the org: a team also sees its parent org's public
+ *   rows, and the system org's public rows are the shared catalog every org
+ *   sees. Requires the resource's `:publish` permission.
+ *
+ * Enforcement lives in exactly two places, so no entity can drift:
+ * `AccessControlQueryBuilder` builds the read predicate, and
+ * `requireVisibilityWriteAccess` gates the writes.
+ */
+export declare const VISIBILITIES: readonly ['private', 'org', 'public'];
+export type Visibility = (typeof VISIBILITIES)[number];

package/lib/types/visibility.js

@@ -0,0 +1,22 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * The single sharing model for every catalog entity: pipelines, plugins,
+ * pipeline templates, and dashboards.
+ *
+ * Three rungs, widening left to right:
+ *
+ * - `private` — only the AUTHOR (`createdBy`) can see or edit it. A personal
+ *   draft: somewhere to iterate before anyone else is affected.
+ * - `org`     — everyone in the owning org can see it; the resource's `:write`
+ *   permission edits it. This is the default working state for shared content.
+ * - `public`  — shared beyond the org: a team also sees its parent org's public
+ *   rows, and the system org's public rows are the shared catalog every org
+ *   sees. Requires the resource's `:publish` permission.
+ *
+ * Enforcement lives in exactly two places, so no entity can drift:
+ * `AccessControlQueryBuilder` builds the read predicate, and
+ * `requireVisibilityWriteAccess` gates the writes.
+ */
+export const VISIBILITIES = ['private', 'org', 'public'];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmlzaWJpbGl0eS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90eXBlcy92aXNpYmlsaXR5LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLCtDQUErQztBQUMvQyxzQ0FBc0M7QUFFdEM7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBaUJHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sWUFBWSxHQUFHLENBQUMsU0FBUyxFQUFFLEtBQUssRUFBRSxRQUFRLENBQVUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIENvcHlyaWdodCAyMDI2IFBpcGVsaW5lIEJ1aWxkZXIgQ29udHJpYnV0b3JzXG4vLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogQXBhY2hlLTIuMFxuXG4vKipcbiAqIFRoZSBzaW5nbGUgc2hhcmluZyBtb2RlbCBmb3IgZXZlcnkgY2F0YWxvZyBlbnRpdHk6IHBpcGVsaW5lcywgcGx1Z2lucyxcbiAqIHBpcGVsaW5lIHRlbXBsYXRlcywgYW5kIGRhc2hib2FyZHMuXG4gKlxuICogVGhyZWUgcnVuZ3MsIHdpZGVuaW5nIGxlZnQgdG8gcmlnaHQ6XG4gKlxuICogLSBgcHJpdmF0ZWAg4oCUIG9ubHkgdGhlIEFVVEhPUiAoYGNyZWF0ZWRCeWApIGNhbiBzZWUgb3IgZWRpdCBpdC4gQSBwZXJzb25hbFxuICogICBkcmFmdDogc29tZXdoZXJlIHRvIGl0ZXJhdGUgYmVmb3JlIGFueW9uZSBlbHNlIGlzIGFmZmVjdGVkLlxuICogLSBgb3JnYCAgICAg4oCUIGV2ZXJ5b25lIGluIHRoZSBvd25pbmcgb3JnIGNhbiBzZWUgaXQ7IHRoZSByZXNvdXJjZSdzIGA6d3JpdGVgXG4gKiAgIHBlcm1pc3Npb24gZWRpdHMgaXQuIFRoaXMgaXMgdGhlIGRlZmF1bHQgd29ya2luZyBzdGF0ZSBmb3Igc2hhcmVkIGNvbnRlbnQuXG4gKiAtIGBwdWJsaWNgICDigJQgc2hhcmVkIGJleW9uZCB0aGUgb3JnOiBhIHRlYW0gYWxzbyBzZWVzIGl0cyBwYXJlbnQgb3JnJ3MgcHVibGljXG4gKiAgIHJvd3MsIGFuZCB0aGUgc3lzdGVtIG9yZydzIHB1YmxpYyByb3dzIGFyZSB0aGUgc2hhcmVkIGNhdGFsb2cgZXZlcnkgb3JnXG4gKiAgIHNlZXMuIFJlcXVpcmVzIHRoZSByZXNvdXJjZSdzIGA6cHVibGlzaGAgcGVybWlzc2lvbi5cbiAqXG4gKiBFbmZvcmNlbWVudCBsaXZlcyBpbiBleGFjdGx5IHR3byBwbGFjZXMsIHNvIG5vIGVudGl0eSBjYW4gZHJpZnQ6XG4gKiBgQWNjZXNzQ29udHJvbFF1ZXJ5QnVpbGRlcmAgYnVpbGRzIHRoZSByZWFkIHByZWRpY2F0ZSwgYW5kXG4gKiBgcmVxdWlyZVZpc2liaWxpdHlXcml0ZUFjY2Vzc2AgZ2F0ZXMgdGhlIHdyaXRlcy5cbiAqL1xuZXhwb3J0IGNvbnN0IFZJU0lCSUxJVElFUyA9IFsncHJpdmF0ZScsICdvcmcnLCAncHVibGljJ10gYXMgY29uc3Q7XG5leHBvcnQgdHlwZSBWaXNpYmlsaXR5ID0gKHR5cGVvZiBWSVNJQklMSVRJRVMpW251bWJlcl07XG4iXX0=

package/lib/utils/alias-resolver.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Clear the memoized alias set so the next access re-reads `SUPPORT_ALIASES`.
+ * The cache is process-lifetime by design (env is fixed per process); this hook
+ * exists so tests can vary the env between cases.
+ */
+export declare function resetSupportAliasesCache(): void;
+/** Well-known fallback support alias used when SUPPORT_ALIASES is unconfigured. */
+export declare const DEFAULT_SUPPORT_ALIAS = "support@pipeline-builder";
+/**
+ * The PRIMARY (first-configured) support alias — for display / prefill in UIs
+ * (e.g. the compose "To" field), so the shown value is driven by SUPPORT_ALIASES
+ * rather than hardcoded. Falls back to {@link DEFAULT_SUPPORT_ALIAS} when the env
+ * is unset. (All configured aliases still resolve via {@link resolveRecipientAlias}.)
+ */
+export declare function getPrimarySupportAlias(): string;
+/**
+ * ALL configured support aliases (order preserved), for UIs that surface every
+ * support inbox as a distinct recipient suggestion. Falls back to a single
+ * {@link DEFAULT_SUPPORT_ALIAS} when SUPPORT_ALIASES is unset.
+ */
+export declare function getAllSupportAliases(): string[];
+/** Result of alias resolution. */
+export interface AliasResolution {
+    /** The resolved organization ID (e.g., 'system'). */
+    resolvedOrgId: string;
+    /** Whether the input was an alias that got resolved. */
+    wasAlias: boolean;
+    /** The original input value, useful for audit logging. */
+    originalValue: string;
+}
+/**
+ * Resolve an email-like alias to an actual organization ID.
+ *
+ * If the input matches a configured support alias, it resolves to the system
+ * org ID. Otherwise the input is returned as-is (lowercased).
+ */
+export declare function resolveRecipientAlias(recipientOrgId: string): AliasResolution;

package/lib/utils/alias-resolver.js

@@ -0,0 +1,68 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { SYSTEM_ORG_ID } from '../middleware/auth.js';
+/** Lazily-cached set of support aliases, parsed from SUPPORT_ALIASES on first access. */
+let _supportAliases;
+function getSupportAliases() {
+    if (!_supportAliases) {
+        const raw = process.env.SUPPORT_ALIASES || '';
+        _supportAliases = new Set(raw
+            .split(',')
+            .map(alias => alias.trim().toLowerCase())
+            .filter(alias => alias.length > 0));
+    }
+    return _supportAliases;
+}
+/**
+ * Clear the memoized alias set so the next access re-reads `SUPPORT_ALIASES`.
+ * The cache is process-lifetime by design (env is fixed per process); this hook
+ * exists so tests can vary the env between cases.
+ */
+export function resetSupportAliasesCache() {
+    _supportAliases = undefined;
+}
+/** Well-known fallback support alias used when SUPPORT_ALIASES is unconfigured. */
+export const DEFAULT_SUPPORT_ALIAS = 'support@pipeline-builder';
+/**
+ * The PRIMARY (first-configured) support alias — for display / prefill in UIs
+ * (e.g. the compose "To" field), so the shown value is driven by SUPPORT_ALIASES
+ * rather than hardcoded. Falls back to {@link DEFAULT_SUPPORT_ALIAS} when the env
+ * is unset. (All configured aliases still resolve via {@link resolveRecipientAlias}.)
+ */
+export function getPrimarySupportAlias() {
+    for (const alias of getSupportAliases())
+        return alias;
+    return DEFAULT_SUPPORT_ALIAS;
+}
+/**
+ * ALL configured support aliases (order preserved), for UIs that surface every
+ * support inbox as a distinct recipient suggestion. Falls back to a single
+ * {@link DEFAULT_SUPPORT_ALIAS} when SUPPORT_ALIASES is unset.
+ */
+export function getAllSupportAliases() {
+    const all = [...getSupportAliases()];
+    return all.length > 0 ? all : [DEFAULT_SUPPORT_ALIAS];
+}
+/**
+ * Resolve an email-like alias to an actual organization ID.
+ *
+ * If the input matches a configured support alias, it resolves to the system
+ * org ID. Otherwise the input is returned as-is (lowercased).
+ */
+export function resolveRecipientAlias(recipientOrgId) {
+    const normalized = recipientOrgId.trim().toLowerCase();
+    const aliases = getSupportAliases();
+    if (aliases.has(normalized)) {
+        return {
+            resolvedOrgId: SYSTEM_ORG_ID,
+            wasAlias: true,
+            originalValue: recipientOrgId,
+        };
+    }
+    return {
+        resolvedOrgId: normalized,
+        wasAlias: false,
+        originalValue: recipientOrgId,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/utils/audit.d.ts

@@ -0,0 +1,15 @@
+import type winston from 'winston';
+import type { AuditEvent } from '../types/audit-events.js';
+/**
+ * Emit a cross-service audit event as a structured log line.
+ *
+ * Best-effort: if the underlying logger transport fails, the caller's
+ * mutation still succeeds — we never let audit-write failure roll back
+ * the user-visible operation. The line is tagged `eventCategory: 'audit'`
+ * so downstream log aggregators (Loki, CloudWatch) can route audit
+ * events into a separate index.
+ *
+ * For platform's own audit events (user.login, org.create, …), use
+ * platform's `helpers/audit.ts` instead — those persist to MongoDB.
+ */
+export declare function emitAudit(logger: winston.Logger, audit: AuditEvent): void;

package/lib/utils/audit.js

@@ -0,0 +1,39 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { scrubAwsIdentifiers } from './aws-scrub.js';
+/**
+ * Emit a cross-service audit event as a structured log line.
+ *
+ * Best-effort: if the underlying logger transport fails, the caller's
+ * mutation still succeeds — we never let audit-write failure roll back
+ * the user-visible operation. The line is tagged `eventCategory: 'audit'`
+ * so downstream log aggregators (Loki, CloudWatch) can route audit
+ * events into a separate index.
+ *
+ * For platform's own audit events (user.login, org.create, …), use
+ * platform's `helpers/audit.ts` instead — those persist to MongoDB.
+ */
+export function emitAudit(logger, audit) {
+    try {
+        // Scrub any AWS account-id-shaped values (e.g. an ARN in `details`) before the
+        // event lands in the durable log store — the logger's secret-key redaction
+        // doesn't cover account ids, and this is exactly the persistence boundary the
+        // "never persist an AWS account id" rule targets.
+        logger.info('audit', scrubAwsIdentifiers({ eventCategory: 'audit', ...audit }));
+    }
+    catch (err) {
+        // The winston logger normally never throws synchronously, but if a
+        // transport explodes during a route call, we don't want the mutation
+        // to fail because the audit write didn't land.
+        try {
+            logger.warn('Failed to emit audit event', {
+                event: audit.event,
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+        catch {
+            // Logger itself is unrecoverable — give up silently.
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/utils/aws-scrub.d.ts

@@ -0,0 +1,11 @@
+/** Redact every AWS-account-id-shaped token (incl. the account field of any ARN) from a string. */
+export declare function scrubAwsIdentifiersFromString(input: string): string;
+/**
+ * Deep-scrub a value (string / array / plain object) of AWS account identifiers,
+ * returning a scrubbed copy — the input is never mutated. String values have
+ * account-id tokens redacted; any key matching {@link ACCOUNT_KEY_RE} with a
+ * string/number value is redacted wholesale. Non-string primitives pass through
+ * unchanged (a bare number is only redacted when it sits under an account-named
+ * key, to avoid clobbering legitimate numeric fields).
+ */
+export declare function scrubAwsIdentifiers<T>(value: T): T;