@mj-biz-apps/orders-core-entities-server 0.0.1 → 5.2.0

package/dist/RevenueRecognition.js

@@ -0,0 +1,133 @@
+var __decorate = (this && this.__decorate) || function (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;
+};
+/**
+ * Revenue-recognition drivers — the pluggable "how is this earned over time?" layer (plan D43).
+ *
+ * DESIGN: there is no "standard vs custom" split. EVERY `RevenueRecognitionType` row — including
+ * the three we ship — names a `DriverClass` resolved through MJ's ClassFactory. The shipped
+ * drivers are ordinary implementations with overridable `protected` methods, so an adopter can
+ * subclass one and re-register under the SAME key to swap their behaviour in wholesale. That is
+ * strictly more powerful than a hardcoded switch plus an escape hatch, and it means our own types
+ * are exercised by the same path every extension uses.
+ *
+ * SEPARATION OF CONCERNS: a driver computes a SCHEDULE — dates and amounts — and nothing else.
+ * It never touches the database, never creates journal entries, and never opens a transaction.
+ * `OrderEntityServer` turns the schedule into forward-dated JEs (D14) inside the single booking
+ * transaction, which keeps transaction management in exactly one place and makes drivers trivially
+ * unit-testable.
+ *
+ * ROUNDING: the remainder is front-loaded into the FIRST period (plan §4.6). A 12 × $100.00
+ * schedule off $1,200.01 recognizes $100.01 then 11 × $100.00 — never a trailing fractional cent,
+ * and the periods always sum exactly to the line amount.
+ *
+ * CONNECTS TO:
+ *   TABLE:  __mj_BizAppsOrders.RevenueRecognitionType (Code, DriverClass, IsDeferred, ...)
+ *   CALLER: OrderJournalEntryFactory (./OrderJournalEntryFactory.ts)
+ */
+import { RegisterClass } from '@memberjunction/global';
+function money(v) {
+    return Math.round((v + Number.EPSILON) * 100) / 100;
+}
+function addMonths(d, n) {
+    const r = new Date(d.getTime());
+    const day = r.getDate();
+    r.setMonth(r.getMonth() + n);
+    if (r.getDate() < day)
+        r.setDate(0); // clamp: Jan 31 + 1mo -> Feb 28/29
+    return r;
+}
+/**
+ * Base driver. Subclass, override `BuildSchedule` (or just the protected helpers), and register
+ * under an existing key to replace a shipped type:
+ *
+ *     @RegisterClass(RevenueRecognitionDriver, 'EvenOverTime')
+ *     export class OurEvenOverTime extends EvenOverTimeDriver { ... }
+ */
+export class RevenueRecognitionDriver {
+    /**
+     * Split `amount` across `periods`, front-loading the rounding remainder into the first period
+     * so the slices always sum EXACTLY to the amount.
+     */
+    AllocateEvenly(amount, periods) {
+        if (periods <= 0)
+            return [];
+        const base = money(amount / periods);
+        const out = new Array(periods).fill(base);
+        out[0] = money(amount - base * (periods - 1));
+        return out;
+    }
+    /** Whole months between two dates, minimum 1. */
+    MonthSpan(start, end) {
+        const months = (end.getFullYear() - start.getFullYear()) * 12 + (end.getMonth() - start.getMonth());
+        return Math.max(1, months + (end.getDate() >= start.getDate() ? 1 : 0));
+    }
+    RequireServicePeriod(context, driver) {
+        if (!context.ServicePeriodStart || !context.ServicePeriodEnd) {
+            throw new Error(`${driver} needs a service period, but this order line has no ` +
+                `ServicePeriodStart/ServicePeriodEnd. Set them on the line, or use a revenue ` +
+                `recognition type that does not require a coverage window.`);
+        }
+        return { start: new Date(context.ServicePeriodStart), end: new Date(context.ServicePeriodEnd) };
+    }
+}
+/**
+ * UpFront — 100% earned when the sale is booked. One-time goods and services.
+ * The booking entry credits Sales directly; there is no deferral round-trip.
+ */
+let UpFrontDriver = class UpFrontDriver extends RevenueRecognitionDriver {
+    BuildSchedule(context) {
+        const d = new Date(context.BookingDate);
+        return { Entries: [{ RecognitionDate: d, Amount: money(context.Amount), PeriodStart: d, PeriodEnd: d }] };
+    }
+};
+UpFrontDriver = __decorate([
+    RegisterClass(RevenueRecognitionDriver, 'UpFront')
+], UpFrontDriver);
+export { UpFrontDriver };
+/**
+ * EvenOverTime — straight-line across the line's service period. Most subscriptions.
+ * A 12-month $1,200 subscription produces 12 monthly $100 entries dated on the anniversaries.
+ */
+let EvenOverTimeDriver = class EvenOverTimeDriver extends RevenueRecognitionDriver {
+    BuildSchedule(context) {
+        const { start, end } = this.RequireServicePeriod(context, 'EvenOverTime');
+        const step = Math.max(1, context.PeriodMonths ?? 1);
+        const periods = Math.max(1, Math.ceil(this.MonthSpan(start, end) / step));
+        const amounts = this.AllocateEvenly(context.Amount, periods);
+        return {
+            Entries: amounts.map((amount, i) => {
+                const periodStart = addMonths(start, i * step);
+                const periodEnd = i === periods - 1 ? end : addMonths(start, (i + 1) * step);
+                return { RecognitionDate: periodStart, Amount: amount, PeriodStart: periodStart, PeriodEnd: periodEnd };
+            }),
+        };
+    }
+};
+EvenOverTimeDriver = __decorate([
+    RegisterClass(RevenueRecognitionDriver, 'EvenOverTime')
+], EvenOverTimeDriver);
+export { EvenOverTimeDriver };
+/**
+ * AllBackEnd — 100% earned on the END date. Events and milestone deliverables, where nothing is
+ * earned until the thing actually happens: cash is collected up front and sits in Deferred Revenue
+ * until the event date.
+ */
+let AllBackEndDriver = class AllBackEndDriver extends RevenueRecognitionDriver {
+    BuildSchedule(context) {
+        const { start, end } = this.RequireServicePeriod(context, 'AllBackEnd');
+        return { Entries: [{ RecognitionDate: end, Amount: money(context.Amount), PeriodStart: start, PeriodEnd: end }] };
+    }
+};
+AllBackEndDriver = __decorate([
+    RegisterClass(RevenueRecognitionDriver, 'AllBackEnd')
+], AllBackEndDriver);
+export { AllBackEndDriver };
+/** Tree-shaking anchor — the shipped drivers must be registered before booking runs. */
+export function LoadRevenueRecognitionDrivers() {
+    // intentionally empty
+}
+//# sourceMappingURL=RevenueRecognition.js.map

