@mj-biz-apps/contracts-core-entities-server 0.1.0

package/dist/ContractTemplateProvisionEntityServer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContractTemplateProvisionEntityServer.d.ts","sourceRoot":"","sources":["../src/ContractTemplateProvisionEntityServer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,OAAO,EAEH,KAAK,mBAAmB,EAGxB,gBAAgB,EACnB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EAAE,+BAA+B,EAAsB,MAAM,iCAAiC,CAAC;AAmBtG,qBACa,qCAAsC,SAAQ,+BAA+B;IACtF;;;;;;;;;;;OAWG;IACmB,aAAa,IAAI,OAAO,CAAC,gBAAgB,CAAC;IAgDhE;;;;OAIG;IACmB,MAAM,CAAC,OAAO,CAAC,EAAE,mBAAmB,GAAG,OAAO,CAAC,OAAO,CAAC;IA6B7E;;;;;;;;;OASG;IACH,OAAO,CAAC,YAAY;IASpB;;;;;;;;;OASG;YACW,mBAAmB;CAmBpC;AAED,yDAAyD;AACzD,wBAAgB,yCAAyC,IAAI,IAAI,CAEhE"}

package/dist/ContractTemplateProvisionEntityServer.js

@@ -0,0 +1,171 @@
+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;
+};
+/**
+ * @fileoverview `ContractTemplateProvisionEntityServer` — a signed clause is a historical record.
+ *
+ * Two rules, both about the same fact: once a contract incorporates a template, that template's
+ * provisions are what somebody agreed to.
+ *
+ *   **R-1** the TERMS (`ProvisionNumber`, `Title`, `ProvisionText`) cannot change, and the provision
+ *           cannot be deleted, while any contract references its template.
+ *   **R-8** and independently of R-1, a provision cannot be deleted while modifications cite it.
+ *
+ * ## The trigger is the floor; this class exists for the sentence
+ *
+ * `trg_ContractTemplateProvision_Immutability` (V202608200100) enforces R-1 against ANY writer — raw
+ * SQL, a future service, another app, a data load — because rewriting signed terms is the case where a
+ * bypass is silent corruption rather than a bad edit in our own UI. What a trigger cannot do is
+ * explain itself: it reaches the user as a raw SQL error naming no field.
+ *
+ * **That is not a nicety here, it is a correctness requirement for R-8.** R-8's whole point is that a
+ * refused delete reads as a sentence instead of a constraint. If this class checked only the
+ * modification dependency and let the trigger catch the template-referenced case, then deleting an
+ * unmodified provision of a referenced template would sail past the guard and die in the database —
+ * producing exactly the raw error R-8 was written to eliminate. So the code half must cover **both**
+ * conditions the trigger covers, or the guard has a hole shaped like the trigger.
+ *
+ * @module @mj-biz-apps/contracts-core-entities-server
+ */
+import { BaseEntity, ValidationErrorInfo, ValidationErrorType, } from '@memberjunction/core';
+import { RegisterClass } from '@memberjunction/global';
+import { ContractTemplateProvisionEntity, TEMPLATE_PUBLISHED } from '@mj-biz-apps/contracts-entities';
+import { GuardedDelete, RefuseDelete, plural } from './delete-guard.js';
+/**
+ * The columns that ARE the terms. `Description` and `Sequence` are deliberately absent: ordering a
+ * document and annotating it internally are not changing what it says, so they stay editable on a
+ * referenced template. This list must stay in step with the trigger's comparison — the trigger is the
+ * floor and a divergence would mean the code permits an edit the database then refuses raw.
+ */
+const FROZEN_TERM_FIELDS = [
+    { Name: 'ProvisionNumber', Label: 'the clause number' },
+    { Name: 'Title', Label: 'the clause title' },
+    { Name: 'ProvisionText', Label: 'the standard wording' },
+];
+/*
+ * EXTENDS THE SHARED SUBCLASS, not the generated one — so an API caller gets the required-field prose
+ * too, not just a browser. Same reason `ContractEntityServer extends ContractEntity`.
+ */
+let ContractTemplateProvisionEntityServer = class ContractTemplateProvisionEntityServer extends ContractTemplateProvisionEntity {
+    /**
+     * R-1 — refuse an edit to the terms of a provision whose template is referenced.
+     *
+     * Gated on `IsSaved` (a provision being created cannot have been agreed to yet) and on a field
+     * actually being dirty, so the ordinary save of an unreferenced or cosmetically-edited provision
+     * pays **nothing** — no probe at all. The reference count runs only when a frozen field really
+     * changed, which is the shape that makes belt-and-braces affordable.
+     *
+     * Compares `OldValue` to `Value` in memory rather than probing the database, for the same reason
+     * `GLAccountEntityServer` does: the entity already knows what it loaded. One error per changed
+     * field, each naming that field, so the form marks the offending input rather than showing a banner.
+     */
+    async ValidateAsync() {
+        const result = await super.ValidateAsync();
+        // CREATE on a published version. The trigger is the floor here too, but it cannot explain
+        // itself on this path at all: MJ calls the generated sproc as `INSERT ... EXEC`, inside which
+        // SQL Server forbids a trigger from issuing ROLLBACK, so the refusal arrived as
+        // "Cannot use the ROLLBACK statement within an INSERT-EXEC statement" — a message about the
+        // mechanism, naming neither the rule nor the field. This is the sentence a user should get.
+        if (!this.IsSaved) {
+            if (this.ContractTemplateID && (await this.templateIsPublished())) {
+                result.Success = false;
+                result.Errors.push(new ValidationErrorInfo('ContractTemplateID', `This agreement version is published, so a clause cannot be added to it — that would ` +
+                    `silently grow the terms of every contract already referencing it. Publish a new ` +
+                    `version instead.`, this.ContractTemplateID, ValidationErrorType.Failure));
+            }
+            return result;
+        }
+        const changed = FROZEN_TERM_FIELDS.filter((f) => this.fieldChanged(f.Name));
+        if (changed.length === 0)
+            return result;
+        // Only now is a read worth doing.
+        if (!(await this.templateIsPublished()))
+            return result;
+        for (const field of changed) {
+            result.Success = false;
+            result.Errors.push(new ValidationErrorInfo(field.Name, `This agreement version is published, so ${field.Label} cannot change — editing it would ` +
+                `rewrite what any customer who signed against it agreed to. Publish a new version instead; ` +
+                `a published version is a historical record. (The description is still editable.)`, this.Get(field.Name), ValidationErrorType.Failure));
+        }
+        return result;
+    }
+    /**
+     * Both delete conditions — R-8's modifications, and R-1's referenced template.
+     *
+     * Reported together rather than first-wins, so someone is not refused twice for two reasons.
+     */
+    async Delete(options) {
+        // The published check first, and separately from the dependency list, because it is not a
+        // dependency — nothing points at this row, the VERSION is simply closed. Pre-empting the
+        // trigger here is what turns its raw SQL error into a sentence (the whole point of R-8).
+        if (await this.templateIsPublished()) {
+            return RefuseDelete(this, `Provision ${this.ProvisionNumber ?? ''} cannot be deleted: this agreement version is published, ` +
+                `and removing a clause from an agreement someone signed is the same act as rewriting it. ` +
+                `Publish a new version instead.`);
+        }
+        return GuardedDelete(this, options, `Provision ${this.ProvisionNumber ?? ''} cannot be deleted.`, [
+            {
+                EntityName: 'MJ_BizApps_Contracts: Contract Template Modifications',
+                Filter: `ContractTemplateProvisionID = '${this.ID}'`,
+                Describe: (n) => `${plural(n, 'contract')} negotiated different wording for this clause, and the negotiated ` +
+                    `text is only meaningful beside the standard text it replaces.`,
+            },
+        ], (o) => super.Delete(o));
+    }
+    /**
+     * Whether a field's value differs from what was loaded.
+     *
+     * Trimmed string comparison: `ProvisionText` is free text, and MJ round-trips trailing whitespace
+     * inconsistently enough that treating `"x "` as an edit to `"x"` would refuse a save nobody meant
+     * to make. The trigger uses exact comparison, so the code is very slightly more permissive than the
+     * floor — which is the correct direction for the pair: the code never permits something the trigger
+     * would reject on a DIFFERENT value, it only declines to complain about a whitespace-only diff that
+     * the trigger would also see. If that ever diverges materially the trigger still holds the line.
+     */
+    fieldChanged(fieldName) {
+        const field = this.GetFieldByName(fieldName);
+        if (!field)
+            return false;
+        const before = field.OldValue;
+        const after = field.Value;
+        if (before === after)
+            return false;
+        return String(before ?? '').trim() !== String(after ?? '').trim();
+    }
+    /**
+     * Whether this provision's template is PUBLISHED.
+     *
+     * ⚠ THIS USED TO ASK "do any contracts reference the template", and that gate was wrong in BOTH
+     * directions (V202608200900). Too strict: a provision added after a contract referenced the
+     * template was never part of what anyone signed, yet became immediately unremovable — and the live
+     * data had referenced templates still being authored, which the rule stranded with no way to
+     * finish. Too loose: it said nothing about INSERT, so a clause could be ADDED to a signed version.
+     * Publication is now an explicit act and the gate reads it directly.
+     */
+    async templateIsPublished() {
+        const result = await this.RunViewProviderToUse.RunView({
+            EntityName: 'MJ_BizApps_Contracts: Contract Templates',
+            ExtraFilter: `ID = '${this.ContractTemplateID}'`,
+            Fields: ['Status'],
+            ResultType: 'simple',
+        }, this.ContextCurrentUser);
+        if (!result?.Success) {
+            // Must not read as "draft" — that would wave through the very edit this guards.
+            throw new Error(`Could not read the publication status of this provision's agreement version: ` +
+                `${result?.ErrorMessage ?? 'unknown error'}. The save was not attempted.`);
+        }
+        return result.Results?.[0]?.Status === TEMPLATE_PUBLISHED;
+    }
+};
+ContractTemplateProvisionEntityServer = __decorate([
+    RegisterClass(BaseEntity, 'MJ_BizApps_Contracts: Contract Template Provisions')
+], ContractTemplateProvisionEntityServer);
+export { ContractTemplateProvisionEntityServer };
+/** Anti-tree-shake anchor — see the note in index.ts. */
+export function LoadContractTemplateProvisionEntityServer() {
+    void ContractTemplateProvisionEntityServer;
+}
+//# sourceMappingURL=ContractTemplateProvisionEntityServer.js.map

