@mj-biz-apps/accounting-entities 0.1.0

package/LICENSE

@@ -0,0 +1,183 @@
+Business Source License 1.1
+
+License text copyright (c) 2024 MariaDB plc, All Rights Reserved.
+"Business Source License" is a trademark of MariaDB plc.
+
+-----------------------------------------------------------------------------
+
+Parameters
+
+Licensor:             Blue Cypress, Inc.
+
+Licensed Work:        MemberJunction.
+                      The Licensed Work is (c) 2023-2026 Blue Cypress, Inc.
+
+Additional Use Grant: Subject to the terms of this License, Licensor grants
+                      you the following additional rights to make Production
+                      Use of the Licensed Work.
+
+                      1. Internal Use
+
+                      You may make production use of the Licensed Work for
+                      your own internal business or organizational operations.
+
+                      2. Nonprofit Use
+
+                      If you are a Nonprofit, you may make production use of
+                      the Licensed Work for the operations and activities of
+                      your Organizational Family.
+
+                      3. MemberJunction Certified Program Use
+
+                      If you are authorized by Licensor under the
+                      MemberJunction Certified Program to provide professional
+                      services using the Licensed Work, you may make
+                      production use of the Licensed Work in providing such
+                      professional services to a client, provided that:
+
+                      (a) the Licensed Work is deployed in, and the applicable
+                      production use occurs within, an environment owned,
+                      leased, licensed, subscribed to, or otherwise controlled
+                      by that client; and
+
+                      (b) the production use is for that client's own internal
+                      business or organizational operations or is otherwise
+                      independently permitted to that client under this
+                      Additional Use Grant.
+
+                      4. Definitions Applicable to the Additional Use Grant
+
+                      "Affiliate" means, with respect to a specified Person,
+                      any other Person that directly or indirectly Controls,
+                      is Controlled by, or is under common Control with such
+                      specified Person.
+
+                      "Control" (including the terms "Controls," "Controlled
+                      by," and "under common Control with") means the direct
+                      or indirect possession of the power to direct or cause
+                      the direction of the management and policies of a
+                      Person, whether through ownership of voting interests,
+                      by contract, or otherwise.
+
+                      "Organizational Family" means, with respect to a Person,
+                      (a) such Person and its Affiliates, and (b) any
+                      nonprofit organization, governmental entity, chapter,
+                      division, local affiliate, regional affiliate, state
+                      affiliate, national affiliate, or other entity that is
+                      formally affiliated with such Person through governing
+                      documents, a charter, bylaws, a membership agreement, or
+                      another written organizational instrument, and is
+                      recognized under such documents as part of the same
+                      organizational structure.
+
+                      "Nonprofit" means a Person recognized by the Internal
+                      Revenue Service as exempt from federal income taxation
+                      under Section 501(c)(3), 501(c)(4), 501(c)(5), or
+                      501(c)(6) of the Internal Revenue Code, or a foreign
+                      organization recognized under substantially equivalent
+                      laws.
+
+                      A Person claiming eligibility as a Nonprofit shall, upon
+                      Licensor's reasonable request, provide documentation
+                      reasonably sufficient to demonstrate that it qualifies
+                      as a Nonprofit. If such Person materially misrepresents,
+                      or is unable to demonstrate, its qualification as a
+                      Nonprofit, the rights granted to such Person under
+                      Section 2 of this Additional Use Grant shall terminate.
+
+                      "MemberJunction Certified Program" means Licensor's
+                      then-current program for certifying and authorizing a
+                      Person to provide professional services using the
+                      Licensed Work.
+
+                      "Person" means any individual, corporation, limited
+                      liability company, partnership, association, nonprofit
+                      organization, governmental entity, or other legal or
+                      organizational entity.
+
+Change Date:          Four (4) years from the date the Licensed Work is first
+                      made available.
+
+Change License:       MIT License.
+
+For information about alternative licensing arrangements for the Licensed
+Work, please contact Blue Cypress, Inc.
+
+-----------------------------------------------------------------------------
+
+Terms
+
+The Licensor hereby grants you the right to copy, modify, create derivative
+works, redistribute, and make non-production use of the Licensed Work. The
+Licensor may make an Additional Use Grant, above, permitting limited
+production use.
+
+Effective on the Change Date, or the fourth anniversary of the first publicly
+available distribution of a specific version of the Licensed Work under this
+License, whichever comes first, the Licensor hereby grants you rights under
+the terms of the Change License, and the rights granted in the paragraph
+above terminate.
+
+If your use of the Licensed Work does not comply with the requirements
+currently in effect as described in this License, you must purchase a
+commercial license from the Licensor, its affiliated entities, or authorized
+resellers, or you must refrain from using the Licensed Work.
+
+All copies of the original and modified Licensed Work, and derivative works
+of the Licensed Work, are subject to this License. This License applies
+separately for each version of the Licensed Work and the Change Date may vary
+for each version of the Licensed Work released by Licensor.
+
+You must conspicuously display this License on each original or modified copy
+of the Licensed Work. If you receive the Licensed Work in original or
+modified form from a third party, the terms and conditions set forth in this
+License apply to your use of that work.
+
+Any use of the Licensed Work in violation of this License will automatically
+terminate your rights under this License for the current and all other
+versions of the Licensed Work.
+
+This License does not grant you any right in any trademark or logo of
+Licensor or its affiliates (provided that you may use a trademark or logo of
+Licensor as expressly required by this License).
+
+TO THE EXTENT PERMITTED BY APPLICABLE LAW, THE LICENSED WORK IS PROVIDED ON
+AN "AS IS" BASIS. LICENSOR HEREBY DISCLAIMS ALL WARRANTIES AND CONDITIONS,
+EXPRESS OR IMPLIED, INCLUDING (WITHOUT LIMITATION) WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT, AND
+TITLE.
+
+MariaDB hereby grants you permission to use this License's text to license
+your works, and to refer to it using the trademark "Business Source License",
+as long as you comply with the Covenants of Licensor below.
+
+-----------------------------------------------------------------------------
+
+Covenants of Licensor
+
+In consideration of the right to use this License's text and the "Business
+Source License" name and trademark, Licensor covenants to MariaDB, and to all
+other recipients of the licensed work to be provided by Licensor:
+
+1. To specify as the Change License the GPL Version 2.0 or any later version,
+   or a license that is compatible with GPL Version 2.0 or a later version,
+   where "compatible" means that software provided under the Change License
+   can be included in a program with software provided under GPL Version 2.0
+   or a later version. Licensor may specify additional Change Licenses without
+   limitation.
+
+2. To either: (a) specify an additional grant of rights to use that does not
+   impose any additional restriction on the right granted in this License, as
+   the Additional Use Grant; or (b) insert the text "None".
+
+3. To specify a Change Date.
+
+4. Not to modify this License in any other way.
+
+-----------------------------------------------------------------------------
+
+Notice
+
+The Business Source License (this document, or the "License") is not an Open
+Source license. However, the Licensed Work will eventually be made available
+under an Open Source License, as stated in this License.

package/dist/JournalEntryEntity.d.ts

@@ -0,0 +1,50 @@
+/**
+ * @fileoverview `JournalEntryEntity` — the double-entry rules, on BOTH tiers.
+ *
+ * WHY THIS LAYER EXISTS
+ *
+ * Every journal-entry rule lived in `JournalEntryEntityServer`, in a server-only package, alongside
+ * a hand-rolled child collection (`_lines`, `_deletedLines`, `AddLine`, `RemoveLine`, `CreateLine`,
+ * `LoadLines`). The browser could not model an entry at all, so the JE editor reached through an
+ * Angular service layer to compose something it had no type for — and learned an entry was
+ * unbalanced only after a round trip.
+ *
+ * The rules now split by what they NEED rather than where they were written:
+ *
+ *   · Here — decidable from the entry and its lines alone. No database, no provider. Runs in the
+ *     browser before a round trip, and again on the server, because the server subclass extends
+ *     this one and `super.Validate()` still fires.
+ *   · `JournalEntryEntityServer` — anything requiring the database: entry numbering, fiscal-year
+ *     derivation, the reversal-type discriminator, GL account existence and company scoping.
+ *
+ * `ClassFactory` priority auto-increments by load order, so the server subclass wins server-side
+ * with no configuration while the browser resolves to this one and keeps the `Lines` collection the
+ * generated class declares.
+ *
+ * @module @mj-biz-apps/accounting-entities
+ */
+import { ValidationResult } from '@memberjunction/core';
+import { mjBizAppsAccountingJournalEntryEntity } from './generated/entity_subclasses.js';
+export declare class JournalEntryEntity extends mjBizAppsAccountingJournalEntryEntity {
+    /**
+     * Whether the line set is KNOWN, as opposed to merely empty.
+     *
+     * An empty collection means "no lines" only when there cannot be any on disk: an entry that was
+     * never saved, or one whose collection was actually loaded. On a saved entry with an unloaded
+     * collection, empty means "unknown" — and counting it as zero would reject a perfectly good
+     * entry whose lines are sitting in the table.
+     *
+     * `IsLoaded` alone is not the test, because `Add()` does not mark a collection loaded: an entry
+     * composed in the browser has lines and `IsLoaded === false`.
+     */
+    protected get LinesAreKnown(): boolean;
+    /**
+     * The double-entry invariants, over the complete line set, before anything is written.
+     *
+     * `super.Validate()` fans out to the `Lines` collection, so each line's own `Validate()` runs
+     * here too and its failures arrive attributed by position (`Lines[3].DebitAmount`). That
+     * replaces a hand-written per-line loop that existed only on the server.
+     */
+    Validate(): ValidationResult;
+}
+//# sourceMappingURL=JournalEntryEntity.d.ts.map

package/dist/JournalEntryEntity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"JournalEntryEntity.d.ts","sourceRoot":"","sources":["../src/JournalEntryEntity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,OAAO,EAAmC,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAEzF,OAAO,EAAE,qCAAqC,EAAE,MAAM,+BAA+B,CAAC;AAGtF,qBACa,kBAAmB,SAAQ,qCAAqC;IACzE;;;;;;;;;;OAUG;IACH,SAAS,KAAK,aAAa,IAAI,OAAO,CAErC;IAED;;;;;;OAMG;IACa,QAAQ,IAAI,gBAAgB;CAqE/C"}

package/dist/JournalEntryEntity.js

@@ -0,0 +1,113 @@
+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 `JournalEntryEntity` — the double-entry rules, on BOTH tiers.
+ *
+ * WHY THIS LAYER EXISTS
+ *
+ * Every journal-entry rule lived in `JournalEntryEntityServer`, in a server-only package, alongside
+ * a hand-rolled child collection (`_lines`, `_deletedLines`, `AddLine`, `RemoveLine`, `CreateLine`,
+ * `LoadLines`). The browser could not model an entry at all, so the JE editor reached through an
+ * Angular service layer to compose something it had no type for — and learned an entry was
+ * unbalanced only after a round trip.
+ *
+ * The rules now split by what they NEED rather than where they were written:
+ *
+ *   · Here — decidable from the entry and its lines alone. No database, no provider. Runs in the
+ *     browser before a round trip, and again on the server, because the server subclass extends
+ *     this one and `super.Validate()` still fires.
+ *   · `JournalEntryEntityServer` — anything requiring the database: entry numbering, fiscal-year
+ *     derivation, the reversal-type discriminator, GL account existence and company scoping.
+ *
+ * `ClassFactory` priority auto-increments by load order, so the server subclass wins server-side
+ * with no configuration while the browser resolves to this one and keeps the `Lines` collection the
+ * generated class declares.
+ *
+ * @module @mj-biz-apps/accounting-entities
+ */
+import { BaseEntity, ValidationErrorInfo } from '@memberjunction/core';
+import { RegisterClass } from '@memberjunction/global';
+import { mjBizAppsAccountingJournalEntryEntity } from './generated/entity_subclasses.js';
+let JournalEntryEntity = class JournalEntryEntity extends mjBizAppsAccountingJournalEntryEntity {
+    /**
+     * Whether the line set is KNOWN, as opposed to merely empty.
+     *
+     * An empty collection means "no lines" only when there cannot be any on disk: an entry that was
+     * never saved, or one whose collection was actually loaded. On a saved entry with an unloaded
+     * collection, empty means "unknown" — and counting it as zero would reject a perfectly good
+     * entry whose lines are sitting in the table.
+     *
+     * `IsLoaded` alone is not the test, because `Add()` does not mark a collection loaded: an entry
+     * composed in the browser has lines and `IsLoaded === false`.
+     */
+    get LinesAreKnown() {
+        return !this.IsSaved || this.Lines.IsLoaded || this.Lines.Count > 0;
+    }
+    /**
+     * The double-entry invariants, over the complete line set, before anything is written.
+     *
+     * `super.Validate()` fans out to the `Lines` collection, so each line's own `Validate()` runs
+     * here too and its failures arrive attributed by position (`Lines[3].DebitAmount`). That
+     * replaces a hand-written per-line loop that existed only on the server.
+     */
+    Validate() {
+        const result = super.Validate();
+        if (!this.LinesAreKnown) {
+            return result; // the server subclass settles it against the database
+        }
+        const lines = this.Lines.Items;
+        // COUNT THE LINES SOMEBODY ACTUALLY TYPED IN.
+        //
+        // An editor opens with blank rows and keeps one at the bottom, so `Lines.Count` is never the
+        // number of lines the entry HAS. Counting them all would let an untouched two-row draft
+        // satisfy the double-entry rule with nothing on it — and the balance check would agree,
+        // because zero equals zero.
+        //
+        // Written as `!== true` rather than `!l.IsEmpty` DELIBERATELY. If the collection ever
+        // resolves to the generated class instead of this subclass — a registration that did not
+        // load, a host that imports the entities package differently — `IsEmpty` is `undefined`, and
+        // `!undefined` is `true`. Every line would read as blank and every entry in the system would
+        // be rejected as having no lines. This way the same accident makes lines count as REAL,
+        // which is the safe direction: a blank one still fails on its own rules a moment later.
+        const live = lines.filter((l) => l.IsEmpty !== true);
+        // A JE must have at least two lines — that is what double entry MEANS.
+        if (live.length < 2) {
+            result.Success = false;
+            result.Errors.push(new ValidationErrorInfo('Lines', `A Journal Entry must have at least 2 line items (double-entry invariant). Found ${live.length} line(s).`, null));
+        }
+        // EQUAL DEBITS AND CREDITS, COMPARED AT PENNY PRECISION.
+        //
+        // This was `totalDebits !== totalCredits` — exact float equality on accumulated sums — and
+        // it rejected entries that balance perfectly. A four-line entry of
+        //
+        //     Dr AR 302.59  /  Cr Sales 233.51 + Cr Tax 25.30 + Cr Shipping 43.78
+        //
+        // sums on the credit side to 302.59000000000003 in IEEE-754, so the comparison failed while
+        // the error message printed both sides as "302.59" — telling the caller two identical
+        // numbers were unequal. It stayed latent while entries had two or three lines and friendly
+        // amounts; the first four-line entry from bizapps-orders hit it.
+        //
+        // DebitAmount and CreditAmount are DECIMAL(18,2), so a penny IS the unit of account and
+        // anything finer is an artefact of summing in binary floating point. Half a penny is
+        // therefore the correct tolerance: tight enough that no real imbalance passes — the smallest
+        // storable discrepancy is a whole penny, two hundred times the epsilon — and loose enough
+        // that accumulation order cannot decide whether a balanced entry is accepted.
+        const totalDebits = lines.reduce((sum, l) => sum + (l.DebitAmount ?? 0), 0);
+        const totalCredits = lines.reduce((sum, l) => sum + (l.CreditAmount ?? 0), 0);
+        if (Math.abs(totalDebits - totalCredits) >= 0.005) {
+            result.Success = false;
+            result.Errors.push(new ValidationErrorInfo('Lines', `Unbalanced Journal Entry: total debits (${totalDebits.toFixed(2)}) must equal ` +
+                `total credits (${totalCredits.toFixed(2)}).`, null));
+        }
+        return result;
+    }
+};
+JournalEntryEntity = __decorate([
+    RegisterClass(BaseEntity, 'MJ_BizApps_Accounting: Journal Entries')
+], JournalEntryEntity);
+export { JournalEntryEntity };
+//# sourceMappingURL=JournalEntryEntity.js.map

package/dist/JournalEntryEntity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"JournalEntryEntity.js","sourceRoot":"","sources":["../src/JournalEntryEntity.ts"],"names":[],"mappings":";;;;;;AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,OAAO,EAAE,UAAU,EAAE,mBAAmB,EAAoB,MAAM,sBAAsB,CAAC;AACzF,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAE,qCAAqC,EAAE,MAAM,+BAA+B,CAAC;AAI/E,IAAM,kBAAkB,GAAxB,MAAM,kBAAmB,SAAQ,qCAAqC;IACzE;;;;;;;;;;OAUG;IACH,IAAc,aAAa;QACvB,OAAO,CAAC,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,KAAK,CAAC,QAAQ,IAAI,IAAI,CAAC,KAAK,CAAC,KAAK,GAAG,CAAC,CAAC;IACxE,CAAC;IAED;;;;;;OAMG;IACa,QAAQ;QACpB,MAAM,MAAM,GAAG,KAAK,CAAC,QAAQ,EAAE,CAAC;QAEhC,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC;YACtB,OAAO,MAAM,CAAC,CAAC,sDAAsD;QACzE,CAAC;QAED,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,KAAiC,CAAC;QAE3D,8CAA8C;QAC9C,EAAE;QACF,6FAA6F;QAC7F,wFAAwF;QACxF,wFAAwF;QACxF,4BAA4B;QAC5B,EAAE;QACF,sFAAsF;QACtF,yFAAyF;QACzF,6FAA6F;QAC7F,6FAA6F;QAC7F,wFAAwF;QACxF,wFAAwF;QACxF,MAAM,IAAI,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,KAAK,IAAI,CAAC,CAAC;QAErD,uEAAuE;QACvE,IAAI,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAClB,MAAM,CAAC,OAAO,GAAG,KAAK,CAAC;YACvB,MAAM,CAAC,MAAM,CAAC,IAAI,CACd,IAAI,mBAAmB,CACnB,OAAO,EACP,mFAAmF,IAAI,CAAC,MAAM,WAAW,EACzG,IAAI,CACP,CACJ,CAAC;QACN,CAAC;QAED,yDAAyD;QACzD,EAAE;QACF,2FAA2F;QAC3F,mEAAmE;QACnE,EAAE;QACF,0EAA0E;QAC1E,EAAE;QACF,4FAA4F;QAC5F,sFAAsF;QACtF,2FAA2F;QAC3F,iEAAiE;QACjE,EAAE;QACF,wFAAwF;QACxF,qFAAqF;QACrF,6FAA6F;QAC7F,0FAA0F;QAC1F,8EAA8E;QAC9E,MAAM,WAAW,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,WAAW,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QAC5E,MAAM,YAAY,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,YAAY,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QAC9E,IAAI,IAAI,CAAC,GAAG,CAAC,WAAW,GAAG,YAAY,CAAC,IAAI,KAAK,EAAE,CAAC;YAChD,MAAM,CAAC,OAAO,GAAG,KAAK,CAAC;YACvB,MAAM,CAAC,MAAM,CAAC,IAAI,CACd,IAAI,mBAAmB,CACnB,OAAO,EACP,2CAA2C,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC,eAAe;gBAC5E,kBAAkB,YAAY,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,EACjD,IAAI,CACP,CACJ,CAAC;QACN,CAAC;QAED,OAAO,MAAM,CAAC;IAClB,CAAC;CACJ,CAAA;AA5FY,kBAAkB;IAD9B,aAAa,CAAC,UAAU,EAAE,wCAAwC,CAAC;GACvD,kBAAkB,CA4F9B"}

