@pipeline-builder/api-core 3.4.101 → 3.4.102

package/lib/testing/tier-mock.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Shared tier fixture for the per-package `@pipeline-builder/api-core` test
+ * mocks (each suite's `test/helpers/mock-api-core.ts`).
+ *
+ * WHY A SEPARATE MODULE: every service mocks `@pipeline-builder/api-core` via
+ * `jest.unstable_mockModule('@pipeline-builder/api-core', …)`. That intercepts the
+ * *package* specifier only — this file is imported through the DEEP built path
+ * `@pipeline-builder/api-core/lib/testing/tier-mock.js`, a different specifier the
+ * mock does NOT intercept, so a mock can pull real, complete tier data without
+ * self-referencing its own mock. api-core has no `exports` map, so the subpath
+ * resolves; both sides are ESM so there's no interop wrinkle.
+ *
+ * WHAT IT BUYS: the tier NAME LIST is sourced from the real `VALID_TIERS`, so
+ * adding a tier in `quota-tiers.ts` flows into every mock automatically — no more
+ * "add a tier → hand-edit N mocks, discover the misses one gate round at a time"
+ * (which is exactly how the `unlimited` tier broke pipeline-core/api-server/platform).
+ * `mockQuotaTiers()` builds a COMPLETE `QUOTA_TIERS` (an entry for every tier) from
+ * caller-supplied per-tier limits, defaulting any unspecified tier to uncapped — so
+ * a new tier can never leave a `QUOTA_TIERS[tier].limits` undefined at mock load.
+ */
+import { type FeatureFlag } from '../types/feature-flags.js';
+import { type QuotaTier, type QuotaTierLimits } from '../types/quota-tiers.js';
+/** The real, complete tier-name list — the single source mocks derive from. */
+export declare const MOCK_TIER_NAMES: readonly QuotaTier[];
+/** Mirrors api-core's `isValidTier`, driven by the shared name list. */
+export declare const mockIsValidTier: (t: string) => boolean;
+type TierPreset = {
+    label: string;
+    limits: QuotaTierLimits;
+};
+/**
+ * Build a COMPLETE `QUOTA_TIERS` map (one entry per real tier) for a mock.
+ * Pass the per-tier limit overrides a suite actually asserts on; every other
+ * dimension (and every unspecified tier) falls back to uncapped, so the map is
+ * always exhaustive over `VALID_TIERS` — the property that keeps a newly-added
+ * tier from crashing mock load.
+ */
+export declare function mockQuotaTiers(limitsByTier?: Partial<Record<QuotaTier, Partial<QuotaTierLimits>>>): Record<QuotaTier, TierPreset>;
+/**
+ * Build a COMPLETE `TIER_FEATURES` map. Defaults every tier to all feature flags
+ * (the common mock stance); pass overrides for suites that assert a narrower set.
+ */
+export declare function mockTierFeatures(featuresByTier?: Partial<Record<QuotaTier, readonly FeatureFlag[]>>): Record<QuotaTier, readonly FeatureFlag[]>;
+export {};

package/lib/testing/tier-mock.js

@@ -0,0 +1,63 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Shared tier fixture for the per-package `@pipeline-builder/api-core` test
+ * mocks (each suite's `test/helpers/mock-api-core.ts`).
+ *
+ * WHY A SEPARATE MODULE: every service mocks `@pipeline-builder/api-core` via
+ * `jest.unstable_mockModule('@pipeline-builder/api-core', …)`. That intercepts the
+ * *package* specifier only — this file is imported through the DEEP built path
+ * `@pipeline-builder/api-core/lib/testing/tier-mock.js`, a different specifier the
+ * mock does NOT intercept, so a mock can pull real, complete tier data without
+ * self-referencing its own mock. api-core has no `exports` map, so the subpath
+ * resolves; both sides are ESM so there's no interop wrinkle.
+ *
+ * WHAT IT BUYS: the tier NAME LIST is sourced from the real `VALID_TIERS`, so
+ * adding a tier in `quota-tiers.ts` flows into every mock automatically — no more
+ * "add a tier → hand-edit N mocks, discover the misses one gate round at a time"
+ * (which is exactly how the `unlimited` tier broke pipeline-core/api-server/platform).
+ * `mockQuotaTiers()` builds a COMPLETE `QUOTA_TIERS` (an entry for every tier) from
+ * caller-supplied per-tier limits, defaulting any unspecified tier to uncapped — so
+ * a new tier can never leave a `QUOTA_TIERS[tier].limits` undefined at mock load.
+ */
+import { ALL_FEATURE_FLAGS } from '../types/feature-flags.js';
+import { VALID_TIERS } from '../types/quota-tiers.js';
+/** The real, complete tier-name list — the single source mocks derive from. */
+export const MOCK_TIER_NAMES = VALID_TIERS;
+/** Mirrors api-core's `isValidTier`, driven by the shared name list. */
+export const mockIsValidTier = (t) => MOCK_TIER_NAMES.includes(t);
+/** Every quota dimension uncapped — the default for tiers a caller doesn't specify. */
+const uncappedLimits = () => ({
+    seats: -1,
+    plugins: -1,
+    pipelines: -1,
+    apiCalls: -1,
+    aiCalls: -1,
+    storageBytes: -1,
+    dashboards: -1,
+    alertRules: -1,
+    alertDestinations: -1,
+    idpConfigs: -1,
+});
+const titleCase = (t) => t.charAt(0).toUpperCase() + t.slice(1);
+/**
+ * Build a COMPLETE `QUOTA_TIERS` map (one entry per real tier) for a mock.
+ * Pass the per-tier limit overrides a suite actually asserts on; every other
+ * dimension (and every unspecified tier) falls back to uncapped, so the map is
+ * always exhaustive over `VALID_TIERS` — the property that keeps a newly-added
+ * tier from crashing mock load.
+ */
+export function mockQuotaTiers(limitsByTier = {}) {
+    return Object.fromEntries(MOCK_TIER_NAMES.map((t) => [
+        t,
+        { label: titleCase(t), limits: { ...uncappedLimits(), ...(limitsByTier[t] ?? {}) } },
+    ]));
+}
+/**
+ * Build a COMPLETE `TIER_FEATURES` map. Defaults every tier to all feature flags
+ * (the common mock stance); pass overrides for suites that assert a narrower set.
+ */
+export function mockTierFeatures(featuresByTier = {}) {
+    return Object.fromEntries(MOCK_TIER_NAMES.map((t) => [t, featuresByTier[t] ?? [...ALL_FEATURE_FLAGS]]));
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -41,8 +41,9 @@ export declare const QUOTA_TIERS: Record<QuotaTier, QuotaTierPreset>;
  *  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. Excludes `unlimited`, which is the billing-DISABLED
- *  default and is never displayed/selectable when billing is enabled. */
+ *  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[];
 /** Whether the billing service is enabled in this deployment (`BILLING_ENABLED`,
  *  opt-out default-on — mirrors the billing/platform configs). With billing OFF

package/lib/types/quota-tiers.js

@@ -140,9 +140,10 @@ export const QUOTA_TIERS = {
  *  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. Excludes `unlimited`, which is the billing-DISABLED
- *  default and is never displayed/selectable when billing is enabled. */
-export const STANDARD_TIERS = ['developer', 'pro', 'team', 'enterprise'];
+ *  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');
 /** 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`. */
@@ -171,4 +172,4 @@ export function isValidTier(value) {
 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\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, apiCalls CAPPED (was unlimited — a DoS/abuse hole\n  // on a shared resource); aiCalls small (each has ~$0.01-0.10 external cost).\n  developer: {\n    plugins: 25,\n    pipelines: 5,\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  },\n  // Pro = one power user, individual pricing.\n  pro: {\n    plugins: 50,\n    pipelines: 10,\n    apiCalls: 500_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  },\n  // Team = collaboration tier; the seat limit (10) is the real differentiator\n  // over Pro. Limits sit between Pro and Enterprise.\n  team: {\n    plugins: 100,\n    pipelines: 200,\n    apiCalls: 2_000_000,\n    aiCalls: 5_000,\n    storageBytes: 150 * GB,\n    dashboards: -1,\n    alertRules: -1,\n    alertDestinations: -1,\n    idpConfigs: 5,\n    seats: 10,\n  },\n  // Enterprise: org-wide, high seat cap. FAIR-USE — cost drivers (apiCalls,\n  // aiCalls, storageBytes) capped high 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: 250,\n    pipelines: 200,\n    apiCalls: 10_000_000,\n    aiCalls: 15_000,\n    storageBytes: 500 * GB,\n    dashboards: -1,\n    alertRules: -1,\n    alertDestinations: -1,\n    idpConfigs: -1,\n    seats: 25,\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  },\n};\n\n/** Read an integer env var, falling back to the code default. `-1` = unlimited. */\nfunction envInt(name: string, fallback: number): number {\n  const raw = process.env[name];\n  if (raw === undefined || raw === '') return fallback;\n  const n = parseInt(raw, 10);\n  return Number.isNaN(n) ? 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  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  };\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. Excludes `unlimited`, which is the billing-DISABLED\n *  default and is never displayed/selectable when billing is enabled. */\nexport const STANDARD_TIERS: readonly QuotaTier[] = ['developer', 'pro', 'team', 'enterprise'];\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"]}
+//# 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\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, apiCalls CAPPED (was unlimited — a DoS/abuse hole\n  // on a shared resource); aiCalls small (each has ~$0.01-0.10 external cost).\n  developer: {\n    plugins: 25,\n    pipelines: 5,\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  },\n  // Pro = one power user, individual pricing.\n  pro: {\n    plugins: 50,\n    pipelines: 10,\n    apiCalls: 500_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  },\n  // Team = collaboration tier; the seat limit (10) is the real differentiator\n  // over Pro. Limits sit between Pro and Enterprise.\n  team: {\n    plugins: 100,\n    pipelines: 200,\n    apiCalls: 2_000_000,\n    aiCalls: 5_000,\n    storageBytes: 150 * GB,\n    dashboards: -1,\n    alertRules: -1,\n    alertDestinations: -1,\n    idpConfigs: 5,\n    seats: 10,\n  },\n  // Enterprise: org-wide, high seat cap. FAIR-USE — cost drivers (apiCalls,\n  // aiCalls, storageBytes) capped high 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: 250,\n    pipelines: 200,\n    apiCalls: 10_000_000,\n    aiCalls: 15_000,\n    storageBytes: 500 * GB,\n    dashboards: -1,\n    alertRules: -1,\n    alertDestinations: -1,\n    idpConfigs: -1,\n    seats: 25,\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  },\n};\n\n/** Read an integer env var, falling back to the code default. `-1` = unlimited. */\nfunction envInt(name: string, fallback: number): number {\n  const raw = process.env[name];\n  if (raw === undefined || raw === '') return fallback;\n  const n = parseInt(raw, 10);\n  return Number.isNaN(n) ? 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  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  };\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/** 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/package.json

@@ -87,7 +87,7 @@
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
-  "version": "3.4.101",
+  "version": "3.4.102",
   "bugs": {
     "url": "https://github.com/mwashburn160/pipeline-builder/issues"
   },