package/dist/ContractTemplateProvisionEntityServer.js.map

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

package/dist/ContractTypeEntityServers.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @fileoverview The two lookup types' delete guards — and the usability trap they close.
+ *
+ * The Configuration page tells people to retire a type by setting `Status = 'Inactive'`, and the grid
+ * then offers Delete anyway with no explanation of why it fails. So the refusal here does more than
+ * name the blocker: it says what to do instead, because the user has already been told the right
+ * answer somewhere they are not currently looking.
+ *
+ * This is the pair R-5 completes. R-5 stops a retired type being newly SELECTED; these stop it being
+ * DELETED. Between them, "retire" is a coherent operation: existing records keep working, new ones
+ * cannot choose it, and nobody has to delete anything.
+ *
+ * TWO CLASSES IN ONE FILE, matching `ContractTypeEntity.ts` on the shared side: they are the same rule
+ * on the two lookup tables, and splitting them would put four lines in each of two files.
+ *
+ * @module @mj-biz-apps/contracts-core-entities-server
+ */
+import { type EntityDeleteOptions } from '@memberjunction/core';
+import { mjBizAppsContractsContractTemplateTypeEntity, mjBizAppsContractsContractTypeEntity } from '@mj-biz-apps/contracts-entities';
+export declare class ContractTypeEntityServer extends mjBizAppsContractsContractTypeEntity {
+    Delete(options?: EntityDeleteOptions): Promise<boolean>;
+}
+export declare class ContractTemplateTypeEntityServer extends mjBizAppsContractsContractTemplateTypeEntity {
+    Delete(options?: EntityDeleteOptions): Promise<boolean>;
+}
+/** Anti-tree-shake anchor — see the note in index.ts. */
+export declare function LoadContractTypeEntityServers(): void;
+//# sourceMappingURL=ContractTypeEntityServers.d.ts.map