package/dist/JournalEntryLineEntity.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @fileoverview `JournalEntryLineEntity` — the per-line debit/credit rules, on BOTH tiers.
+ *
+ * WHY THIS LAYER EXISTS
+ *
+ * These rules — an account is required, exactly one side carries an amount, neither side is
+ * negative — need nothing but the line itself. They lived in `JournalEntryLineEntityServer`, in a
+ * server-only package, so the browser could not run them; the JE workspace therefore carried a
+ * hand-written `lineIssue()` saying the same things in different words, and the two were free to
+ * drift. They did: the server's wording named `DebitAmount`, the screen's named "the debit column",
+ * and only one of them was ever updated when the rule changed.
+ *
+ * `super.Validate()` on the parent entry fans out to the `Lines` collection, so these run as part of
+ * the entry's own validation and arrive attributed by position — `Lines[3].DebitAmount` — which is
+ * what lets the editor put an error on the offending ROW rather than in a list above the grid.
+ *
+ * WHAT DELIBERATELY STAYED ON THE SERVER SUBCLASS. Anything that reads reference data: whether the
+ * GL account is active, whether it belongs to the entry's company, whether a dimension value belongs
+ * to the dimension it tags. The browser has a cache of those, but a cache is not an authority, and a
+ * rule enforced against a stale cache is worse than one enforced late.
+ *
+ * @module @mj-biz-apps/accounting-entities
+ */
+import { ValidationResult } from '@memberjunction/core';
+import { mjBizAppsAccountingJournalEntryLineEntity } from './generated/entity_subclasses.js';
+export declare class JournalEntryLineEntity extends mjBizAppsAccountingJournalEntryLineEntity {
+    /** How this line names itself in a message. Falls back to the id while the number is unassigned. */
+    protected get Label(): string;
+    /**
+     * True when the operator has not touched this row at all.
+     *
+     * An untouched row is not an error — the editor opens with two blank lines by design, and
+     * reporting "pick an account" against a row nobody has typed in is noise that trains people to
+     * ignore the error list. It is dropped at save rather than reported.
+     */
+    get IsEmpty(): boolean;
+    Validate(): ValidationResult;
+}
+//# sourceMappingURL=JournalEntryLineEntity.d.ts.map