package/dist/RevenueRecognition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RevenueRecognition.js","sourceRoot":"","sources":["../src/RevenueRecognition.ts"],"names":[],"mappings":"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"}

package/dist/ReversalBehavior.d.ts

@@ -0,0 +1,82 @@
+/**
+ * What a reversal line is allowed to be — the arithmetic, with no database in sight.
+ *
+ * A reversal line carries a negative quantity and points at the line it unwinds
+ * (`ReversesOrderLineID`). `OrderLineEntityServer` already refuses a negative quantity with no
+ * pointer, because a negative line with no origin is indistinguishable from a typo. This module
+ * answers the harder question the pointer makes possible: given the origin, is THIS reversal
+ * legitimate, and what should it cost?
+ *
+ * Three facts the origin line is the only authority on:
+ *
+ *   1. **HOW MUCH is left to give back.** Nothing else in the system knows. Over-returning produces
+ *      a perfectly balanced journal entry that refunds money never collected, so the ledger cannot
+ *      catch it — the origin line has to.
+ *
+ *   2. **WHAT IT COST.** A return must refund the price PAID, not today's price. Resolving a
+ *      reversal against the current price table refunds last year's purchase at this year's rate,
+ *      which is wrong in whichever direction prices moved. (It is also why `ComputeAmount` refuses
+ *      a negative quantity outright: asking "which volume band does -5 land in?" has no answer.)
+ *
+ *   3. **WHICH PRODUCT.** An ID copied from the wrong row books a credit against another company's
+ *      revenue and still balances.
+ *
+ * THE SHAPE THIS SHARES WITH THE REST OF THE PACKAGE: every one of these produces a wrong answer
+ * that looks exactly like a right one. Hence refusal rather than a best guess.
+ *
+ * CONNECTS TO:
+ *   CODE: ReversalResolver (the lookups), OrderEntityServer.savePendingLines (the caller)
+ *   DOC:  plans/archive/bizapps-orders-master.md D16
+ */
+/** The line being unwound, as the database holds it. Quantity is positive — it was a sale. */
+export interface ReversalOrigin {
+    ID: string;
+    ProductID: string;
+    Quantity: number;
+    UnitPrice: number;
+    DiscountPct: number;
+    /** The origin's ALLOCATED discount — an order-level promotion's share of this line (D70). */
+    DiscountAmount?: number;
+    /** For the refusal message — an ID alone tells the reader nothing about what they mispointed at. */
+    OrderNumber?: string | null;
+}
+/** The reversal being attempted. Quantity is negative, as the caller wrote it. */
+export interface ReversalRequest {
+    ProductID: string;
+    Quantity: number;
+}
+/**
+ * How much of the origin line is still returnable.
+ *
+ * Rounded to the quantity column's 4dp scale: a prorated origin (a short first subscription period)
+ * carries a fractional quantity, and comparing an unrounded remainder against a stored one rejects
+ * a legitimate final return by a billionth of a unit.
+ */
+export declare function RemainingReturnable(originalQuantity: number, alreadyReversed: number): number;
+/**
+ * Is this reversal legal? Returns `null` when it is, and the reason it is not when it is not.
+ *
+ * A string rather than a boolean because every caller needs the reason: these refusals reach a
+ * person who is trying to process a return and has to be told what to do instead.
+ */
+export declare function ValidateReversal(request: ReversalRequest, origin: ReversalOrigin, alreadyReversed: number): string | null;
+/**
+ * What the reversal line should cost: the origin's terms, not today's.
+ *
+ * `DiscountAmount` IS PART OF THE PRICE PAID, and leaving it out was a real defect. `DiscountPct` is
+ * a rate, so it carries to any quantity unchanged — but `DiscountAmount` is an ALLOCATED cash amount
+ * (an order-level promotion's share of this line, D70), so returning half the units must give back
+ * half of it. Without that, a line that sold 4 × 100 less a 50 promotion — 350 actually paid — refunds
+ * 400, and the 50 is given away. The journal entry balances perfectly while doing it.
+ *
+ * RT7 tested exactly this concern and passed, because it used `DiscountPct`. The two fields express
+ * the same idea and only one of them was carried through. Surfaced by Marcelo on PR #17.
+ *
+ * `reversalQuantity` is what the caller intends to send back, in either sign.
+ */
+export declare function InheritedTerms(origin: ReversalOrigin, reversalQuantity: number): {
+    UnitPrice: number;
+    DiscountPct: number;
+    DiscountAmount: number;
+};
+//# sourceMappingURL=ReversalBehavior.d.ts.map