package/dist/ContractTypeEntityServers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContractTypeEntityServers.d.ts","sourceRoot":"","sources":["../src/ContractTypeEntityServers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,EAAc,KAAK,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAE5E,OAAO,EACH,4CAA4C,EAC5C,oCAAoC,EACvC,MAAM,iCAAiC,CAAC;AAMzC,qBACa,wBAAyB,SAAQ,oCAAoC;IACxD,MAAM,CAAC,OAAO,CAAC,EAAE,mBAAmB,GAAG,OAAO,CAAC,OAAO,CAAC;CAehF;AAED,qBACa,gCAAiC,SAAQ,4CAA4C;IACxE,MAAM,CAAC,OAAO,CAAC,EAAE,mBAAmB,GAAG,OAAO,CAAC,OAAO,CAAC;CAehF;AAED,yDAAyD;AACzD,wBAAgB,6BAA6B,IAAI,IAAI,CAGpD"}

package/dist/ContractTypeEntityServers.js

@@ -0,0 +1,65 @@
+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;
+};
+/**
+ * @fileoverview The two lookup types' delete guards — and the usability trap they close.
+ *
+ * The Configuration page tells people to retire a type by setting `Status = 'Inactive'`, and the grid
+ * then offers Delete anyway with no explanation of why it fails. So the refusal here does more than
+ * name the blocker: it says what to do instead, because the user has already been told the right
+ * answer somewhere they are not currently looking.
+ *
+ * This is the pair R-5 completes. R-5 stops a retired type being newly SELECTED; these stop it being
+ * DELETED. Between them, "retire" is a coherent operation: existing records keep working, new ones
+ * cannot choose it, and nobody has to delete anything.
+ *
+ * TWO CLASSES IN ONE FILE, matching `ContractTypeEntity.ts` on the shared side: they are the same rule
+ * on the two lookup tables, and splitting them would put four lines in each of two files.
+ *
+ * @module @mj-biz-apps/contracts-core-entities-server
+ */
+import { BaseEntity } from '@memberjunction/core';
+import { RegisterClass } from '@memberjunction/global';
+import { mjBizAppsContractsContractTemplateTypeEntity, mjBizAppsContractsContractTypeEntity, } from '@mj-biz-apps/contracts-entities';
+import { GuardedDelete, plural } from './delete-guard.js';
+/** How to retire instead of deleting — the same advice in both messages, written once. */
+const RETIRE_INSTEAD = `Retiring is what you want: set Status to Inactive, which stops it being offered for new records and leaves the existing ones working.`;
+let ContractTypeEntityServer = class ContractTypeEntityServer extends mjBizAppsContractsContractTypeEntity {
+    async Delete(options) {
+        return GuardedDelete(this, options, `Contract type "${this.Name ?? this.ID}" cannot be deleted.`, [
+            {
+                EntityName: 'MJ_BizApps_Contracts: Contracts',
+                Filter: `ContractTypeID = '${this.ID}'`,
+                Describe: (n) => `${plural(n, 'contract')} ${n === 1 ? 'is' : 'are'} of this type. ${RETIRE_INSTEAD}`,
+            },
+        ], (o) => super.Delete(o));
+    }
+};
+ContractTypeEntityServer = __decorate([
+    RegisterClass(BaseEntity, 'MJ_BizApps_Contracts: Contract Types')
+], ContractTypeEntityServer);
+export { ContractTypeEntityServer };
+let ContractTemplateTypeEntityServer = class ContractTemplateTypeEntityServer extends mjBizAppsContractsContractTemplateTypeEntity {
+    async Delete(options) {
+        return GuardedDelete(this, options, `Template type "${this.Name ?? this.ID}" cannot be deleted.`, [
+            {
+                EntityName: 'MJ_BizApps_Contracts: Contract Templates',
+                Filter: `ContractTemplateTypeID = '${this.ID}'`,
+                Describe: (n) => `${plural(n, 'template')} ${n === 1 ? 'is' : 'are'} of this type. ${RETIRE_INSTEAD}`,
+            },
+        ], (o) => super.Delete(o));
+    }
+};
+ContractTemplateTypeEntityServer = __decorate([
+    RegisterClass(BaseEntity, 'MJ_BizApps_Contracts: Contract Template Types')
+], ContractTemplateTypeEntityServer);
+export { ContractTemplateTypeEntityServer };
+/** Anti-tree-shake anchor — see the note in index.ts. */
+export function LoadContractTypeEntityServers() {
+    void ContractTypeEntityServer;
+    void ContractTemplateTypeEntityServer;
+}
+//# sourceMappingURL=ContractTypeEntityServers.js.map