package/dist/JournalEntryLineEntity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"JournalEntryLineEntity.d.ts","sourceRoot":"","sources":["../src/JournalEntryLineEntity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,OAAO,EAAmC,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAEzF,OAAO,EAAE,yCAAyC,EAAE,MAAM,+BAA+B,CAAC;AAE1F,qBACa,sBAAuB,SAAQ,yCAAyC;IACjF,oGAAoG;IACpG,SAAS,KAAK,KAAK,IAAI,MAAM,CAE5B;IAED;;;;;;OAMG;IACH,IAAW,OAAO,IAAI,OAAO,CAO5B;IAEe,QAAQ,IAAI,gBAAgB;CAoD/C"}

package/dist/JournalEntryLineEntity.js

@@ -0,0 +1,96 @@
+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 `JournalEntryLineEntity` — the per-line debit/credit rules, on BOTH tiers.
+ *
+ * WHY THIS LAYER EXISTS
+ *
+ * These rules — an account is required, exactly one side carries an amount, neither side is
+ * negative — need nothing but the line itself. They lived in `JournalEntryLineEntityServer`, in a
+ * server-only package, so the browser could not run them; the JE workspace therefore carried a
+ * hand-written `lineIssue()` saying the same things in different words, and the two were free to
+ * drift. They did: the server's wording named `DebitAmount`, the screen's named "the debit column",
+ * and only one of them was ever updated when the rule changed.
+ *
+ * `super.Validate()` on the parent entry fans out to the `Lines` collection, so these run as part of
+ * the entry's own validation and arrive attributed by position — `Lines[3].DebitAmount` — which is
+ * what lets the editor put an error on the offending ROW rather than in a list above the grid.
+ *
+ * WHAT DELIBERATELY STAYED ON THE SERVER SUBCLASS. Anything that reads reference data: whether the
+ * GL account is active, whether it belongs to the entry's company, whether a dimension value belongs
+ * to the dimension it tags. The browser has a cache of those, but a cache is not an authority, and a
+ * rule enforced against a stale cache is worse than one enforced late.
+ *
+ * @module @mj-biz-apps/accounting-entities
+ */
+import { BaseEntity, ValidationErrorInfo, ValidationResult } from '@memberjunction/core';
+import { RegisterClass } from '@memberjunction/global';
+import { mjBizAppsAccountingJournalEntryLineEntity } from './generated/entity_subclasses.js';
+let JournalEntryLineEntity = class JournalEntryLineEntity extends mjBizAppsAccountingJournalEntryLineEntity {
+    /** How this line names itself in a message. Falls back to the id while the number is unassigned. */
+    get Label() {
+        return this.LineNumber ? `Line ${this.LineNumber}` : 'This line';
+    }
+    /**
+     * True when the operator has not touched this row at all.
+     *
+     * An untouched row is not an error — the editor opens with two blank lines by design, and
+     * reporting "pick an account" against a row nobody has typed in is noise that trains people to
+     * ignore the error list. It is dropped at save rather than reported.
+     */
+    get IsEmpty() {
+        return (!this.GLAccountID &&
+            !(this.DebitAmount ?? 0) &&
+            !(this.CreditAmount ?? 0) &&
+            !(this.Description ?? '').trim());
+    }
+    Validate() {
+        // AN UNTOUCHED ROW REPORTS NOTHING — including whatever the generated base would say about
+        // it. `super.Validate()` mirrors the table's CHECK constraints, one of which is "a line must
+        // have a positive debit or a positive credit"; running it here would put that on the blank
+        // row the editor always keeps at the bottom, which is the noise this whole rule exists to
+        // avoid. A blank line that reaches a SAVE is caught by `JournalEntryEntityServer.Validate()`,
+        // which names it by number.
+        if (this.IsEmpty) {
+            const quiet = new ValidationResult();
+            quiet.Success = true;
+            return quiet;
+        }
+        const result = super.Validate();
+        const debit = this.DebitAmount ?? 0;
+        const credit = this.CreditAmount ?? 0;
+        const fail = (source, message, value) => {
+            result.Success = false;
+            result.Errors.push(new ValidationErrorInfo(source, message, value));
+        };
+        if (!this.GLAccountID) {
+            fail('GLAccountID', `${this.Label} needs an account.`, null);
+        }
+        // ONE SIDE ONLY. A line carrying both is not a line that nets — it is two lines somebody
+        // typed into one row, and the entry would still balance, so nothing downstream would notice.
+        if (debit > 0 && credit > 0) {
+            fail('DebitAmount', `${this.Label} is either a debit or a credit, not both (${debit} / ${credit}).`, debit);
+        }
+        if (debit === 0 && credit === 0) {
+            fail('DebitAmount', `${this.Label} needs a debit or a credit amount.`, null);
+        }
+        // A NEGATIVE AMOUNT IS THE OTHER COLUMN. Accepting one would let an entry balance by two
+        // wrongs — a negative debit against a smaller credit sums correctly and posts backwards.
+        if (debit < 0) {
+            fail('DebitAmount', `${this.Label} cannot have a negative debit — use the credit column instead.`, debit);
+        }
+        if (credit < 0) {
+            fail('CreditAmount', `${this.Label} cannot have a negative credit — use the debit column instead.`, credit);
+        }
+        return result;
+    }
+};
+JournalEntryLineEntity = __decorate([
+    RegisterClass(BaseEntity, 'MJ_BizApps_Accounting: Journal Entry Lines')
+], JournalEntryLineEntity);
+export { JournalEntryLineEntity };
+//# sourceMappingURL=JournalEntryLineEntity.js.map

package/dist/JournalEntryLineEntity.js.map

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