package/dist/ReversalBehavior.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReversalBehavior.d.ts","sourceRoot":"","sources":["../src/ReversalBehavior.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,8FAA8F;AAC9F,MAAM,WAAW,cAAc;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,6FAA6F;IAC7F,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,oGAAoG;IACpG,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/B;AAED,kFAAkF;AAClF,MAAM,WAAW,eAAe;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,gBAAgB,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,GAAG,MAAM,CAG7F;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC5B,OAAO,EAAE,eAAe,EACxB,MAAM,EAAE,cAAc,EACtB,eAAe,EAAE,MAAM,GACxB,MAAM,GAAG,IAAI,CAmCf;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,cAAc,CAC1B,MAAM,EAAE,cAAc,EACtB,gBAAgB,EAAE,MAAM,GACzB;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAC;IAAC,cAAc,EAAE,MAAM,CAAA;CAAE,CAWpE"}

package/dist/ReversalBehavior.js

@@ -0,0 +1,100 @@
+/**
+ * What a reversal line is allowed to be — the arithmetic, with no database in sight.
+ *
+ * A reversal line carries a negative quantity and points at the line it unwinds
+ * (`ReversesOrderLineID`). `OrderLineEntityServer` already refuses a negative quantity with no
+ * pointer, because a negative line with no origin is indistinguishable from a typo. This module
+ * answers the harder question the pointer makes possible: given the origin, is THIS reversal
+ * legitimate, and what should it cost?
+ *
+ * Three facts the origin line is the only authority on:
+ *
+ *   1. **HOW MUCH is left to give back.** Nothing else in the system knows. Over-returning produces
+ *      a perfectly balanced journal entry that refunds money never collected, so the ledger cannot
+ *      catch it — the origin line has to.
+ *
+ *   2. **WHAT IT COST.** A return must refund the price PAID, not today's price. Resolving a
+ *      reversal against the current price table refunds last year's purchase at this year's rate,
+ *      which is wrong in whichever direction prices moved. (It is also why `ComputeAmount` refuses
+ *      a negative quantity outright: asking "which volume band does -5 land in?" has no answer.)
+ *
+ *   3. **WHICH PRODUCT.** An ID copied from the wrong row books a credit against another company's
+ *      revenue and still balances.
+ *
+ * THE SHAPE THIS SHARES WITH THE REST OF THE PACKAGE: every one of these produces a wrong answer
+ * that looks exactly like a right one. Hence refusal rather than a best guess.
+ *
+ * CONNECTS TO:
+ *   CODE: ReversalResolver (the lookups), OrderEntityServer.savePendingLines (the caller)
+ *   DOC:  plans/archive/bizapps-orders-master.md D16
+ */
+/**
+ * How much of the origin line is still returnable.
+ *
+ * Rounded to the quantity column's 4dp scale: a prorated origin (a short first subscription period)
+ * carries a fractional quantity, and comparing an unrounded remainder against a stored one rejects
+ * a legitimate final return by a billionth of a unit.
+ */
+export function RemainingReturnable(originalQuantity, alreadyReversed) {
+    const remaining = Math.abs(originalQuantity) - Math.abs(alreadyReversed);
+    return Math.round(remaining * 1e4) / 1e4;
+}
+/**
+ * Is this reversal legal? Returns `null` when it is, and the reason it is not when it is not.
+ *
+ * A string rather than a boolean because every caller needs the reason: these refusals reach a
+ * person who is trying to process a return and has to be told what to do instead.
+ */
+export function ValidateReversal(request, origin, alreadyReversed) {
+    // Case-INSENSITIVE. SQL Server hands UUIDs back uppercase while application code writes them
+    // lowercase, so a `!==` here refuses every legitimate reversal — and the message it prints shows
+    // the same UUID twice, which reads as a system fault rather than as a comparison bug.
+    if (request.ProductID.toLowerCase() !== origin.ProductID.toLowerCase()) {
+        return (`This reversal line is for a different product than the line it reverses. The origin ` +
+            `line${origin.OrderNumber ? ` on order ${origin.OrderNumber}` : ''} sold product ` +
+            `${origin.ProductID}; this line names ${request.ProductID}. Point the reversal at the ` +
+            `line that actually sold this product — crediting a different product books the refund ` +
+            `against the wrong revenue account, and it still balances.`);
+    }
+    const wanted = Math.abs(request.Quantity);
+    const remaining = RemainingReturnable(origin.Quantity, alreadyReversed);
+    if (remaining <= 0) {
+        return (`Nothing remains to be returned against this line. It sold ${origin.Quantity} and ` +
+            `${Math.abs(alreadyReversed)} has already been reversed.`);
+    }
+    if (wanted > remaining) {
+        return (`Cannot return ${wanted} against a line that sold ${origin.Quantity}` +
+            `${alreadyReversed ? ` and has already had ${Math.abs(alreadyReversed)} reversed` : ''}. ` +
+            `At most ${remaining} remains returnable. Returning more than was bought refunds money ` +
+            `that was never collected, and the resulting journal entry balances, so nothing further ` +
+            `downstream would notice.`);
+    }
+    return null;
+}
+/**
+ * What the reversal line should cost: the origin's terms, not today's.
+ *
+ * `DiscountAmount` IS PART OF THE PRICE PAID, and leaving it out was a real defect. `DiscountPct` is
+ * a rate, so it carries to any quantity unchanged — but `DiscountAmount` is an ALLOCATED cash amount
+ * (an order-level promotion's share of this line, D70), so returning half the units must give back
+ * half of it. Without that, a line that sold 4 × 100 less a 50 promotion — 350 actually paid — refunds
+ * 400, and the 50 is given away. The journal entry balances perfectly while doing it.
+ *
+ * RT7 tested exactly this concern and passed, because it used `DiscountPct`. The two fields express
+ * the same idea and only one of them was carried through. Surfaced by Marcelo on PR #17.
+ *
+ * `reversalQuantity` is what the caller intends to send back, in either sign.
+ */
+export function InheritedTerms(origin, reversalQuantity) {
+    const originQty = Math.abs(origin.Quantity);
+    const share = originQty > 0 ? Math.abs(reversalQuantity) / originQty : 0;
+    // Positive: the column is CHECK (DiscountAmount >= 0) and `NetAfterDiscount` reads it as a
+    // magnitude that moves the line toward zero.
+    const allocated = Math.abs(origin.DiscountAmount ?? 0) * share;
+    return {
+        UnitPrice: origin.UnitPrice,
+        DiscountPct: origin.DiscountPct ?? 0,
+        DiscountAmount: Math.round(allocated * 100) / 100,
+    };
+}
+//# sourceMappingURL=ReversalBehavior.js.map