package/dist/ContractTypeEntityServers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContractTypeEntityServers.js","sourceRoot":"","sources":["../src/ContractTypeEntityServers.ts"],"names":[],"mappings":";;;;;;AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,EAAE,UAAU,EAA4B,MAAM,sBAAsB,CAAC;AAC5E,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EACH,4CAA4C,EAC5C,oCAAoC,GACvC,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAE1D,0FAA0F;AAC1F,MAAM,cAAc,GAAG,uIAAuI,CAAC;AAGxJ,IAAM,wBAAwB,GAA9B,MAAM,wBAAyB,SAAQ,oCAAoC;IAC9D,KAAK,CAAC,MAAM,CAAC,OAA6B;QACtD,OAAO,aAAa,CAChB,IAAI,EACJ,OAAO,EACP,kBAAkB,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,EAAE,sBAAsB,EAC5D;YACI;gBACI,UAAU,EAAE,iCAAiC;gBAC7C,MAAM,EAAE,qBAAqB,IAAI,CAAC,EAAE,GAAG;gBACvC,QAAQ,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,MAAM,CAAC,CAAC,EAAE,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,kBAAkB,cAAc,EAAE;aACxG;SACJ,EACD,CAAC,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CACzB,CAAC;IACN,CAAC;CACJ,CAAA;AAhBY,wBAAwB;IADpC,aAAa,CAAC,UAAU,EAAE,sCAAsC,CAAC;GACrD,wBAAwB,CAgBpC;;AAGM,IAAM,gCAAgC,GAAtC,MAAM,gCAAiC,SAAQ,4CAA4C;IAC9E,KAAK,CAAC,MAAM,CAAC,OAA6B;QACtD,OAAO,aAAa,CAChB,IAAI,EACJ,OAAO,EACP,kBAAkB,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,EAAE,sBAAsB,EAC5D;YACI;gBACI,UAAU,EAAE,0CAA0C;gBACtD,MAAM,EAAE,6BAA6B,IAAI,CAAC,EAAE,GAAG;gBAC/C,QAAQ,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,MAAM,CAAC,CAAC,EAAE,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,kBAAkB,cAAc,EAAE;aACxG;SACJ,EACD,CAAC,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CACzB,CAAC;IACN,CAAC;CACJ,CAAA;AAhBY,gCAAgC;IAD5C,aAAa,CAAC,UAAU,EAAE,+CAA+C,CAAC;GAC9D,gCAAgC,CAgB5C;;AAED,yDAAyD;AACzD,MAAM,UAAU,6BAA6B;IACzC,KAAK,wBAAwB,CAAC;IAC9B,KAAK,gCAAgC,CAAC;AAC1C,CAAC"}

