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

package/dist/checkout-offer.service-CCVxG9b2.d.cts

@@ -0,0 +1,242 @@
+import { PlanCatalogSettings, PlanRepository, BundleRepository, PromotionRepository, CheckoutOfferPriceBreakdown, CheckoutOfferLineItem, CheckoutOfferPromotionSnapshot, CheckoutOfferPromoCodeSnapshot, CheckoutOfferRow, CheckoutOfferRepository, CatalogEntryRepository, TransactionRunner, CheckoutOfferFilter, CheckoutOfferSelection, CheckoutOfferSelectionUpdate, NewSubscriberDetails, TransactionContext, SubscriptionContractRecord } from '@saasicat/core';
+import { S as SubscriptionContractService, C as CreateContractFromOfferOptions } from './subscription-contract.service-CfNApLuP.cjs';
+import { S as SubscriberService } from './subscriber.service-5W6Gi-1B.cjs';
+import { a as PromoCodesService } from './promo.service-BYBu6dy3.cjs';
+
+type Cycle = 'monthly' | 'yearly';
+/** What pricing needs to know about a selection. */
+interface CheckoutOfferPricingInput {
+    planKey: string;
+    billingCycle: Cycle;
+    bundleVersionIds: readonly string[];
+    promoCode: string | null;
+    locale: string;
+    /**
+     * The offer when it is priced again. A slot of its promo code held for its
+     * checkout is its own, not counted against it.
+     */
+    checkoutOfferId?: string;
+    /**
+     * Priced as the offer is concluded: its held slot also keeps the code as it
+     * stood when the slot was taken.
+     */
+    concluding?: boolean;
+}
+/** The part of a stored offer the server computes. */
+interface PricedCheckoutOffer {
+    planVersionId: string;
+    bundles: string[];
+    bundleVersionIds: string[];
+    promotionId: string | null;
+    promoCode: string | null;
+    priceBreakdown: CheckoutOfferPriceBreakdown;
+    lineItems: CheckoutOfferLineItem[];
+    promotionSnapshots: CheckoutOfferPromotionSnapshot[];
+    promoCodeSnapshot: CheckoutOfferPromoCodeSnapshot | null;
+}
+declare class CheckoutOfferPricing {
+    private readonly settings;
+    private readonly plans;
+    private readonly bundles;
+    private readonly promotions;
+    private readonly promoCodes;
+    constructor(settings: PlanCatalogSettings, plans: PlanRepository, bundles?: BundleRepository | null, promotions?: PromotionRepository | null, promoCodes?: PromoCodesService | null);
+    /** Prices a selection against the plan version on sale now. */
+    price(input: CheckoutOfferPricingInput, asOf?: Date): Promise<PricedCheckoutOffer>;
+    /**
+     * Throws unless the offer's stored amounts are what this pricing makes of
+     * its own selection: the plan and bundle versions it froze, and the
+     * promotions as they stood when it was last priced.
+     */
+    assertPricedByCatalogue(offer: CheckoutOfferRow): Promise<void>;
+    private compute;
+    /** The plan version on sale for new bookings, as the public catalogue resolves it. */
+    private planVersionOnSale;
+    /** A plan without a list price is not sold at one (`SC-PRIC-011`). */
+    private assertPlanPriced;
+    private bundleVersionsFor;
+    private pricePlan;
+    private priceBundle;
+    private line;
+    /**
+     * The promo code's discount on the plan, after its promotion.
+     *
+     * Eligibility is the promo module's to decide, and it decides on its own
+     * terms: status, validity, the plan and rhythm the code is limited to. Only
+     * the amount is computed here, on the price this offer actually carries.
+     */
+    private pricePromoCode;
+}
+
+/** What concluding an offer produced: the consumed offer and its contract. */
+interface ConcludedCheckoutOffer {
+    offer: CheckoutOfferRow;
+    contract: SubscriptionContractRecord;
+}
+/** How an offer is concluded, and for whom. */
+interface ConcludeCheckoutOfferOptions extends CreateContractFromOfferOptions {
+    /**
+     * The subscriber of a tenant that does not have one yet, created on the
+     * conclusion's transaction before its contract — what a sign-up passes,
+     * `subscriberFromRegistration(pending)` giving the details. Left out, the
+     * tenant's existing subscriber is the party; a tenant with neither is
+     * refused with `SUBSCRIBER_REQUIRED`, and one that already has a subscriber
+     * with `SUBSCRIBER_ALREADY_EXISTS`.
+     */
+    subscriber?: NewSubscriberDetails;
+    /**
+     * The transaction to conclude on, when the caller already holds one. A
+     * sign-up's activation does: the gateway's confirmation is claimed on it,
+     * and the offer, the subscriber, the contract and `within` are written on
+     * it and undone with it. Left out, the conclusion opens a transaction of
+     * its own.
+     */
+    tx?: TransactionContext;
+}
+/**
+ * The application's own writes that belong to concluding an offer, such as
+ * starting its subscription. They run on the same transaction, after the offer
+ * is consumed and its contract written; throwing undoes all of it.
+ */
+type ConcludeCheckoutOfferWithin = (tx: TransactionContext, concluded: ConcludedCheckoutOffer) => Promise<void>;
+declare class CheckoutOfferService {
+    private readonly repo;
+    private readonly pricing;
+    private readonly bundles;
+    private readonly plans;
+    private readonly catalogEntries;
+    private readonly contracts;
+    private readonly transactions;
+    private readonly subscribers;
+    private readonly promoCodes;
+    constructor(repo: CheckoutOfferRepository, pricing: CheckoutOfferPricing, bundles?: BundleRepository | null, plans?: PlanRepository | null, catalogEntries?: CatalogEntryRepository | null, contracts?: SubscriptionContractService | null, transactions?: TransactionRunner | null, subscribers?: SubscriberService | null, promoCodes?: PromoCodesService | null);
+    list(filter: CheckoutOfferFilter): Promise<CheckoutOfferRow[]>;
+    getById(id: string): Promise<CheckoutOfferRow>;
+    /** Prices what the caller chose and stores it as an open offer. */
+    create(selection: CheckoutOfferSelection): Promise<CheckoutOfferRow>;
+    /**
+     * Customization in onboarding — only while the offer is `open`. The plan
+     * stays; whatever else changes, the whole offer is priced again. A slot of
+     * its promo code held for its checkout stays with it while the code does,
+     * and is given back when the code is changed or removed.
+     */
+    update(id: string, change: CheckoutOfferSelectionUpdate): Promise<CheckoutOfferRow>;
+    /**
+     * Holds a slot of the offer's promo code for its checkout until `until` —
+     * what a sign-up does as its checkout starts, until a confirmation of its
+     * payment form can no longer arrive — so that the code cannot run out
+     * before the payment is confirmed and the offer concluded. A live slot the
+     * offer holds of that code already moves to `until`, never earlier. The
+     * conclusion turns the slot into the redemption; the slot goes back when
+     * the offer's code changes or `until` passes.
+     *
+     * Refused, and nothing held, when the offer is no longer open or its code
+     * cannot be held: `PROMO_CODE_NOT_REDEEMABLE` with the reason a preview
+     * gives, `EXHAUSTED` when every slot is redeemed or held. An offer without
+     * a code holds nothing.
+     */
+    holdPromoCode(id: string, hold: {
+        email?: string;
+        until: Date;
+    }): Promise<void>;
+    /**
+     * Gives back the slot held for the offer's checkout while it is still held
+     * until `heldUntil`, as the caller wrote it. A slot another start of the
+     * checkout moved later stays with the form that start opened.
+     */
+    releasePromoCodeHold(id: string, heldUntil: Date): Promise<void>;
+    /**
+     * Freezes the offer (`status = 'consumed'`). Returns the final
+     * snapshot — the caller (registration/billing) writes it
+     * as `Subscription.packageSnapshot`.
+     *
+     * Refused unless every add-on is still bookable and the stored amounts are
+     * what the catalogue makes of the offer's own selection, so an offer whose
+     * amounts were written by anything but the pricing never becomes a contract.
+     *
+     * The plan, the add-ons and the promotions are priced as they stood when the
+     * offer was priced; a promo code is checked with the promo module as it
+     * stands now. A code is redeemed when the contract is concluded, so one that
+     * has expired or run out of redemptions since refuses the offer with
+     * `CHECKOUT_OFFER_PROMO_CODE_NOT_ACCEPTED`; `CHECKOUT_OFFER_PRICE_NOT_CURRENT`
+     * is kept for amounts that no longer match.
+     */
+    consume(id: string): Promise<CheckoutOfferRow>;
+    /**
+     * Consumes an offer and creates its contract in one transaction, together
+     * with the application's own writes in `within`, so an offer is never
+     * consumed without its contract, and no contract is written for an offer
+     * that stays open.
+     *
+     * Everything that can refuse runs before the transaction: what `consume`
+     * checks, and the checks the contract the offer becomes is held to. Inside
+     * it, the offer is consumed on the condition that it is still open, the
+     * contract is written, and `within` runs; an error in any of them undoes
+     * the others, and the offer can be concluded again.
+     *
+     * An offer that is already concluded for the same tenant answers with its
+     * contract rather than a refusal, so a caller retrying after a lost answer,
+     * or losing a race to another call for that tenant, gets the conclusion that
+     * stands; `within` does not run again, its writes committed with it. A
+     * conclusion for another tenant is refused with
+     * `CHECKOUT_OFFER_ALREADY_CONSUMED`, and an offer changed between the checks
+     * and the transaction with `CHECKOUT_OFFER_CHANGED`, nothing written.
+     *
+     * The contract is between the tenant's subscriber and the configured
+     * issuer. A sign-up creates the tenant in `within` and has no subscriber
+     * yet, so it passes `subscriber`, which is created on the same transaction
+     * before the contract; whether one may be created, or whether the tenant
+     * has one, is asked before the transaction with the other checks.
+     *
+     * A promo code on the offer is redeemed in `within`, with
+     * `PromoCodesService.redeemInTransaction` on the same transaction. Before
+     * the transaction the code is only checked the way pricing checks it; the
+     * redemption checks the rest, the customer and the remaining redemptions,
+     * where a refusal still undoes everything. Nothing checks the code again
+     * after `within`, so a redemption that takes its last slot does not refuse
+     * the offer it was redeemed for.
+     *
+     * A slot held for the offer's checkout (`holdPromoCode`) is the offer's own
+     * throughout: the checks before the transaction do not count it against
+     * the code and accept the code as it stood when the slot was held, and the
+     * redemption in `within` takes that slot rather than a free one. A slot
+     * `within` did not redeem is given back before the conclusion commits.
+     */
+    conclude(id: string, options: ConcludeCheckoutOfferOptions, within?: ConcludeCheckoutOfferWithin): Promise<ConcludedCheckoutOffer>;
+    private assertConsumable;
+    /**
+     * The conclusion that stands for this tenant, if the offer has one. An offer
+     * carries no tenant and its id travels in a link, so a conclusion for
+     * another tenant is not an answer: that caller is refused as before.
+     */
+    private standingConclusion;
+    private conclusionPorts;
+    /**
+     * Before anything is written: the subscriber to create is one that may be
+     * created, or the tenant already has the party the contract is with.
+     */
+    private assertParty;
+    /**
+     * #35 P6 — server-side requires validation: the dependencies of all
+     * features (plan ∪ selected bundles) must be covered within the
+     * selection, otherwise an offer would be created whose features cannot
+     * work at the tenant (an app-specific validateModuleDependencies check is
+     * thereby replaced on the platform side). The requires source are the
+     * curated FeatureCatalogEntries; without CatalogEntryRepository it is
+     * skipped (graceful — no requires data available).
+     */
+    private assertFeatureRequiresSatisfied;
+    /**
+     * Plan features preferably from the server SSOT (PlanRepository); fallback
+     * is the frozen featuresSnapshot of the plan LineItem (adapter without
+     * PlanRepository wiring).
+     */
+    private resolvePlanFeatures;
+    /** Bundle features from the BundleVersions; fallback featuresSnapshot. */
+    private resolveBundleFeatures;
+    private assertBundleVersionsStillBookable;
+    private assertOpen;
+    private isExpired;
+}
+
+export { CheckoutOfferPricing as C, type PricedCheckoutOffer as P, type CheckoutOfferPricingInput as a, CheckoutOfferService as b, type ConcludeCheckoutOfferOptions as c, type ConcludeCheckoutOfferWithin as d, type ConcludedCheckoutOffer as e };