package/dist/ReversalBehavior.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReversalBehavior.js","sourceRoot":"","sources":["../src/ReversalBehavior.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAqBH;;;;;;GAMG;AACH,MAAM,UAAU,mBAAmB,CAAC,gBAAwB,EAAE,eAAuB;IACjF,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,CAAC,gBAAgB,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC;IACzE,OAAO,IAAI,CAAC,KAAK,CAAC,SAAS,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC;AAC7C,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,gBAAgB,CAC5B,OAAwB,EACxB,MAAsB,EACtB,eAAuB;IAEvB,6FAA6F;IAC7F,iGAAiG;IACjG,sFAAsF;IACtF,IAAI,OAAO,CAAC,SAAS,CAAC,WAAW,EAAE,KAAK,MAAM,CAAC,SAAS,CAAC,WAAW,EAAE,EAAE,CAAC;QACrE,OAAO,CACH,sFAAsF;YACtF,OAAO,MAAM,CAAC,WAAW,CAAC,CAAC,CAAC,aAAa,MAAM,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,EAAE,gBAAgB;YAClF,GAAG,MAAM,CAAC,SAAS,qBAAqB,OAAO,CAAC,SAAS,8BAA8B;YACvF,wFAAwF;YACxF,2DAA2D,CAC9D,CAAC;IACN,CAAC;IAED,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;IAC1C,MAAM,SAAS,GAAG,mBAAmB,CAAC,MAAM,CAAC,QAAQ,EAAE,eAAe,CAAC,CAAC;IAExE,IAAI,SAAS,IAAI,CAAC,EAAE,CAAC;QACjB,OAAO,CACH,6DAA6D,MAAM,CAAC,QAAQ,OAAO;YACnF,GAAG,IAAI,CAAC,GAAG,CAAC,eAAe,CAAC,6BAA6B,CAC5D,CAAC;IACN,CAAC;IAED,IAAI,MAAM,GAAG,SAAS,EAAE,CAAC;QACrB,OAAO,CACH,iBAAiB,MAAM,6BAA6B,MAAM,CAAC,QAAQ,EAAE;YACrE,GAAG,eAAe,CAAC,CAAC,CAAC,wBAAwB,IAAI,CAAC,GAAG,CAAC,eAAe,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,IAAI;YAC1F,WAAW,SAAS,oEAAoE;YACxF,yFAAyF;YACzF,0BAA0B,CAC7B,CAAC;IACN,CAAC;IAED,OAAO,IAAI,CAAC;AAChB,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,cAAc,CAC1B,MAAsB,EACtB,gBAAwB;IAExB,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;IAC5C,MAAM,KAAK,GAAG,SAAS,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,gBAAgB,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;IACzE,2FAA2F;IAC3F,6CAA6C;IAC7C,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,cAAc,IAAI,CAAC,CAAC,GAAG,KAAK,CAAC;IAC/D,OAAO;QACH,SAAS,EAAE,MAAM,CAAC,SAAS;QAC3B,WAAW,EAAE,MAAM,CAAC,WAAW,IAAI,CAAC;QACpC,cAAc,EAAE,IAAI,CAAC,KAAK,CAAC,SAAS,GAAG,GAAG,CAAC,GAAG,GAAG;KACpD,CAAC;AACN,CAAC"}