package/dist/SupersedeOperation.d.ts

@@ -0,0 +1,53 @@
+/**
+ * @fileoverview `Contracts.Supersede` — set (or clear) which contract an agreement replaces.
+ *
+ * WHY A REMOTABLE OPERATION AND NOT ENTITY CALLS FROM THE PANEL. The write targets a DIFFERENT record
+ * from the one on screen: `SupersededByContractID` lives on the PREDECESSOR, so the successor's form
+ * has to reach over and write another contract. Doing that from the browser meant the panel loading
+ * and saving foreign entities itself — server work done in the client. Ruled by Marcelo (2026-08-21):
+ * a cross-record write with rules is exactly what a remote operation is for.
+ *
+ * It also makes the feature immune to MJ#4002, where the browser resolves the CodeGen-generated entity
+ * class instead of the app's subclass, so `ContractEntity.Supersede()` is simply absent client-side.
+ * Here the work runs on the server, where the server subclass resolves correctly and every rule in
+ * `ContractEntityServer.ValidateAsync()` — same-level, self-reference, lineage cycles — actually fires.
+ *
+ * REPLACE, NOT ADD. The schema deliberately allows MANY predecessors to name one successor
+ * (consolidation), so setting a new predecessor without releasing the old one leaves the agreement
+ * quietly superseding BOTH. The UI is a single-select, so one predecessor is the intent: release the
+ * others, then link. Passing `PredecessorID: null` releases everything and links nothing, which is
+ * what "unlink" is.
+ *
+ * NO transaction wrapper, deliberately. Each contract is saved through its own entity so every rule
+ * runs, and the outcome is reported per-record. A half-applied change is visible in the returned list
+ * rather than hidden behind a rollback that also discards the reason it failed.
+ *
+ * @module @mj-biz-apps/contracts-core-entities-server
+ */
+import { BaseRemotableOperation, type IMetadataProvider, type RemoteOpServerContext, type UserInfo } from '@memberjunction/core';
+export interface SupersedeInput {
+    /** The agreement doing the superseding — the record the user is looking at. */
+    SuccessorID: string;
+    /** The agreement being replaced. `null` releases every predecessor and links none (unlink). */
+    PredecessorID: string | null;
+}
+export interface SupersedeOutput {
+    /** What the successor supersedes AFTER the operation — the panel renders this, so it can never be stale. */
+    Supersedes: Array<{
+        ID: string;
+        ContractNumber: string;
+    }>;
+    /** Contract numbers released by this call. */
+    Released: string[];
+    /** Set when the link was refused; carries the entity's own message, not a generic failure. */
+    Refused?: string;
+}
+export declare class SupersedeOperation extends BaseRemotableOperation<SupersedeInput, SupersedeOutput> {
+    readonly OperationKey = "Contracts.Supersede";
+    protected InternalExecute(input: SupersedeInput, provider: IMetadataProvider, user: UserInfo, _context: RemoteOpServerContext): Promise<SupersedeOutput>;
+    /** Live read of what a contract supersedes — returned to the caller so its list is never cached. */
+    private readSupersedes;
+}
+/** Anti-tree-shake anchor — without a live reference the @RegisterClass side effect can be dropped. */
+export declare function LoadSupersedeOperation(): void;
+//# sourceMappingURL=SupersedeOperation.d.ts.map

