@saasicat/nest 1.0.0-rc.2 → 1.0.0-rc.21

package/dist/{chunk-NHVDCYK5.js → chunk-R5YCJBHY.js}

@@ -1,21 +1,26 @@
 import {
   FEATURE_GUARD_MARKER,
+  PLAN_CATALOG_UNREADABLE_ERROR,
   PUBLIC_CATALOG_BUNDLE_REPOSITORY_TOKEN,
   PUBLIC_CATALOG_CATALOG_ENTRY_REPOSITORY_TOKEN,
-  PUBLIC_CATALOG_PROJECT_KEY_TOKEN,
+  PlanCatalogValidationError,
   REQUIRE_FEATURE_KEY,
+  loadPlanCatalogFromString,
   periodEndAfter
-} from "./chunk-6Z7JR4EW.js";
+} from "./chunk-M47BNEY2.js";
+import {
+  EnforceMfa
+} from "./chunk-34XVPR6P.js";
 import {
   EntitlementService,
   isLimitExceededError
-} from "./chunk-VIJ5NJWC.js";
+} from "./chunk-G6EZWECL.js";
 import {
   ENTITLEMENT_SERVICE_TOKEN
 } from "./chunk-OUDSQ3PU.js";
 import {
   asProvider
-} from "./chunk-SABTXESR.js";
+} from "./chunk-J7NJRK3K.js";
 import {
   __name
 } from "./chunk-SHUYVCID.js";
