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

package/dist/{chunk-I7GTA3RX.js → chunk-JQRA724W.js}

@@ -1,6 +1,6 @@
 import {
   DiscoveryScanner
-} from "./chunk-WXYJHZCN.js";
+} from "./chunk-JVAEKTJ4.js";
 import {
   DEFINES_QUOTA_KEY,
   DISCOVERY_SNAPSHOT_TOKEN,

package/dist/{chunk-WXYJHZCN.js → chunk-JVAEKTJ4.js}

@@ -13,6 +13,7 @@ import { mkdirSync, writeFileSync } from "fs";
 import { dirname } from "path";
 import { Inject, Injectable, Logger, Optional } from "@nestjs/common";
 import { DiscoveryService, MetadataScanner, Reflector } from "@nestjs/core";
+import { canonicalJson } from "@saasicat/core";
 function _ts_decorate(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);
@@ -288,23 +289,10 @@ function computeSnapshotHash(snapshot) {
     features: snapshot.features,
     quotas: snapshot.quotas
   };
-  const json = canonicalStringify(stableInput);
+  const json = canonicalJson(stableInput);
   return `sha256-${createHash("sha256").update(json).digest("hex")}`;
 }
 __name(computeSnapshotHash, "computeSnapshotHash");
-function canonicalStringify(value) {
-  return JSON.stringify(value, (_key, val) => {
-    if (val && typeof val === "object" && !Array.isArray(val)) {
-      const sorted = {};
-      for (const k of Object.keys(val).sort()) {
-        sorted[k] = val[k];
-      }
-      return sorted;
-    }
-    return val;
-  });
-}
-__name(canonicalStringify, "canonicalStringify");
 
 export {
   DISCOVERY_APP_INFO_TOKEN,

package/dist/chunk-KPEMTBOP.js

@@ -0,0 +1,26 @@
+import {
+  __name
+} from "./chunk-SHUYVCID.js";
+
+// src/billing/bundle-price.ts
+function resolveBundlePriceNet(bundleVersion, planKey, billingCycle) {
+  const override = (bundleVersion.pricingOverrides ?? []).find((o) => o.planId === planKey);
+  const yearly = billingCycle === "YEARLY";
+  const raw = yearly ? override?.yearlyNet !== void 0 ? override.yearlyNet : bundleVersion.yearlyNet : override?.monthlyNet !== void 0 ? override.monthlyNet : bundleVersion.monthlyNet;
+  if (raw === null || raw === void 0) return null;
+  const parsed = Number.parseFloat(raw);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+__name(resolveBundlePriceNet, "resolveBundlePriceNet");
+function cyclesSoldFor(planVersion) {
+  const cycles = [];
+  if (planVersion.monthlyNet != null) cycles.push("MONTHLY");
+  if (planVersion.yearlyNet != null) cycles.push("YEARLY");
+  return cycles;
+}
+__name(cyclesSoldFor, "cyclesSoldFor");
+
+export {
+  resolveBundlePriceNet,
+  cyclesSoldFor
+};

package/dist/chunk-LF6J4YYN.js

@@ -0,0 +1,301 @@
+import {
+  PLAN_CATALOG_SETTINGS_TOKEN
+} from "./chunk-FEQZCWUL.js";
+import {
+  codedError
+} from "./chunk-J7NJRK3K.js";
+import {
+  __name
+} from "./chunk-SHUYVCID.js";
+
+// src/subscriber/subscriber.tokens.ts
+var SUBSCRIBER_REPOSITORY_TOKEN = /* @__PURE__ */ Symbol.for("saasicat/nest/SubscriberRepository");
+
+// src/subscriber/subscriber.service.ts
+import { ConflictException, Inject, Injectable, NotFoundException, UnprocessableEntityException as UnprocessableEntityException2 } from "@nestjs/common";
+import { SUBSCRIBER_ERROR_CODES as SUBSCRIBER_ERROR_CODES2, contractPartiesOf } from "@saasicat/core";
+
+// src/subscriber/subscriber-details.ts
+import { UnprocessableEntityException } from "@nestjs/common";
+import { SUBSCRIBER_ERROR_CODES, LEGAL_IDENTITY_FIELDS } from "@saasicat/core";
+var COUNTRY_CODE = /^[A-Z]{2}$/;
+var MAX_EMAIL_LENGTH = 254;
+var INVOICE_ADDRESS_FIELDS = [
+  "addressLine1",
+  "postalCode",
+  "city",
+  "country"
+];
+var CONTACT_FIELDS = [
+  "addressLine1",
+  "addressLine2",
+  "postalCode",
+  "city",
+  "country",
+  "invoiceEmail"
+];
+function settleNewSubscriberDetails(details) {
+  return {
+    legalName: settleLegalName(details.legalName),
+    vatId: settleText("vatId", details.vatId),
+    taxNumber: settleText("taxNumber", details.taxNumber),
+    ...settleContact(details, CONTACT_FIELDS)
+  };
+}
+__name(settleNewSubscriberDetails, "settleNewSubscriberDetails");
+function settleContactChange(change) {
+  const identity = LEGAL_IDENTITY_FIELDS.find((field) => change[field] !== void 0);
+  if (identity) {
+    throw new UnprocessableEntityException(codedError(SUBSCRIBER_ERROR_CODES.SUBSCRIBER_IDENTITY_NOT_A_CONTACT, {
+      field: identity
+    }));
+  }
+  const named = CONTACT_FIELDS.filter((field) => change[field] !== void 0);
+  return settleContact(change, named);
+}
+__name(settleContactChange, "settleContactChange");
+function settleIdentityCorrection(correction) {
+  const values = {};
+  for (const field of LEGAL_IDENTITY_FIELDS) {
+    if (correction[field] === void 0) continue;
+    values[field] = settleIdentityValue(field, correction[field]);
+  }
+  return values;
+}
+__name(settleIdentityCorrection, "settleIdentityCorrection");
+function settleIdentityValue(field, value) {
+  return field === "legalName" ? settleLegalName(value) : settleText(field, value);
+}
+__name(settleIdentityValue, "settleIdentityValue");
+function settleLegalName(value) {
+  const legalName = settleText("legalName", value);
+  if (legalName === null) {
+    throw new UnprocessableEntityException(codedError(SUBSCRIBER_ERROR_CODES.SUBSCRIBER_LEGAL_NAME_REQUIRED));
+  }
+  return legalName;
+}
+__name(settleLegalName, "settleLegalName");
+function settleContact(source, fields) {
+  const contact = {};
+  for (const field of fields) {
+    contact[field] = settleContactValue(field, source[field]);
+  }
+  return contact;
+}
+__name(settleContact, "settleContact");
+function settleContactValue(field, value) {
+  const text = settleText(field, value);
+  if (text === null) return null;
+  if (field === "country") {
+    const country = text.toUpperCase();
+    if (!COUNTRY_CODE.test(country)) throw invalid(field);
+    return country;
+  }
+  if (field === "invoiceEmail" && !isEmailShaped(text)) throw invalid(field);
+  return text;
+}
+__name(settleContactValue, "settleContactValue");
+function settleText(field, value) {
+  if (value === void 0 || value === null) return null;
+  if (typeof value !== "string") throw invalid(field);
+  const trimmed = value.trim();
+  return trimmed === "" ? null : trimmed;
+}
+__name(settleText, "settleText");
+function isEmailShaped(value) {
+  if (value.length > MAX_EMAIL_LENGTH) return false;
+  const at = value.indexOf("@");
+  if (at <= 0 || at !== value.lastIndexOf("@")) return false;
+  const domain = value.slice(at + 1);
+  const dot = domain.lastIndexOf(".");
+  if (dot <= 0 || dot === domain.length - 1) return false;
+  return !/\s/.test(value);
+}
+__name(isEmailShaped, "isEmailShaped");
+function invalid(field) {
+  return new UnprocessableEntityException(codedError(SUBSCRIBER_ERROR_CODES.SUBSCRIBER_DETAIL_INVALID, {
+    field
+  }));
+}
+__name(invalid, "invalid");
+
+// src/subscriber/subscriber.service.ts
+function _ts_decorate(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);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+function _ts_metadata(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata, "_ts_metadata");
+function _ts_param(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param, "_ts_param");
+var KEPT_BY_A_TENANT = [
+  ...INVOICE_ADDRESS_FIELDS,
+  "invoiceEmail"
+];
+var SubscriberService = class {
+  static {
+    __name(this, "SubscriberService");
+  }
+  repo;
+  settings;
+  constructor(repo, settings) {
+    this.repo = repo;
+    this.settings = settings;
+  }
+  /**
+   * Creates the tenant's subscriber and assigns its customer number, behind
+   * the prefix `config/saas.yaml` names. With `tx` it is written on that
+   * transaction and undone with it — pass the one the tenant is created on.
+   *
+   * Refused with `SUBSCRIBER_ALREADY_EXISTS` when the tenant has one: a second
+   * party for the same tenant is not a correction of the first.
+   */
+  async createForTenant(tenantId, details, tx) {
+    const settled = settleNewSubscriberDetails(details);
+    const created = await this.repo.createForTenant({
+      ...settled,
+      tenantId,
+      customerNumberPrefix: this.settings.subscribers?.customerNumberPrefix ?? ""
+    }, tx);
+    if (!created) {
+      throw new ConflictException(codedError(SUBSCRIBER_ERROR_CODES2.SUBSCRIBER_ALREADY_EXISTS, {
+        tenantId
+      }));
+    }
+    return created;
+  }
+  /** The tenant's subscriber, or `null` when it has none. */
+  findByTenantId(tenantId, tx) {
+    return this.repo.findByTenantId(tenantId, tx);
+  }
+  /** The tenant's subscriber, refused with `SUBSCRIBER_REQUIRED` when it has none. */
+  async requireForTenant(tenantId, tx) {
+    const subscriber = await this.repo.findByTenantId(tenantId, tx);
+    if (!subscriber) throw subscriberRequired(tenantId);
+    return subscriber;
+  }
+  /**
+   * Who a contract concluded for this tenant now is between: its subscriber
+   * as the record stands, and the issuer as the running configuration names
+   * it. Refused with `SUBSCRIBER_REQUIRED` when the tenant has no subscriber.
+   */
+  async contractPartiesFor(tenantId, tx) {
+    const subscriber = await this.requireForTenant(tenantId, tx);
+    return contractPartiesOf(subscriber, this.settings.issuer);
+  }
+  async getById(subscriberId) {
+    const subscriber = await this.repo.findById(subscriberId);
+    if (!subscriber) throw subscriberNotFound(subscriberId);
+    return subscriber;
+  }
+  /**
+   * Changes how the subscriber is reached — the address, the country, the
+   * invoice email — at any time. A contract keeps the copy it was concluded
+   * with; what comes later reads the new details. The legal name and the tax
+   * identifiers are refused here: they change by `correctIdentity`.
+   */
+  async changeContact(subscriberId, change) {
+    return this.writeContact(subscriberId, settleContactChange(change));
+  }
+  /**
+   * A tenant's own change of how its subscriber is reached, from its billing
+   * area. The address and the invoice email can be changed but not cleared —
+   * `SUBSCRIBER_DETAIL_INVALID` names the field — since without them nothing
+   * can be invoiced. The legal name and the tax identifiers are refused as
+   * with `changeContact`: they are the party, and only the operator corrects
+   * them.
+   */
+  async changeContactOfTenant(tenantId, change) {
+    const subscriber = await this.requireForTenant(tenantId);
+    const settled = settleContactChange(change);
+    const cleared = KEPT_BY_A_TENANT.find((field) => settled[field] === null);
+    if (cleared) {
+      throw new UnprocessableEntityException2(codedError(SUBSCRIBER_ERROR_CODES2.SUBSCRIBER_DETAIL_INVALID, {
+        field: cleared
+      }));
+    }
+    return this.writeContact(subscriber.id, settled);
+  }
+  /** Writes contact details already settled; settling twice would check one copy and write another. */
+  async writeContact(subscriberId, settled) {
+    const updated = await this.repo.updateContact(subscriberId, settled);
+    if (!updated) throw subscriberNotFound(subscriberId);
+    return updated;
+  }
+  /**
+   * Corrects the legal identity of the same legal entity — a misspelt name, a
+   * wrong tax identifier, a change of name that entity went through — and
+   * records the values it replaced, the reason and who made it. A contract
+   * keeps the copy it was concluded with.
+   *
+   * The operator declares what the change is, because nothing here can tell:
+   * another legal entity taking over is a transfer, and is refused with
+   * `SUBSCRIBER_TAKEOVER_IS_A_TRANSFER` rather than recorded as an edit.
+   */
+  async correctIdentity(subscriberId, correction) {
+    if (correction.kind !== "correction") {
+      throw new UnprocessableEntityException2(codedError(SUBSCRIBER_ERROR_CODES2.SUBSCRIBER_TAKEOVER_IS_A_TRANSFER));
+    }
+    const reason = typeof correction.reason === "string" ? correction.reason.trim() : "";
+    if (reason === "") {
+      throw new UnprocessableEntityException2(codedError(SUBSCRIBER_ERROR_CODES2.SUBSCRIBER_CORRECTION_REASON_REQUIRED));
+    }
+    const correctedBy = typeof correction.correctedBy === "string" ? correction.correctedBy.trim() : "";
+    if (correctedBy === "") {
+      throw new UnprocessableEntityException2(codedError(SUBSCRIBER_ERROR_CODES2.SUBSCRIBER_CORRECTION_ACTOR_REQUIRED));
+    }
+    const result = await this.repo.correctIdentity(subscriberId, {
+      corrected: settleIdentityCorrection(correction),
+      reason,
+      correctedBy,
+      correctedAt: /* @__PURE__ */ new Date()
+    });
+    if (!result) throw subscriberNotFound(subscriberId);
+    if (!result.correction) {
+      throw new UnprocessableEntityException2(codedError(SUBSCRIBER_ERROR_CODES2.SUBSCRIBER_CORRECTION_CHANGES_NOTHING));
+    }
+    return result.correction;
+  }
+  /** Every correction of the subscriber's legal identity, the latest first. */
+  listCorrections(subscriberId) {
+    return this.repo.listCorrections(subscriberId);
+  }
+};
+SubscriberService = _ts_decorate([
+  Injectable(),
+  _ts_param(0, Inject(SUBSCRIBER_REPOSITORY_TOKEN)),
+  _ts_param(1, Inject(PLAN_CATALOG_SETTINGS_TOKEN)),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof SubscriberRepository === "undefined" ? Object : SubscriberRepository,
+    typeof PlanCatalogSettings === "undefined" ? Object : PlanCatalogSettings
+  ])
+], SubscriberService);
+function subscriberRequired(tenantId) {
+  return new ConflictException(codedError(SUBSCRIBER_ERROR_CODES2.SUBSCRIBER_REQUIRED, {
+    tenantId
+  }));
+}
+__name(subscriberRequired, "subscriberRequired");
+function subscriberNotFound(subscriberId) {
+  return new NotFoundException(codedError(SUBSCRIBER_ERROR_CODES2.SUBSCRIBER_NOT_FOUND, {
+    subscriberId
+  }));
+}
+__name(subscriberNotFound, "subscriberNotFound");
+
+export {
+  INVOICE_ADDRESS_FIELDS,
+  settleNewSubscriberDetails,
+  SUBSCRIBER_REPOSITORY_TOKEN,
+  SubscriberService
+};