package/dist/SupersedeOperation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SupersedeOperation.d.ts","sourceRoot":"","sources":["../src/SupersedeOperation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,OAAO,EACH,sBAAsB,EACtB,KAAK,iBAAiB,EACtB,KAAK,qBAAqB,EAE1B,KAAK,QAAQ,EAChB,MAAM,sBAAsB,CAAC;AAM9B,MAAM,WAAW,cAAc;IAC3B,+EAA+E;IAC/E,WAAW,EAAE,MAAM,CAAC;IACpB,+FAA+F;IAC/F,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;CAChC;AAED,MAAM,WAAW,eAAe;IAC5B,4GAA4G;IAC5G,UAAU,EAAE,KAAK,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC1D,8CAA8C;IAC9C,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,8FAA8F;IAC9F,OAAO,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,qBACa,kBAAmB,SAAQ,sBAAsB,CAAC,cAAc,EAAE,eAAe,CAAC;IAC3F,SAAgB,YAAY,yBAAyB;cAE5B,eAAe,CACpC,KAAK,EAAE,cAAc,EACrB,QAAQ,EAAE,iBAAiB,EAC3B,IAAI,EAAE,QAAQ,EACd,QAAQ,EAAE,qBAAqB,GAChC,OAAO,CAAC,eAAe,CAAC;IAsD3B,oGAAoG;YACtF,cAAc;CAkB/B;AAED,uGAAuG;AACvG,wBAAgB,sBAAsB,IAAI,IAAI,CAE7C"}

package/dist/SupersedeOperation.js

@@ -0,0 +1,112 @@
+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;
+};
+/**
+ * @fileoverview `Contracts.Supersede` — set (or clear) which contract an agreement replaces.
+ *
+ * WHY A REMOTABLE OPERATION AND NOT ENTITY CALLS FROM THE PANEL. The write targets a DIFFERENT record
+ * from the one on screen: `SupersededByContractID` lives on the PREDECESSOR, so the successor's form
+ * has to reach over and write another contract. Doing that from the browser meant the panel loading
+ * and saving foreign entities itself — server work done in the client. Ruled by Marcelo (2026-08-21):
+ * a cross-record write with rules is exactly what a remote operation is for.
+ *
+ * It also makes the feature immune to MJ#4002, where the browser resolves the CodeGen-generated entity
+ * class instead of the app's subclass, so `ContractEntity.Supersede()` is simply absent client-side.
+ * Here the work runs on the server, where the server subclass resolves correctly and every rule in
+ * `ContractEntityServer.ValidateAsync()` — same-level, self-reference, lineage cycles — actually fires.
+ *
+ * REPLACE, NOT ADD. The schema deliberately allows MANY predecessors to name one successor
+ * (consolidation), so setting a new predecessor without releasing the old one leaves the agreement
+ * quietly superseding BOTH. The UI is a single-select, so one predecessor is the intent: release the
+ * others, then link. Passing `PredecessorID: null` releases everything and links nothing, which is
+ * what "unlink" is.
+ *
+ * NO transaction wrapper, deliberately. Each contract is saved through its own entity so every rule
+ * runs, and the outcome is reported per-record. A half-applied change is visible in the returned list
+ * rather than hidden behind a rollback that also discards the reason it failed.
+ *
+ * @module @mj-biz-apps/contracts-core-entities-server
+ */
+import { BaseRemotableOperation, RunView, } from '@memberjunction/core';
+import { RegisterClass } from '@memberjunction/global';
+const E_CONTRACT = 'MJ_BizApps_Contracts: Contracts';
+let SupersedeOperation = class SupersedeOperation extends BaseRemotableOperation {
+    constructor() {
+        super(...arguments);
+        this.OperationKey = 'Contracts.Supersede';
+    }
+    async InternalExecute(input, provider, user, _context) {
+        if (!input?.SuccessorID)
+            throw new Error('SuccessorID is required.');
+        const successor = await provider.GetEntityObject(E_CONTRACT, user);
+        if (!(await successor.Load(input.SuccessorID))) {
+            throw new Error('The contract doing the superseding could not be loaded.');
+        }
+        const released = [];
+        const same = (a, b) => !!a && !!b && a.toLowerCase() === b.toLowerCase();
+        // Release every predecessor except the one being (re-)linked, so re-picking the same contract
+        // is a no-op rather than a clear-and-reset.
+        for (const current of await this.readSupersedes(provider, user, input.SuccessorID)) {
+            if (same(current.ID, input.PredecessorID))
+                continue;
+            const previous = await provider.GetEntityObject(E_CONTRACT, user);
+            if (!(await previous.Load(current.ID)))
+                continue;
+            previous.SupersededByContractID = null;
+            if (!(await previous.Save())) {
+                return {
+                    Supersedes: await this.readSupersedes(provider, user, input.SuccessorID),
+                    Released: released,
+                    Refused: previous.LatestResult?.Message ??
+                        `Could not release ${current.ContractNumber}; nothing else was changed.`,
+                };
+            }
+            released.push(current.ContractNumber);
+        }
+        if (input.PredecessorID && !same(input.PredecessorID, input.SuccessorID)) {
+            const predecessor = await provider.GetEntityObject(E_CONTRACT, user);
+            if (!(await predecessor.Load(input.PredecessorID))) {
+                throw new Error('The contract to be superseded could not be loaded.');
+            }
+            // Through Supersede(), not a bare field write, so the entity keeps owning the rule.
+            predecessor.Supersede(successor);
+            if (!(await predecessor.Save())) {
+                return {
+                    Supersedes: await this.readSupersedes(provider, user, input.SuccessorID),
+                    Released: released,
+                    // The server guards produce field-named prose (same-level, self-reference, cycles);
+                    // that message is far more use than "the save failed".
+                    Refused: predecessor.LatestResult?.Message ?? 'That contract could not be marked superseded.',
+                };
+            }
+        }
+        return {
+            Supersedes: await this.readSupersedes(provider, user, input.SuccessorID),
+            Released: released,
+        };
+    }
+    /** Live read of what a contract supersedes — returned to the caller so its list is never cached. */
+    async readSupersedes(provider, user, successorID) {
+        const rv = RunView.FromMetadataProvider(provider);
+        const r = await rv.RunView({
+            EntityName: E_CONTRACT,
+            Fields: ['ID', 'ContractNumber'],
+            ExtraFilter: `SupersededByContractID = '${successorID.replace(/'/g, "''")}'`,
+            OrderBy: 'ContractNumber ASC',
+            ResultType: 'simple',
+        }, user);
+        return r?.Success ? r.Results : [];
+    }
+};
+SupersedeOperation = __decorate([
+    RegisterClass(BaseRemotableOperation, 'Contracts.Supersede')
+], SupersedeOperation);
+export { SupersedeOperation };
+/** Anti-tree-shake anchor — without a live reference the @RegisterClass side effect can be dropped. */
+export function LoadSupersedeOperation() {
+    // no-op
+}
+//# sourceMappingURL=SupersedeOperation.js.map