package/dist/ReversalResolver.d.ts

@@ -0,0 +1,37 @@
+/**
+ * ReversalResolver — finds the line a reversal unwinds, and how much of it is already gone.
+ *
+ * The server half of `ReversalBehavior`: this does the lookups, that does the judging. Same split
+ * as `PriceResolver`/`PricingBehavior` and for the same reason — the rule about how much may be
+ * returned is provable without a database, and only finding the rows needs one.
+ *
+ * ALREADY-REVERSED IS A SUM ACROSS ORDERS, not a flag on the line. A customer may send back two of
+ * four units in March and two more in June, on separate return orders. Each of those is individually
+ * within the original, so a guard that reads one reversal at a time passes both — and a third one
+ * too. Only the running total against the origin catches it.
+ *
+ * DRAFT AND VOIDED RETURNS DO NOT COUNT. A draft that never confirms would otherwise hold the
+ * customer's allowance hostage, and a voided one already gave it back.
+ *
+ * CONNECTS TO:
+ *   PURE:   ./ReversalBehavior.ts
+ *   CALLER: OrderEntityServer.savePendingLines (before pricing — see there for why)
+ */
+import { IMetadataProvider, UserInfo } from '@memberjunction/core';
+import type { ReversalOrigin } from './ReversalBehavior.js';
+/** The origin line plus what prior reversals have already taken from it. */
+export interface ReversalContext {
+    Origin: ReversalOrigin;
+    AlreadyReversed: number;
+}
+/**
+ * Load the origin line for `reversesOrderLineID` and total the reversals already booked against it.
+ *
+ * Returns `null` when the origin does not exist — the caller refuses, rather than treating a
+ * dangling pointer as "no constraint". A reversal pointing at nothing is the case where every
+ * guard in `ReversalBehavior` would otherwise pass vacuously.
+ */
+export declare function LoadReversalContext(reversesOrderLineID: string, provider: IMetadataProvider, user: UserInfo, 
+/** IDs to exclude from the already-reversed total — the reversal line being validated, on a re-save. */
+excludeLineIDs?: string[]): Promise<ReversalContext | null>;
+//# sourceMappingURL=ReversalResolver.d.ts.map