package/dist/chunk-34XVPR6P.js

@@ -0,0 +1,222 @@
+import {
+  MFA_PORT_TOKEN
+} from "./chunk-SZ7RFPXA.js";
+import {
+  codedError
+} from "./chunk-J7NJRK3K.js";
+import {
+  __name
+} from "./chunk-SHUYVCID.js";
+
+// src/admin/mfa.service.ts
+import { Inject, Injectable, Logger } from "@nestjs/common";
+import { generateSecret, generateURI, verify as verifyTotpCode } from "otplib";
+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 CLOCK_DRIFT_TOLERANCE_SECONDS = 30;
+var OTPLIB_TOKEN_ERROR_NAMES = /* @__PURE__ */ new Set([
+  "TokenError",
+  "TokenFormatError",
+  "TokenLengthError"
+]);
+function isOtplibTokenError(error) {
+  return error instanceof Error && OTPLIB_TOKEN_ERROR_NAMES.has(error.name);
+}
+__name(isOtplibTokenError, "isOtplibTokenError");
+var MfaService = class _MfaService {
+  static {
+    __name(this, "MfaService");
+  }
+  mfa;
+  logger = new Logger(_MfaService.name);
+  constructor(mfa) {
+    this.mfa = mfa;
+  }
+  /**
+   * Generates a new TOTP secret, persists it via `MfaPort.setSecret`
+   * and returns the secret + the otpauth URI for the QR code.
+   *
+   * `issuer` and `label` shape the display in the authenticator (e.g.
+   * "DemoApp:taci@example.com").
+   */
+  async setup(userId, label, issuer) {
+    const secret = generateSecret();
+    const otpauthUri = generateURI({
+      issuer,
+      label,
+      secret
+    });
+    await this.mfa.setSecret(userId, secret);
+    return {
+      secret,
+      otpauthUri
+    };
+  }
+  /**
+   * Verifies the entered code against the stored secret,
+   * clock-drift-tolerant by ±1 time step.
+   */
+  async verify(input) {
+    const secret = await this.mfa.getSecret(input.userId);
+    if (!secret) return false;
+    try {
+      const result = await verifyTotpCode({
+        secret,
+        token: input.code.trim(),
+        epochTolerance: CLOCK_DRIFT_TOLERANCE_SECONDS
+      });
+      return result.valid;
+    } catch (error) {
+      if (isOtplibTokenError(error)) {
+        return false;
+      }
+      const message = error instanceof Error ? error.message : String(error);
+      this.logger.warn(`TOTP verification for user ${input.userId} failed unexpectedly: ${message}`);
+      return false;
+    }
+  }
+  /**
+   * Deletes a user's secret — used by `ahp admin mfa-reset`.
+   */
+  async disable(userId) {
+    await this.mfa.setSecret(userId, null);
+  }
+  /** Delegates to `MfaPort.isEnabled`. */
+  async isEnabled(userId) {
+    return this.mfa.isEnabled(userId);
+  }
+};
+MfaService = _ts_decorate([
+  Injectable(),
+  _ts_param(0, Inject(MFA_PORT_TOKEN)),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof MfaPort === "undefined" ? Object : MfaPort
+  ])
+], MfaService);
+
+// src/admin/mfa.guard.ts
+import { Inject as Inject2, Injectable as Injectable2, Logger as Logger2, SetMetadata, UnauthorizedException } from "@nestjs/common";
+import { Reflector } from "@nestjs/core";
+import { AUTH_ERROR_CODES } from "@saasicat/core";
+function _ts_decorate2(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_decorate2, "_ts_decorate");
+function _ts_metadata2(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata2, "_ts_metadata");
+function _ts_param2(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param2, "_ts_param");
+var REQUIRE_MFA_KEY = "saasicat/nest/require-mfa";
+var RequireMfa = /* @__PURE__ */ __name(() => SetMetadata(REQUIRE_MFA_KEY, true), "RequireMfa");
+var MfaGuard = class _MfaGuard {
+  static {
+    __name(this, "MfaGuard");
+  }
+  reflector;
+  mfaService;
+  logger = new Logger2(_MfaGuard.name);
+  constructor(reflector, mfaService) {
+    this.reflector = reflector;
+    this.mfaService = mfaService;
+  }
+  async canActivate(context) {
+    const required = this.reflector.getAllAndOverride(REQUIRE_MFA_KEY, [
+      context.getHandler(),
+      context.getClass()
+    ]);
+    if (!required) return true;
+    if (process.env.SAAS_PLATFORM_SKIP_MFA === "1" && process.env.NODE_ENV !== "production") {
+      return true;
+    }
+    const request = context.switchToHttp().getRequest();
+    const userId = request.user?.id ?? request.user?.userId;
+    if (!userId) {
+      throw new UnauthorizedException({
+        ...codedError(AUTH_ERROR_CODES.NOT_AUTHENTICATED),
+        // `reason` is superseded by `code` and will be removed.
+        reason: "NOT_AUTHENTICATED"
+      });
+    }
+    const enabled = await this.mfaService.isEnabled(userId);
+    if (!enabled) {
+      throw new UnauthorizedException({
+        code: AUTH_ERROR_CODES.MFA_NOT_SET_UP,
+        // `reason` is superseded by `code` and will be removed.
+        reason: "MFA_NOT_SET_UP",
+        message: "Run the MFA setup via the CLI first."
+      });
+    }
+    const headerVal = request.headers?.["x-mfa-code"];
+    const code = Array.isArray(headerVal) ? headerVal[0] : headerVal;
+    if (!code) {
+      throw new UnauthorizedException({
+        code: AUTH_ERROR_CODES.MFA_REQUIRED,
+        // `reason` is superseded by `code` and will be removed.
+        reason: "MFA_REQUIRED",
+        message: "TOTP code required in the X-Mfa-Code header."
+      });
+    }
+    const valid = await this.mfaService.verify({
+      userId,
+      code: String(code)
+    });
+    if (!valid) {
+      throw new UnauthorizedException({
+        code: AUTH_ERROR_CODES.MFA_FAILED,
+        // `reason` is superseded by `code` and will be removed.
+        reason: "MFA_FAILED",
+        message: "Invalid TOTP code."
+      });
+    }
+    return true;
+  }
+};
+MfaGuard = _ts_decorate2([
+  Injectable2(),
+  _ts_param2(0, Inject2(Reflector)),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    typeof Reflector === "undefined" ? Object : Reflector,
+    typeof MfaService === "undefined" ? Object : MfaService
+  ])
+], MfaGuard);
+
+// src/admin/enforce-mfa.decorator.ts
+import { applyDecorators, UseGuards } from "@nestjs/common";
+function EnforceMfa() {
+  return applyDecorators(RequireMfa(), UseGuards(MfaGuard));
+}
+__name(EnforceMfa, "EnforceMfa");
+
+export {
+  MfaService,
+  REQUIRE_MFA_KEY,
+  RequireMfa,
+  MfaGuard,
+  EnforceMfa
+};