package/dist/SupersedeOperation.js.map

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

package/dist/delete-guard.d.ts

@@ -0,0 +1,89 @@
+/**
+ * @fileoverview R-8 — turning a foreign-key violation into a sentence.
+ *
+ * Every FK in this schema is `NO_ACTION`, which is the correct behaviour: a delete that would orphan
+ * data is refused. The problem is only that it reaches the user as a constraint name. Four entities
+ * need the same treatment and differ ONLY in which rows to count, so this is one guard parameterised
+ * by the dependencies rather than four copies of the same shape drifting apart — the review test from
+ * ORCHESTRATION.md ("if I had to change this logic, how many places would I have to find?").
+ *
+ * ## Why `Delete()` and not a validation hook
+ *
+ * `BaseEntity` has no delete-side counterpart to `Validate()` — no `ValidateDelete`, no `BeforeDelete`,
+ * no vetoable event. Verified by reading `_InnerDelete`, which runs no validation at all where
+ * `_InnerSave` runs `Validate()`/`ValidateAsync()` first. So the only seam is overriding `Delete()`.
+ * Filed upstream as [MJ#3971](https://github.com/MemberJunction/MJ/issues/3971), and a fix is already
+ * authored there; when it lands, these overrides become `ValidateDeleteAsync()` bodies and this file
+ * shrinks rather than disappears.
+ *
+ * ## Why it REGISTERS A RESULT and returns false, instead of throwing
+ *
+ * `bizapps-accounting`'s two precedents (`JournalEntryTypeEntityServer`, `JournalEntryLineEntityServer`)
+ * **throw**. That works, and it is not what this does, deliberately:
+ *
+ *   · `Delete()` is declared `Promise<boolean>`. A caller written against that signature does
+ *     `if (!await entity.Delete())` and gets an exception instead of `false`.
+ *   · `LatestResult` is how MJ carries the reason for a refused write — it is what `ResolverBase`
+ *     reads to build the GraphQL error, and what a refused `Save()` already populates. Throwing routes
+ *     around the one channel built for this.
+ *   · `RegisterResultHistoryEntry` is public precisely so a subclass can do this.
+ *
+ * ⚠ **This depends on an MJ fix to be VISIBLE.** `ResolverBase.DeleteRecord` read
+ * `LatestResult?.Message` rather than `CompleteMessage`, so a registered refusal reached the API as
+ * the literal string "Unknown error". Measured on this instance; the one-word fix is applied locally
+ * in `instances/contracts-mj6/mj` and was commented onto MJ#3973. **On an unpatched MJ these messages
+ * are correct and invisible** — the delete is still refused, so this is a message-quality dependency,
+ * not a correctness one.
+ *
+ * @module @mj-biz-apps/contracts-core-entities-server
+ */
+import { BaseEntity, type EntityDeleteOptions } from '@memberjunction/core';
+/**
+ * One thing that can block a delete: the rows to look for, and how to describe them once counted.
+ *
+ * `describe` takes the count because the useful sentence names it — "3 contracts negotiated this
+ * clause" tells someone how much work the cleanup is, where "this clause is in use" does not.
+ */
+export type DeleteDependency = {
+    /** The MJ entity name holding the referencing rows. */
+    EntityName: string;
+    /** `ExtraFilter` selecting the rows that reference the record being deleted. */
+    Filter: string;
+    /** The clause describing what was found, given how many. */
+    Describe: (count: number) => string;
+};
+/**
+ * Count each dependency and return the refusal text, or null when nothing blocks the delete.
+ *
+ * COUNTS, NOT EXISTENCE. `count_only` costs the same as `TOP 1` on an indexed FK (MJ auto-indexes
+ * every FK), and the number is most of the value of the message.
+ *
+ * ALL dependencies are checked, not just the first. Deleting a template usually trips both its
+ * provisions and its contracts, and being told about one, fixing it, and then being refused again for
+ * the other is the worst version of this interaction.
+ *
+ * A FAILED COUNT ABORTS rather than defaulting to zero. Reading "could not verify" as "nothing
+ * references it" would let this guard wave through exactly the delete it exists to stop; the FK is
+ * still the floor, but a guard that fails open is worse than no guard because it looks like one.
+ */
+export declare function DescribeDeleteBlockers(entity: BaseEntity, dependencies: readonly DeleteDependency[]): Promise<string | null>;
+/**
+ * Record a delete refusal on the entity so `LatestResult` carries the reason, and return false.
+ *
+ * Registered BEFORE `super.Delete()` is ever called, so nothing else has written a result — `Message`
+ * is what `CompleteMessage` reads first, so the sentence survives without needing an `Errors` entry.
+ * There is no field to name: a delete refusal is about the record, not about one of its columns, which
+ * is part of why `ValidationErrorInfo` is the wrong vehicle here and MJ#3971 asks for a delete-shaped
+ * one.
+ */
+export declare function RefuseDelete(entity: BaseEntity, message: string): false;
+/**
+ * The whole guard: count the blockers, refuse with an explanation if there are any, otherwise delete.
+ *
+ * Every subclass override is one call to this, which is the point — the only thing that varies between
+ * the four is the dependency list and the leading sentence.
+ */
+export declare function GuardedDelete(entity: BaseEntity, options: EntityDeleteOptions | undefined, lead: string, dependencies: readonly DeleteDependency[], superDelete: (options?: EntityDeleteOptions) => Promise<boolean>): Promise<boolean>;
+/** `'1 contract'` / `'3 contracts'` — so a message never reads "1 contracts". */
+export declare function plural(count: number, singular: string, pluralForm?: string): string;
+//# sourceMappingURL=delete-guard.d.ts.map