package/dist/ReversalResolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReversalResolver.d.ts","sourceRoot":"","sources":["../src/ReversalResolver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,EAAE,iBAAiB,EAA6B,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAC9F,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAK5D,4EAA4E;AAC5E,MAAM,WAAW,eAAe;IAC5B,MAAM,EAAE,cAAc,CAAC;IACvB,eAAe,EAAE,MAAM,CAAC;CAC3B;AAED;;;;;;GAMG;AACH,wBAAsB,mBAAmB,CACrC,mBAAmB,EAAE,MAAM,EAC3B,QAAQ,EAAE,iBAAiB,EAC3B,IAAI,EAAE,QAAQ;AACd,wGAAwG;AACxG,cAAc,GAAE,MAAM,EAAO,GAC9B,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC,CAoFjC"}

package/dist/ReversalResolver.js

@@ -0,0 +1,96 @@
+/**
+ * ReversalResolver — finds the line a reversal unwinds, and how much of it is already gone.
+ *
+ * The server half of `ReversalBehavior`: this does the lookups, that does the judging. Same split
+ * as `PriceResolver`/`PricingBehavior` and for the same reason — the rule about how much may be
+ * returned is provable without a database, and only finding the rows needs one.
+ *
+ * ALREADY-REVERSED IS A SUM ACROSS ORDERS, not a flag on the line. A customer may send back two of
+ * four units in March and two more in June, on separate return orders. Each of those is individually
+ * within the original, so a guard that reads one reversal at a time passes both — and a third one
+ * too. Only the running total against the origin catches it.
+ *
+ * DRAFT AND VOIDED RETURNS DO NOT COUNT. A draft that never confirms would otherwise hold the
+ * customer's allowance hostage, and a voided one already gave it back.
+ *
+ * CONNECTS TO:
+ *   PURE:   ./ReversalBehavior.ts
+ *   CALLER: OrderEntityServer.savePendingLines (before pricing — see there for why)
+ */
+import { RunView } from '@memberjunction/core';
+const ORDER_LINE_ENTITY = 'MJ_BizApps_Orders: Order Lines';
+const ORDER_HEADER_ENTITY = 'MJ_BizApps_Orders: Order Headers';
+/**
+ * Load the origin line for `reversesOrderLineID` and total the reversals already booked against it.
+ *
+ * Returns `null` when the origin does not exist — the caller refuses, rather than treating a
+ * dangling pointer as "no constraint". A reversal pointing at nothing is the case where every
+ * guard in `ReversalBehavior` would otherwise pass vacuously.
+ */
+export async function LoadReversalContext(reversesOrderLineID, provider, user, 
+/** IDs to exclude from the already-reversed total — the reversal line being validated, on a re-save. */
+excludeLineIDs = []) {
+    // A FORMAT CHECK ON AN INTERPOLATED ID. Everything reaching here comes from our own columns, so
+    // this is not the last line of defence against injection — but it is free, it turns a malformed
+    // pointer into a clear refusal instead of a SQL syntax error from inside a booking transaction,
+    // and it means the filter below cannot be built from arbitrary text. Raised by Marcelo on PR #17.
+    if (!/^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/.test(reversesOrderLineID)) {
+        throw new Error(`'${reversesOrderLineID}' is not a valid order line identifier, so the line it claims to ` +
+            `reverse cannot be looked up.`);
+    }
+    const rv = new RunView(provider);
+    // The origin and every reversal already pointing at it, in ONE view. Splitting them costs a
+    // round trip and buys nothing — both are order lines and both are needed.
+    const lines = await rv.RunView({
+        EntityName: ORDER_LINE_ENTITY,
+        ExtraFilter: `ID = '${reversesOrderLineID}' OR ReversesOrderLineID = '${reversesOrderLineID}'`,
+        ResultType: 'simple',
+    }, user);
+    const rows = lines?.Results ?? [];
+    const origin = rows.find((r) => String(r.ID).toLowerCase() === reversesOrderLineID.toLowerCase());
+    if (!origin)
+        return null;
+    const priors = rows.filter((r) => r !== origin);
+    // The order-line view does not carry its header's Status, and the status is what decides
+    // whether a prior reversal counts — so the headers have to be fetched. One view, not one per.
+    const statusByOrder = new Map();
+    if (priors.length) {
+        const ids = [...new Set(priors.map((p) => `'${p.OrderHeaderID}'`))].join(',');
+        const headers = await rv.RunView({
+            EntityName: ORDER_HEADER_ENTITY,
+            ExtraFilter: `ID IN (${ids})`,
+            ResultType: 'simple',
+        }, user);
+        for (const h of headers?.Results ?? []) {
+            statusByOrder.set(String(h.ID).toLowerCase(), String(h.Status ?? ''));
+        }
+    }
+    const excluded = new Set(excludeLineIDs.map((id) => id.toLowerCase()));
+    let alreadyReversed = 0;
+    for (const prior of priors) {
+        if (excluded.has(String(prior.ID).toLowerCase()))
+            continue;
+        // A Draft return has not taken anything yet and a Voided one has given it back. Anything
+        // else — Confirmed, Posted, Fulfilled — is money the customer already has. An UNKNOWN
+        // status counts: a prior reversal whose header could not be read is not evidence of room.
+        const status = statusByOrder.get(String(prior.OrderHeaderID).toLowerCase()) ?? '';
+        if (status === 'Draft' || status === 'Voided')
+            continue;
+        // `ABS` because reversal quantities are stored negative, and a signed sum here would let a
+        // reversal and a re-sale cancel out into a fresh allowance.
+        alreadyReversed += Math.abs(Number(prior.Quantity ?? 0));
+    }
+    return {
+        Origin: {
+            ID: origin.ID,
+            ProductID: origin.ProductID,
+            Quantity: Number(origin.Quantity ?? 0),
+            UnitPrice: Number(origin.UnitPrice ?? 0),
+            DiscountPct: Number(origin.DiscountPct ?? 0),
+            DiscountAmount: Number(origin.DiscountAmount ?? 0),
+            OrderNumber: null,
+        },
+        AlreadyReversed: Math.round(alreadyReversed * 1e4) / 1e4,
+    };
+}
+//# sourceMappingURL=ReversalResolver.js.map

