@classytic/ledger 0.4.2 → 0.5.0

package/dist/reconciliation.schema-BA1lPv4t.mjs

@@ -1,666 +0,0 @@
-import { o as getJournalTypeCodes, r as _freezeJournalTypes, t as JOURNAL_CODES } from "./journals-BfwnCFam.mjs";
-import mongoose from "mongoose";
-//#region src/schemas/currency-field.ts
-/**
-* Build the Mongoose currency field definition.
-* Returns `null` if multi-currency is not enabled.
-*/
-function buildCurrencyField(config) {
-	if (!config.multiCurrency?.enabled) return null;
-	const allowed = config.multiCurrency.currencies;
-	return {
-		type: String,
-		default: null,
-		...allowed?.length ? { enum: [
-			null,
-			config.currency,
-			...allowed
-		] } : {}
-	};
-}
-//#endregion
-//#region src/schemas/account.schema.ts
-/**
-* Account Schema Factory
-*
-* Creates a Mongoose schema for Chart of Accounts that is:
-* - Multi-tenant aware (adds org field + compound indexes when configured)
-* - Validates accountTypeCode against the country pack
-* - Supports accountNumber (unique per org) and name (user-facing display)
-* - Lean: no cached balances — always computed from journal entries
-*/
-function createAccountSchema(config, options = {}) {
-	const { multiTenant, country } = config;
-	const { indexes = true, extraFields = {}, extraIndexes = [] } = options;
-	const fields = {
-		accountTypeCode: {
-			type: String,
-			required: true,
-			validate: {
-				validator: (code) => country.isValidAccountType(code),
-				message: (props) => `"${props.value}" is not a valid account type code for ${country.name}.`
-			}
-		},
-		accountNumber: {
-			type: String,
-			required: true,
-			trim: true
-		},
-		name: {
-			type: String,
-			required: true,
-			trim: true
-		},
-		active: {
-			type: Boolean,
-			default: true
-		},
-		isCashAccount: {
-			type: Boolean,
-			default: false
-		}
-	};
-	const currencyField = buildCurrencyField(config);
-	if (currencyField) fields.currency = currencyField;
-	Object.assign(fields, extraFields);
-	if (multiTenant) fields[multiTenant.orgField] = {
-		type: mongoose.Schema.Types.ObjectId,
-		ref: multiTenant.orgRef,
-		required: true
-	};
-	const schema = new mongoose.Schema(fields, { timestamps: true });
-	schema.pre("validate", function() {
-		if (!this.accountNumber && this.accountTypeCode) this.accountNumber = this.accountTypeCode;
-		if (!this.name && this.accountTypeCode) this.name = country.getAccountType(this.accountTypeCode)?.name ?? this.accountTypeCode;
-	});
-	if (indexes) if (multiTenant) {
-		const org = multiTenant.orgField;
-		schema.index({
-			[org]: 1,
-			active: 1
-		});
-		schema.index({
-			[org]: 1,
-			accountNumber: 1
-		}, { unique: true });
-		schema.index({
-			[org]: 1,
-			accountTypeCode: 1
-		});
-	} else {
-		schema.index({ active: 1 });
-		schema.index({ accountNumber: 1 }, { unique: true });
-		schema.index({ accountTypeCode: 1 });
-	}
-	for (const idx of extraIndexes) schema.index(idx.fields, idx.options);
-	return schema;
-}
-//#endregion
-//#region src/schemas/budget.schema.ts
-/**
-* Budget Schema Factory
-*
-* Creates a Mongoose schema for budget records.
-* Each record represents a budgeted amount for an account over a specific period.
-* All monetary amounts are in integer cents.
-*/
-function createBudgetSchema(config, options = {}) {
-	const { multiTenant } = config;
-	const { indexes = true, extraFields = {}, extraIndexes = [] } = options;
-	const fields = {
-		account: {
-			type: mongoose.Schema.Types.ObjectId,
-			ref: "Account",
-			required: true
-		},
-		periodStart: {
-			type: Date,
-			required: true
-		},
-		periodEnd: {
-			type: Date,
-			required: true
-		},
-		amount: {
-			type: Number,
-			required: true,
-			validate: {
-				validator: (v) => Number.isInteger(v),
-				message: "amount must be an integer (cents)."
-			}
-		},
-		label: {
-			type: String,
-			default: null
-		},
-		...extraFields
-	};
-	if (multiTenant) fields[multiTenant.orgField] = {
-		type: mongoose.Schema.Types.ObjectId,
-		ref: multiTenant.orgRef,
-		required: true
-	};
-	const schema = new mongoose.Schema(fields, { timestamps: true });
-	schema.pre("validate", function() {
-		const doc = this;
-		if (doc.periodStart && doc.periodEnd && doc.periodEnd <= doc.periodStart) doc.invalidate("periodEnd", "periodEnd must be after periodStart.", doc.periodEnd, "periodEnd");
-	});
-	if (indexes) if (multiTenant) {
-		const org = multiTenant.orgField;
-		schema.index({
-			[org]: 1,
-			account: 1,
-			periodStart: 1,
-			periodEnd: 1
-		}, { unique: true });
-		schema.index({
-			[org]: 1,
-			periodStart: 1,
-			periodEnd: 1
-		});
-	} else {
-		schema.index({
-			account: 1,
-			periodStart: 1,
-			periodEnd: 1
-		}, { unique: true });
-		schema.index({
-			periodStart: 1,
-			periodEnd: 1
-		});
-	}
-	for (const idx of extraIndexes) schema.index(idx.fields, idx.options);
-	return schema;
-}
-//#endregion
-//#region src/schemas/fiscal-period.schema.ts
-/**
-* Fiscal Period Schema Factory
-*
-* Creates a Mongoose schema for tracking fiscal periods (months, quarters, years).
-* Supports closing periods to lock entries.
-*/
-function createFiscalPeriodSchema(config, options = {}) {
-	const { multiTenant } = config;
-	const { indexes = true, extraFields = {}, extraIndexes = [] } = options;
-	const fields = {
-		name: {
-			type: String,
-			required: true
-		},
-		startDate: {
-			type: Date,
-			required: true
-		},
-		endDate: {
-			type: Date,
-			required: true
-		},
-		closed: {
-			type: Boolean,
-			default: false
-		},
-		closedAt: {
-			type: Date,
-			default: null
-		},
-		closedBy: {
-			type: String,
-			default: null
-		},
-		closingEntryId: {
-			type: mongoose.Schema.Types.ObjectId,
-			default: null
-		},
-		reopenedAt: {
-			type: Date,
-			default: null
-		},
-		reopenedBy: {
-			type: String,
-			default: null
-		},
-		...extraFields
-	};
-	if (multiTenant) fields[multiTenant.orgField] = {
-		type: mongoose.Schema.Types.ObjectId,
-		ref: multiTenant.orgRef,
-		required: true
-	};
-	const schema = new mongoose.Schema(fields, { timestamps: true });
-	if (indexes) if (multiTenant) {
-		const org = multiTenant.orgField;
-		schema.index({
-			[org]: 1,
-			startDate: 1,
-			endDate: 1
-		}, { unique: true });
-		schema.index({
-			[org]: 1,
-			closed: 1
-		});
-	} else {
-		schema.index({
-			startDate: 1,
-			endDate: 1
-		}, { unique: true });
-		schema.index({ closed: 1 });
-	}
-	for (const idx of extraIndexes) schema.index(idx.fields, idx.options);
-	schema.pre("validate", async function() {
-		const doc = this;
-		if (!doc.startDate || !doc.endDate) return;
-		const overlapQuery = {
-			_id: { $ne: doc._id },
-			startDate: { $lt: doc.endDate },
-			endDate: { $gt: doc.startDate }
-		};
-		if (multiTenant) overlapQuery[multiTenant.orgField] = doc[multiTenant.orgField];
-		const overlap = await doc.collection.findOne(overlapQuery);
-		if (overlap) {
-			const msg = `Fiscal period overlaps with existing period "${overlap.name}" (${new Date(overlap.startDate).toISOString().split("T")[0]} – ${new Date(overlap.endDate).toISOString().split("T")[0]}).`;
-			doc.invalidate("startDate", msg, doc.startDate, "overlap");
-		}
-	});
-	return schema;
-}
-//#endregion
-//#region src/schemas/journal-entry.schema.ts
-/**
-* Journal Entry Schema Factory
-*
-* Creates a Mongoose schema for double-entry journal entries.
-* - Multi-tenant aware
-* - Embedded journal items with account refs
-* - State machine: draft → posted, draft → archived
-* - Auto-generated reference numbers
-* - Double-entry validation on post
-* - Optimized indexes for high-load reporting
-*/
-function createJournalEntrySchema(config, accountModelName, options = {}) {
-	const { multiTenant } = config;
-	const { indexes = true, autoReference = true, textSearch = true, extraFields = {}, extraIndexes = [], extraItemFields = {} } = options;
-	const TaxDetailSchema = new mongoose.Schema({
-		taxCode: { type: String },
-		taxName: { type: String }
-	}, { _id: false });
-	const amountValidator = {
-		validator: (v) => Number.isInteger(v) && v >= 0,
-		message: "{PATH} must be a non-negative integer (cents), got {VALUE}"
-	};
-	const currencyItemFields = {};
-	const currencyField = buildCurrencyField(config);
-	if (currencyField) {
-		currencyItemFields.currency = currencyField;
-		currencyItemFields.exchangeRate = {
-			type: Number,
-			default: null,
-			validate: {
-				validator: (v) => v === null || v > 0,
-				message: "exchangeRate must be greater than zero when set, got {VALUE}"
-			}
-		};
-		currencyItemFields.originalDebit = {
-			type: Number,
-			default: null,
-			min: 0,
-			validate: amountValidator
-		};
-		currencyItemFields.originalCredit = {
-			type: Number,
-			default: null,
-			min: 0,
-			validate: amountValidator
-		};
-	}
-	const JournalItemSchema = new mongoose.Schema({
-		account: {
-			type: mongoose.Schema.Types.ObjectId,
-			ref: accountModelName,
-			required: true
-		},
-		label: { type: String },
-		date: { type: Date },
-		debit: {
-			type: Number,
-			default: 0,
-			min: 0,
-			validate: amountValidator
-		},
-		credit: {
-			type: Number,
-			default: 0,
-			min: 0,
-			validate: amountValidator
-		},
-		taxDetails: {
-			type: [TaxDetailSchema],
-			default: []
-		},
-		...currencyItemFields,
-		...extraItemFields
-	}, { _id: false });
-	_freezeJournalTypes();
-	const fields = {
-		journalType: {
-			type: String,
-			enum: getJournalTypeCodes(),
-			default: JOURNAL_CODES.MISC,
-			required: true
-		},
-		referenceNumber: { type: String },
-		label: { type: String },
-		date: {
-			type: Date,
-			default: Date.now,
-			required: function() {
-				return this.state !== "draft";
-			}
-		},
-		journalItems: {
-			type: [JournalItemSchema],
-			default: []
-		},
-		totalDebit: {
-			type: Number,
-			required: true,
-			min: 0,
-			validate: {
-				validator: Number.isInteger,
-				message: "totalDebit must be an integer (cents)"
-			}
-		},
-		totalCredit: {
-			type: Number,
-			required: true,
-			min: 0,
-			validate: {
-				validator: Number.isInteger,
-				message: "totalCredit must be an integer (cents)"
-			}
-		},
-		state: {
-			type: String,
-			enum: [
-				"draft",
-				"posted",
-				"archived"
-			],
-			default: "draft",
-			required: true
-		},
-		stateChangedAt: {
-			type: Date,
-			default: Date.now
-		},
-		reversed: {
-			type: Boolean,
-			default: false
-		},
-		reversedBy: {
-			type: mongoose.Schema.Types.ObjectId,
-			ref: "JournalEntry",
-			default: null
-		},
-		reversalOf: {
-			type: mongoose.Schema.Types.ObjectId,
-			ref: "JournalEntry",
-			default: null
-		},
-		...extraFields
-	};
-	if (config.audit?.trackActor) {
-		fields.createdBy = {
-			type: mongoose.Schema.Types.ObjectId,
-			default: null
-		};
-		fields.postedBy = {
-			type: mongoose.Schema.Types.ObjectId,
-			default: null
-		};
-		fields.reversedByUser = {
-			type: mongoose.Schema.Types.ObjectId,
-			default: null
-		};
-	}
-	if (config.strictness?.requireApproval || config.audit?.trackActor) {
-		fields.approvedBy = {
-			type: mongoose.Schema.Types.ObjectId,
-			default: null
-		};
-		fields.approvedAt = {
-			type: Date,
-			default: null
-		};
-	}
-	if (config.idempotency) fields.idempotencyKey = {
-		type: String,
-		default: null
-	};
-	if (multiTenant) fields[multiTenant.orgField] = {
-		type: mongoose.Schema.Types.ObjectId,
-		ref: multiTenant.orgRef,
-		required: true
-	};
-	const schema = new mongoose.Schema(fields, { timestamps: true });
-	schema.pre("validate", function() {
-		for (const item of this.journalItems) if (!item.date) item.date = this.date;
-		for (let i = 0; i < this.journalItems.length; i++) {
-			const d = this.journalItems[i].debit ?? 0;
-			const c = this.journalItems[i].credit ?? 0;
-			if (d > 0 && c > 0) throw new Error(`Journal item at index ${i}: cannot have both debit (${d}) and credit (${c}) greater than zero`);
-			if (this.state === "posted" && d === 0 && c === 0) throw new Error(`Journal item at index ${i}: posted entries cannot have zero-value lines (both debit and credit are 0)`);
-		}
-		const totalDebit = this.journalItems.reduce((s, item) => s + (item.debit ?? 0), 0);
-		const totalCredit = this.journalItems.reduce((s, item) => s + (item.credit ?? 0), 0);
-		if (this.state === "posted") {
-			if (this.journalItems.length < 2) throw new Error("Posted entries must have at least 2 journal items");
-			if (totalDebit !== totalCredit) throw new Error("Total debit must equal total credit for posted entries");
-		}
-		this.totalDebit = totalDebit;
-		this.totalCredit = totalCredit;
-	});
-	if (autoReference) {
-		const generateReferenceNumber = async (doc, Model, session) => {
-			const jt = doc.journalType || "MISC";
-			const d = new Date(doc.date);
-			const prefix = `${jt}/${d.getFullYear()}/${String(d.getMonth() + 1).padStart(2, "0")}/`;
-			const matchFilter = { referenceNumber: { $regex: `^${prefix.replace(/\//g, "\\/")}` } };
-			if (multiTenant) matchFilter[multiTenant.orgField] = doc[multiTenant.orgField];
-			const pipeline = [
-				{ $match: matchFilter },
-				{ $addFields: { _refSeq: { $toInt: { $arrayElemAt: [{ $split: ["$referenceNumber", "/"] }, -1] } } } },
-				{ $sort: { _refSeq: -1 } },
-				{ $limit: 1 },
-				{ $project: { _refSeq: 1 } }
-			];
-			const results = await Model.aggregate(pipeline).session(session);
-			let seq = 1;
-			if (results.length > 0 && typeof results[0]._refSeq === "number") seq = results[0]._refSeq + 1;
-			return `${prefix}${String(seq).padStart(4, "0")}`;
-		};
-		schema.pre("save", async function() {
-			if (this.isModified("journalType")) this.referenceNumber = void 0;
-			if (!this.referenceNumber) {
-				const session = this.$session?.() ?? null;
-				const Model = this.constructor;
-				this.referenceNumber = await generateReferenceNumber(this, Model, session);
-			}
-		});
-		const MAX_REF_RETRIES = 3;
-		schema.post("save", async (error, doc, next) => {
-			const mongoError = error;
-			if (mongoError.code === 11e3 && mongoError.keyPattern?.referenceNumber) {
-				const entry = doc;
-				const retryCount = entry.__refRetries ?? 0;
-				if (retryCount >= MAX_REF_RETRIES) {
-					next(/* @__PURE__ */ new Error(`Failed to generate unique reference number after ${MAX_REF_RETRIES} retries. Too many concurrent inserts for this period.`));
-					return;
-				}
-				entry.__refRetries = retryCount + 1;
-				const session = entry.$session?.() ?? null;
-				const Model = entry.constructor;
-				entry.referenceNumber = await generateReferenceNumber(entry, Model, session);
-				try {
-					await entry.save({ session });
-					next();
-				} catch (retryError) {
-					next(retryError);
-				}
-			} else next(error);
-		});
-	}
-	if (indexes) {
-		const org = multiTenant?.orgField;
-		const refPartial = { partialFilterExpression: { referenceNumber: {
-			$exists: true,
-			$type: "string"
-		} } };
-		if (org) {
-			schema.index({
-				[org]: 1,
-				referenceNumber: 1
-			}, {
-				unique: true,
-				...refPartial
-			});
-			schema.index({
-				[org]: 1,
-				state: 1,
-				date: 1
-			});
-			schema.index({
-				[org]: 1,
-				date: -1
-			});
-			schema.index({
-				[org]: 1,
-				journalType: 1
-			});
-			schema.index({
-				"journalItems.account": 1,
-				state: 1
-			});
-			schema.index({
-				[org]: 1,
-				"journalItems.account": 1,
-				date: 1,
-				state: 1
-			});
-		} else {
-			schema.index({ referenceNumber: 1 }, {
-				unique: true,
-				...refPartial
-			});
-			schema.index({
-				state: 1,
-				date: 1
-			});
-			schema.index({ date: -1 });
-			schema.index({ journalType: 1 });
-			schema.index({
-				"journalItems.account": 1,
-				state: 1
-			});
-		}
-		schema.index({ reversed: 1 });
-		if (config.idempotency) {
-			const idempotencyIdx = {};
-			if (org) idempotencyIdx[org] = 1;
-			idempotencyIdx.idempotencyKey = 1;
-			schema.index(idempotencyIdx, {
-				unique: true,
-				partialFilterExpression: { idempotencyKey: {
-					$exists: true,
-					$ne: null
-				} }
-			});
-		}
-	}
-	if (textSearch) schema.index({
-		referenceNumber: "text",
-		label: "text"
-	}, {
-		weights: {
-			referenceNumber: 10,
-			label: 5
-		},
-		name: "journal_text_idx"
-	});
-	for (const idx of extraIndexes) schema.index(idx.fields, idx.options);
-	return schema;
-}
-//#endregion
-//#region src/schemas/reconciliation.schema.ts
-/**
-* Reconciliation Schema Factory
-*
-* Creates a Mongoose schema for reconciliation records that link matched
-* debit/credit journal items. Used to track which journal entries have been
-* reconciled against each other for a given account.
-*/
-function createReconciliationSchema(config, accountModelName, journalEntryModelName, options = {}) {
-	const { multiTenant } = config;
-	const { indexes = true, extraFields = {}, extraIndexes = [] } = options;
-	const fields = {
-		account: {
-			type: mongoose.Schema.Types.ObjectId,
-			ref: accountModelName,
-			required: true
-		},
-		journalEntryIds: {
-			type: [{
-				type: mongoose.Schema.Types.ObjectId,
-				ref: journalEntryModelName
-			}],
-			required: true,
-			validate: {
-				validator: (v) => Array.isArray(v) && v.length > 0,
-				message: "journalEntryIds must contain at least one entry."
-			}
-		},
-		debitTotal: {
-			type: Number,
-			required: true
-		},
-		creditTotal: {
-			type: Number,
-			required: true
-		},
-		difference: {
-			type: Number,
-			default: 0
-		},
-		note: { type: String },
-		reconciledBy: { type: String },
-		reconciledAt: {
-			type: Date,
-			default: Date.now
-		},
-		...extraFields
-	};
-	if (multiTenant) fields[multiTenant.orgField] = {
-		type: mongoose.Schema.Types.ObjectId,
-		ref: multiTenant.orgRef,
-		required: true
-	};
-	const schema = new mongoose.Schema(fields, { timestamps: true });
-	if (indexes) {
-		if (multiTenant) {
-			const org = multiTenant.orgField;
-			schema.index({
-				[org]: 1,
-				account: 1,
-				reconciledAt: 1
-			});
-		} else schema.index({
-			account: 1,
-			reconciledAt: 1
-		});
-		schema.index({ journalEntryIds: 1 });
-	}
-	for (const idx of extraIndexes) schema.index(idx.fields, idx.options);
-	return schema;
-}
-//#endregion
-export { createAccountSchema as a, createBudgetSchema as i, createJournalEntrySchema as n, createFiscalPeriodSchema as r, createReconciliationSchema as t };

package/dist/repositories/index.d.mts

@@ -1,2 +0,0 @@
-import { n as wireJournalEntryMethods, r as wireAccountMethods, t as wireReconciliationMethods } from "../reconciliation.repository-D-D_ITL-.mjs";
-export { wireAccountMethods, wireJournalEntryMethods, wireReconciliationMethods };

package/dist/repositories/index.mjs

@@ -1,2 +0,0 @@
-import { n as wireJournalEntryMethods, r as wireAccountMethods, t as wireReconciliationMethods } from "../reconciliation.repository-fPwFKvrk.mjs";
-export { wireAccountMethods, wireJournalEntryMethods, wireReconciliationMethods };