@@ -71,6 +76,8 @@ __name(assertOptimisticLockHeld, "assertOptimisticLockHeld");
 function decideRenewal(sub, now) {
   if (!sub.pendingPlanVersionId || !sub.pendingPlanVersionEffectiveAt) return "SKIP";
   if (sub.pendingPlanVersionEffectiveAt > now) return "SKIP";
+  const landedAt = sub.canceledEffectiveAt ?? sub.canceledAt;
+  if (landedAt !== null && landedAt <= now) return "SKIP";
   if (sub.pendingPlanVersionNonRegressive || sub.pendingPlanVersionAccepted) {
     return "ROLL_FORWARD";
   }
@@ -90,14 +97,16 @@ function clearPendingPlanVersionFields() {
 }
 __name(clearPendingPlanVersionFields, "clearPendingPlanVersionFields");
 function computeNextPeriod(sub, now) {
-  if (sub.canceledAt !== null) return null;
   if (sub.currentPeriodEnd === null) return null;
   if (sub.currentPeriodEnd > now) return null;
+  const landedAt = sub.canceledEffectiveAt ?? sub.canceledAt;
+  if (landedAt !== null && landedAt <= now) return null;
   const newStart = sub.currentPeriodEnd;
-  const newEnd = periodEndAfter(newStart, sub.billingCycle, now);
+  const newEnd = periodEndAfter(newStart, sub.billingCycle, now, sub.billingAnchorDay ?? void 0);
   return {
     currentPeriodStart: newStart,
-    currentPeriodEnd: newEnd
+    currentPeriodEnd: newEnd,
+    minimumTermUntil: newEnd
   };
 }
 __name(computeNextPeriod, "computeNextPeriod");
@@ -261,12 +270,10 @@ var CatalogBundleUpsellResolver = class {
     __name(this, "CatalogBundleUpsellResolver");
   }
   bundleRepo;
-  projectKey;
   catalogEntryRepo;
   currency;
-  constructor(bundleRepo, projectKey, catalogEntryRepo = null, currency = null) {
+  constructor(bundleRepo, catalogEntryRepo = null, currency = null) {
     this.bundleRepo = bundleRepo;
-    this.projectKey = projectKey;
     this.catalogEntryRepo = catalogEntryRepo;
     this.currency = currency;
   }
@@ -296,15 +303,12 @@ var CatalogBundleUpsellResolver = class {
    */
   async lookupUnmetRequires(featureKeys) {
     if (!this.catalogEntryRepo) return [];
-    const rows = await this.catalogEntryRepo.listFeatures({
-      projectKey: this.projectKey
-    });
+    const rows = await this.catalogEntryRepo.listFeatures({});
     return collectUnsatisfiedRequires(featureKeys, buildFeatureRequiresIndex(rows));
   }
   /** Only published-and-live AND marketed — non-marketed bundles are not an offer. */
   async listLiveMarketedBundles() {
     const stems = await this.bundleRepo.list({
-      projectKey: this.projectKey,
       excludeDeleted: true
     });
     const out = [];
@@ -327,15 +331,13 @@ var CatalogBundleUpsellResolver = class {
 CatalogBundleUpsellResolver = _ts_decorate2([
   Injectable2(),
   _ts_param2(0, Inject2(PUBLIC_CATALOG_BUNDLE_REPOSITORY_TOKEN)),
-  _ts_param2(1, Inject2(PUBLIC_CATALOG_PROJECT_KEY_TOKEN)),
+  _ts_param2(1, Optional2()),
+  _ts_param2(1, Inject2(PUBLIC_CATALOG_CATALOG_ENTRY_REPOSITORY_TOKEN)),
   _ts_param2(2, Optional2()),
-  _ts_param2(2, Inject2(PUBLIC_CATALOG_CATALOG_ENTRY_REPOSITORY_TOKEN)),
-  _ts_param2(3, Optional2()),
-  _ts_param2(3, Inject2(UPSELL_OFFER_CURRENCY_TOKEN)),
+  _ts_param2(2, Inject2(UPSELL_OFFER_CURRENCY_TOKEN)),
   _ts_metadata2("design:type", Function),
   _ts_metadata2("design:paramtypes", [
     typeof BundleRepository === "undefined" ? Object : BundleRepository,
-    String,
     Object,
     Object
   ])
@@ -398,82 +400,6 @@ LimitExceededFilter = _ts_decorate3([
   Catch()
 ], LimitExceededFilter);
 
-// src/billing/plan-catalog-loader.ts
-import { readFileSync } from "fs";
-import { resolve as resolvePath } from "path";
-import yaml from "js-yaml";
-import Ajv2020 from "ajv/dist/2020.js";
-import addFormats from "ajv-formats";
-import { planCatalogSchema } from "@saasicat/spec";
-var PlanCatalogValidationError = class extends Error {
-  static {
-    __name(this, "PlanCatalogValidationError");
-  }
-  source;
-  errors;
-  constructor(source, errors) {
-    const messages = errors.map((e) => `${e.instancePath || "/"}: ${e.message ?? "unknown"}`).join("\n  ");
-    super(`Plan catalog validation failed for ${source}:
-  ${messages}`), this.source = source, this.errors = errors;
-    this.name = "PlanCatalogValidationError";
-  }
-};
-function loadPlanCatalogFromFile(opts) {
-  const absolutePath = resolvePath(opts.path);
-  const raw = readFileSync(absolutePath, "utf-8");
-  return loadPlanCatalogFromString(raw, {
-    source: absolutePath,
-    crossFieldChecks: opts.crossFieldChecks ?? true
-  });
-}
-__name(loadPlanCatalogFromFile, "loadPlanCatalogFromFile");
-function loadPlanCatalogFromString(yamlContent, opts) {
-  const parsed = yaml.load(yamlContent);
-  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
-    throw new Error(`The YAML content of ${opts.source} is not an object`);
-  }
-  const ajv = new Ajv2020({
-    strict: false,
-    allErrors: true
-  });
-  addFormats.default(ajv);
-  const validate = ajv.compile(planCatalogSchema);
-  if (!validate(parsed)) {
-    throw new PlanCatalogValidationError(opts.source, validate.errors ?? []);
-  }
-  const catalog = parsed;
-  if (opts.crossFieldChecks ?? true) {
-    validateConsistency(catalog, opts.source);
-  }
-  return catalog;
-}
-__name(loadPlanCatalogFromString, "loadPlanCatalogFromString");
-function validateConsistency(catalog, source) {
-  const errors = [];
-  const declaredFeatureKeys = new Set((catalog.features ?? []).map((f) => f.key));
-  const planIds = /* @__PURE__ */ new Set();
-  for (const plan of catalog.plans ?? []) {
-    if (planIds.has(plan.id)) {
-      errors.push(`plans[].id: duplicate plan id "${plan.id}"`);
-    }
-    planIds.add(plan.id);
-    if (catalog.features) {
-      for (const fk of plan.features) {
-        if (!declaredFeatureKeys.has(fk)) {
-          errors.push(`plans[id=${plan.id}].features: Unknown featureKey "${fk}" \u2014 not declared in catalog.features`);
-        }
-      }
-    }
-  }
-  if (errors.length > 0) {
-    const err = new Error(`Plan catalog consistency error in ${source}:
-  ${errors.join("\n  ")}`);
-    err.name = "PlanCatalogConsistencyError";
-    throw err;
-  }
-}
-__name(validateConsistency, "validateConsistency");
-
 // src/billing/plan-catalog-importer.service.ts
 import { Inject as Inject3, Injectable as Injectable3 } from "@nestjs/common";
 function _ts_decorate4(decorators, target, key, desc) {
@@ -529,7 +455,6 @@ var PlanCatalogImporterService = class {
     };
     for (const feature of catalog.features ?? []) {
       const result = await this.sink.upsertFeatureCatalogEntry({
-        projectKey: catalog.projectKey,
         featureKey: feature.key,
         label: feature.label,
         icon: feature.icon,
@@ -541,7 +466,6 @@ var PlanCatalogImporterService = class {
     }
     for (const plan of catalog.plans ?? []) {
       const planResult = await this.sink.upsertPlan({
-        projectKey: catalog.projectKey,
         planKey: plan.id,
         label: plan.name ?? plan.id,
         description: plan.tagline ?? null
@@ -552,13 +476,17 @@ var PlanCatalogImporterService = class {
         report.warnings.push(`Plan '${plan.id}' has no monthlyNet \u2014 skipped (on-request plans need a manual plan version).`);
         continue;
       }
+      if (plan.yearlyNet === null || plan.yearlyNet === void 0) {
+        report.warnings.push(`Plan '${plan.id}' has no yearlyNet \u2014 skipped (a plan version needs a yearly price; set one in the catalog or publish the version manually).`);
+        continue;
+      }
       const versionResult = await this.sink.upsertPlanVersion({
         planKey: plan.id,
         version: 1,
         features: plan.features,
         quotas: plan.quotas,
         monthlyNet: plan.monthlyNet.toFixed(2),
-        yearlyNet: (plan.yearlyNet ?? plan.monthlyNet * 10).toFixed(2),
+        yearlyNet: plan.yearlyNet.toFixed(2),
         marketed: plan.marketed ?? true,
         publish: true,
         changeNote: IMPORT_CHANGE_NOTE
@@ -582,8 +510,9 @@ PlanCatalogImporterService = _ts_decorate4([
 import { Module } from "@nestjs/common";
 
 // src/billing/plan-catalog-importer.controller.ts
-import { Body, Controller, Inject as Inject4, Post, UseGuards } from "@nestjs/common";
+import { BadRequestException, Body, Controller, Inject as Inject4, Post, UseGuards } from "@nestjs/common";
 import { IsBoolean, IsOptional, IsString, MinLength } from "class-validator";
+import { CATALOG_ERROR_CODES } from "@saasicat/core";
 function _ts_decorate5(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -618,6 +547,15 @@ _ts_decorate5([
   IsBoolean(),
   _ts_metadata4("design:type", Boolean)
 ], PlanCatalogImportDto.prototype, "crossFieldChecks", void 0);
+var UNREADABLE_ERROR_NAMES = /* @__PURE__ */ new Set([
+  "YAMLException",
+  "YAMLParseError",
+  PLAN_CATALOG_UNREADABLE_ERROR
+]);
+function isUnreadableDocument(error) {
+  return error instanceof Error && UNREADABLE_ERROR_NAMES.has(error.name);
+}
+__name(isUnreadableDocument, "isUnreadableDocument");
 function buildPlanCatalogImporterController(guards) {
   let GeneratedPlanCatalogImporterController = class GeneratedPlanCatalogImporterController {
     static {
@@ -627,14 +565,45 @@ function buildPlanCatalogImporterController(guards) {
     constructor(service) {
       this.service = service;
     }
+    /**
+     * A body that does not parse or does not validate is the caller's
+     * mistake, so it answers 400.
+     *
+     * Without this it answered 500: the loader throws a plain `Error` for
+     * unparseable YAML and a `PlanCatalogValidationError` for a schema or
+     * cross-field violation, and neither is an HTTP exception. A caller
+     * cannot tell a bad upload from a broken server that way, and the one
+     * they can fix is the one that looked unfixable.
+     */
     async import(dto) {
-      return this.service.importFromYaml(dto.yamlContent, {
-        crossFieldChecks: dto.crossFieldChecks
-      });
+      try {
+        return await this.service.importFromYaml(dto.yamlContent, {
+          crossFieldChecks: dto.crossFieldChecks
+        });
+      } catch (error) {
+        if (error instanceof PlanCatalogValidationError) {
+          throw new BadRequestException({
+            code: CATALOG_ERROR_CODES.PLAN_CATALOG_INVALID,
+            message: error.message,
+            params: {
+              message: error.message,
+              errors: error.errors
+            }
+          });
+        }
+        if (isUnreadableDocument(error)) {
+          throw new BadRequestException({
+            code: CATALOG_ERROR_CODES.PLAN_CATALOG_UNREADABLE,
+            message: error.message
+          });
+        }
+        throw error;
+      }
     }
   };
   _ts_decorate5([
     Post("import"),
+    EnforceMfa(),
     _ts_param4(0, Body()),
     _ts_metadata4("design:type", Function),
     _ts_metadata4("design:paramtypes", [
@@ -724,7 +693,6 @@ var ConfiguratorCatalogBuilder = class {
       m
     ]));
     return {
-      cycleDiscount: marketing.getCycleDiscount(),
       currency: marketing.getCurrency(),
       vatRate: marketing.getVatRate(),
       models: planRows.filter((row) => row.marketed).map((row) => buildModel(row, planMarketingByPlanId)).filter((m) => m !== null)
@@ -779,9 +747,6 @@ export {
   FeatureGuard,
   CatalogBundleUpsellResolver,
   LimitExceededFilter,
-  PlanCatalogValidationError,
-  loadPlanCatalogFromFile,
-  loadPlanCatalogFromString,
   PLAN_CATALOG_IMPORT_SINK_TOKEN,
   PlanCatalogImporterService,
   PlanCatalogImportDto,

package/dist/{chunk-XBYAFEOR.js → chunk-S33SO5XX.js}

@@ -2,7 +2,7 @@ import {
   DISCOVERY_APP_INFO_TOKEN,
   DISCOVERY_SNAPSHOT_PATH_TOKEN,
   DiscoveryScanner
-} from "./chunk-WXYJHZCN.js";
+} from "./chunk-JVAEKTJ4.js";
 import {
   DISCOVERY_SNAPSHOT_TOKEN
 } from "./chunk-QUZU2M33.js";

package/dist/chunk-SZ7RFPXA.js

@@ -0,0 +1,10 @@
+// src/admin/admin.tokens.ts
+var MFA_PORT_TOKEN = /* @__PURE__ */ Symbol.for("saasicat/nest/MfaPort");
+var AUDIT_PORT_TOKEN = /* @__PURE__ */ Symbol.for("saasicat/nest/AuditPort");
+var RLS_BYPASS_PORT_TOKEN = /* @__PURE__ */ Symbol.for("saasicat/nest/RlsBypassPort");
+
+export {
+  MFA_PORT_TOKEN,
+  AUDIT_PORT_TOKEN,
+  RLS_BYPASS_PORT_TOKEN
+};

package/dist/chunk-TBBZWZQT.js

@@ -0,0 +1,98 @@
+import {
+  assertTaxRatePercent,
+  grossFromNet
+} from "./chunk-6PJE7EWO.js";
+import {
+  __name
+} from "./chunk-SHUYVCID.js";
+
+// src/billing/plan-helpers.ts
+import { BILLING_ERROR_CODES } from "@saasicat/core";
+function findPlan(catalog, planId) {
+  return (catalog.plans ?? []).find((p) => p.id === planId);
+}
+__name(findPlan, "findPlan");
+function getPlanOrThrow(catalog, planId) {
+  const plan = findPlan(catalog, planId);
+  if (!plan) {
+    throw new Error(`Plan "${planId}" is not in the catalog`);
+  }
+  return plan;
+}
+__name(getPlanOrThrow, "getPlanOrThrow");
+function getMarketedPlans(catalog) {
+  return (catalog.plans ?? []).filter((p) => p.marketed !== false);
+}
+__name(getMarketedPlans, "getMarketedPlans");
+function getPlanPriceNet(catalog, planId, cycle) {
+  const plan = findPlan(catalog, planId);
+  return plan ? listPriceNet(plan, cycle) : null;
+}
+__name(getPlanPriceNet, "getPlanPriceNet");
+function listPriceNet(plan, cycle) {
+  if (plan.marketed === false) return null;
+  const net = cycle === "YEARLY" ? plan.yearlyNet : plan.monthlyNet;
+  return net ?? null;
+}
+__name(listPriceNet, "listPriceNet");
+function isPlanNotSoldInCycle(plan, cycle) {
+  if (plan.marketed === false) return false;
+  return (cycle === "YEARLY" ? plan.yearlyNet : plan.monthlyNet) == null;
+}
+__name(isPlanNotSoldInCycle, "isPlanNotSoldInCycle");
+function planNotSoldInCycle(plan, cycle) {
+  const planName = plan.name ?? plan.id;
+  return {
+    code: BILLING_ERROR_CODES.PLAN_NOT_SOLD_IN_CYCLE,
+    message: `${planName} has no price for this billing rhythm and cannot be booked in it.`,
+    params: {
+      planName,
+      planKey: plan.id,
+      billingCycle: cycle
+    }
+  };
+}
+__name(planNotSoldInCycle, "planNotSoldInCycle");
+function getPlanPriceGross(catalog, planId, cycle, vatRate) {
+  const net = getPlanPriceNet(catalog, planId, cycle);
+  if (net === null) return null;
+  const rate = vatRate ?? catalog.vatRate;
+  assertTaxRatePercent(vatRate === void 0 ? "catalog.vatRate" : "vatRate", rate);
+  return grossFromNet(net, rate);
+}
+__name(getPlanPriceGross, "getPlanPriceGross");
+function isFeatureInPlan(catalog, planId, featureKey) {
+  const plan = findPlan(catalog, planId);
+  if (!plan) return false;
+  return plan.features.includes(featureKey);
+}
+__name(isFeatureInPlan, "isFeatureInPlan");
+function getPlanQuota(catalog, planId, quotaKey) {
+  const plan = findPlan(catalog, planId);
+  return plan?.quotas[quotaKey];
+}
+__name(getPlanQuota, "getPlanQuota");
+function getActiveFeatureKeys(catalog) {
+  return (catalog.features ?? []).filter((f) => !f.plannedOnly).map((f) => f.key);
+}
+__name(getActiveFeatureKeys, "getActiveFeatureKeys");
+function isFeaturePlannedOnly(catalog, featureKey) {
+  const def = (catalog.features ?? []).find((f) => f.key === featureKey);
+  return def?.plannedOnly === true;
+}
+__name(isFeaturePlannedOnly, "isFeaturePlannedOnly");
+
+export {
+  findPlan,
+  getPlanOrThrow,
+  getMarketedPlans,
+  getPlanPriceNet,
+  listPriceNet,
+  isPlanNotSoldInCycle,
+  planNotSoldInCycle,
+  getPlanPriceGross,
+  isFeatureInPlan,
+  getPlanQuota,
+  getActiveFeatureKeys,
+  isFeaturePlannedOnly
+};