package/dist/ReversalResolver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReversalResolver.js","sourceRoot":"","sources":["../src/ReversalResolver.ts"],"names":[],"mappings":"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"}

package/dist/SpawnRenewalsOperation.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Orders.SpawnRenewals — place the renewal orders that are due (plan D55).
+ *
+ * The last piece of the subscription lifecycle. `AutoRenew` and `RenewalLeadDays` were columns with
+ * no consumer: a subscription would reach the end of its term and simply stop, with nothing to
+ * continue it.
+ *
+ * THE DESIGN QUESTION THIS ANSWERS
+ * "Is a renewal an order the customer approves, or one the system places for them?" — BOTH, and
+ * `AutoRenew` is the switch. `AutoRenew = true` means the customer has already consented to
+ * recurring billing, so the system places a CONFIRMED order: it books, it invoices, and coverage
+ * continues without a gap. `AutoRenew = false` means it does not renew, full stop — this operation
+ * skips it and the term simply ends. Reminder-and-approve for the second case is a communication
+ * flow, not a booking one, and does not belong here.
+ *
+ * The order is placed at LEAD TIME, not on the expiry date, which is how subscription billing
+ * actually works: the invoice goes out before the period it covers. Revenue is not affected — the
+ * booking entry credits Deferred Revenue and the recognition entries are dated into the new term's
+ * own window (D14).
+ *
+ * IDEMPOTENCY, which a scheduled job makes non-negotiable
+ * Two independent guards, because this runs unattended and a double-spawn double-bills a customer:
+ *   1. the SELECTION only finds subscriptions whose LATEST term ends inside the window — once a
+ *      renewal is booked, term N+1 exists and the subscription no longer qualifies;
+ *   2. an explicit check for an existing order with `RenewsSubscriptionID` covering that term,
+ *      which catches the case where a prior pass booked the order but its term write failed.
+ * Running the operation twice in a row is a no-op, and that is asserted by the check suite.
+ *
+ * CONNECTS TO:
+ *   BOOKING: OrderEntityServer.Save — the renewal order goes through the ordinary confirm path,
+ *            so extension, term creation, GL resolution and recognition are all the SAME code
+ *   POLICY:  SubscriptionBehavior (IsRenewal bypasses ConcurrencyMode — a renewal is not a second
+ *            concurrent subscription, it is this one continuing)
+ *   TABLES:  __mj_BizAppsOrders.{Subscription,SubscriptionTerm,SubscriptionType,OrderHeader,OrderLine}
+ */
+import { BaseRemotableOperation, IMetadataProvider, UserInfo } from '@memberjunction/core';
+export interface SpawnRenewalsInput {
+    /** Treat this as "today". Defaults to now. */
+    AsOfDate?: Date | string;
+    /** Restrict to one subscription — for a targeted retry, or for a test. */
+    SubscriptionID?: string;
+    /** Report what WOULD be placed, without placing anything. */
+    Preview?: boolean;
+    /**
+     * Cap on orders placed in one pass. A safety valve for the first production run, where a
+     * mis-set lead time could otherwise invoice an entire book of business at once.
+     */
+    MaxCount?: number;
+}
+export interface RenewalCandidate {
+    SubscriptionID: string;
+    SubscriptionNumber: string;
+    ProductID: string;
+    /** End of the term that is expiring. */
+    CurrentTermEnd: string;
+    /** Lead days actually applied, after the subscription's override of the type's default. */
+    LeadDays: number;
+    /** Set when the renewal was placed (absent on a preview, or when placing failed). */
+    OrderID?: string;
+    OrderNumber?: string;
+    /** Set when this candidate was skipped, with the reason. */
+    SkippedReason?: string;
+}
+export interface SpawnRenewalsOutput {
+    Success: boolean;
+    Message?: string;
+    /** Every subscription considered due, whether or not an order was placed. */
+    Candidates: RenewalCandidate[];
+    Placed: number;
+    Skipped: number;
+}
+export declare class SpawnRenewalsOperation extends BaseRemotableOperation<SpawnRenewalsInput, SpawnRenewalsOutput> {
+    OperationKey: string;
+    protected InternalExecute(input: SpawnRenewalsInput, provider: IMetadataProvider, user: UserInfo): Promise<SpawnRenewalsOutput>;
+    /**
+     * Subscriptions whose latest term expires within their effective lead window.
+     *
+     * Raw SQL rather than RunView because the selection is inherently a JOIN across four tables with
+     * a "latest term per subscription" window — expressible in one statement and awkward as several
+     * round trips. `RenewalLeadDays` falls back from the subscription to its type, which is the
+     * inheritance rule the schema documents.
+     */
+    private findDue;
+    /** True when an order already exists that renews this subscription past the expiring term. */
+    private alreadyRenewed;
+    /**
+     * Place the renewal as an ordinary confirmed order.
+     *
+     * Deliberately NOT a special write path: routing it through `OrderEntityServer.Save` means the
+     * extension, the new term, GL resolution, the recognition schedule and the all-or-none
+     * guarantee are the same code that handles a customer purchase. A bespoke renewal writer would
+     * be a second implementation of booking, drifting from the first.
+     */
+    private placeRenewal;
+    /**
+     * Quantity for the renewal.
+     *
+     * A PRORATED source line carries a fractional quantity — the short first period into a calendar
+     * anchor (D54). Renewing at that fraction would bill half a year forever. A renewal is always a
+     * FULL period, so the fraction is dropped and the quantity rounds up to whole units.
+     */
+    private renewalQuantity;
+    private dayAfter;
+    private loadSourceLine;
+    private logEvent;
+}
+/** Tree-shaking anchor — called from the server bootstrap so the registration is retained. */
+export declare function LoadSpawnRenewalsOperation(): void;
+//# sourceMappingURL=SpawnRenewalsOperation.d.ts.map