package/dist/delete-guard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delete-guard.d.ts","sourceRoot":"","sources":["../src/delete-guard.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,OAAO,EAAE,UAAU,EAAoB,KAAK,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAE9F;;;;;GAKG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC3B,uDAAuD;IACvD,UAAU,EAAE,MAAM,CAAC;IACnB,gFAAgF;IAChF,MAAM,EAAE,MAAM,CAAC;IACf,4DAA4D;IAC5D,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;CACvC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,wBAAsB,sBAAsB,CAAC,MAAM,EAAE,UAAU,EAAE,YAAY,EAAE,SAAS,gBAAgB,EAAE,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAuBlI;AAED;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,GAAG,KAAK,CAQvE;AAED;;;;;GAKG;AACH,wBAAsB,aAAa,CAC/B,MAAM,EAAE,UAAU,EAClB,OAAO,EAAE,mBAAmB,GAAG,SAAS,EACxC,IAAI,EAAE,MAAM,EACZ,YAAY,EAAE,SAAS,gBAAgB,EAAE,EACzC,WAAW,EAAE,CAAC,OAAO,CAAC,EAAE,mBAAmB,KAAK,OAAO,CAAC,OAAO,CAAC,GACjE,OAAO,CAAC,OAAO,CAAC,CAIlB;AAED,iFAAiF;AACjF,wBAAgB,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,CAEnF"}