package/dist/{chunk-AOQJEYOL.js → chunk-3QVGA6JX.js}

@@ -7,6 +7,7 @@ var PROMOTION_REPOSITORY_TOKEN = /* @__PURE__ */ Symbol.for("saasicat/nest/Promo
 var MARKETING_SETTINGS_REPOSITORY_TOKEN = /* @__PURE__ */ Symbol.for("saasicat/nest/MarketingSettingsRepository");
 var CATALOG_SERVICE_CONFIG_TOKEN = /* @__PURE__ */ Symbol.for("saasicat/nest/CatalogServiceConfig");
 var CATALOG_FEATURE_UI_REGISTRY_TOKEN = /* @__PURE__ */ Symbol.for("saasicat/nest/CatalogFeatureUiRegistry");
+var NEW_PAYMENT_METHODS_SOURCE_TOKEN = /* @__PURE__ */ Symbol.for("saasicat/nest/NewPaymentMethodsSource");
 
 export {
   PLAN_REPOSITORY_TOKEN,
@@ -16,5 +17,6 @@ export {
   PROMOTION_REPOSITORY_TOKEN,
   MARKETING_SETTINGS_REPOSITORY_TOKEN,
   CATALOG_SERVICE_CONFIG_TOKEN,
-  CATALOG_FEATURE_UI_REGISTRY_TOKEN
+  CATALOG_FEATURE_UI_REGISTRY_TOKEN,
+  NEW_PAYMENT_METHODS_SOURCE_TOKEN
 };