package/dist/SpawnRenewalsOperation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SpawnRenewalsOperation.d.ts","sourceRoot":"","sources":["../src/SpawnRenewalsOperation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,OAAO,EAEH,sBAAsB,EAEtB,iBAAiB,EAIjB,QAAQ,EACX,MAAM,sBAAsB,CAAC;AAgB9B,MAAM,WAAW,kBAAkB;IAC/B,8CAA8C;IAC9C,QAAQ,CAAC,EAAE,IAAI,GAAG,MAAM,CAAC;IACzB,0EAA0E;IAC1E,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,6DAA6D;IAC7D,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,gBAAgB;IAC7B,cAAc,EAAE,MAAM,CAAC;IACvB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,wCAAwC;IACxC,cAAc,EAAE,MAAM,CAAC;IACvB,2FAA2F;IAC3F,QAAQ,EAAE,MAAM,CAAC;IACjB,qFAAqF;IACrF,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,4DAA4D;IAC5D,aAAa,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,mBAAmB;IAChC,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,6EAA6E;IAC7E,UAAU,EAAE,gBAAgB,EAAE,CAAC;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;CACnB;AAwBD,qBACa,sBAAuB,SAAQ,sBAAsB,CAAC,kBAAkB,EAAE,mBAAmB,CAAC;IAChG,YAAY,SAA0B;cAE7B,eAAe,CAC3B,KAAK,EAAE,kBAAkB,EACzB,QAAQ,EAAE,iBAAiB,EAC3B,IAAI,EAAE,QAAQ,GACf,OAAO,CAAC,mBAAmB,CAAC;IAyD/B;;;;;;;OAOG;YACW,OAAO;IA6CrB,8FAA8F;YAChF,cAAc;IA8B5B;;;;;;;OAOG;YACW,YAAY;IAsE1B;;;;;;OAMG;IACH,OAAO,CAAC,eAAe;IAKvB,OAAO,CAAC,QAAQ;YAKF,cAAc;YAmBd,QAAQ;CA0BzB;AAED,8FAA8F;AAC9F,wBAAgB,0BAA0B,IAAI,IAAI,CAEjD"}