@classytic/ledger 0.4.1 → 0.5.0

package/dist/reconciliation.repository-fPwFKvrk.mjs

@@ -1,542 +0,0 @@
-import { n as Errors } from "./errors-B_dyYZc_.mjs";
-import { t as requireOrgScope } from "./tenant-guard-r17Se3Bb.mjs";
-//#region src/repositories/account.repository.ts
-/**
-* Wire seedAccounts, bulkCreate and posting-account validation
-* onto an existing mongokit Repository.
-*
-* @param repository - A mongokit Repository instance (already created)
-* @param AccountModel - The Mongoose model for accounts
-* @param country - The CountryPack for account type lookups
-* @param orgField - The multi-tenant field name (e.g. 'business')
-*/
-function wireAccountMethods(repository, AccountModel, country, orgField) {
-	repository.on("before:create", (ctx) => {
-		const code = ctx.data?.accountTypeCode;
-		if (code && !country.isPostingAccount(code)) throw Errors.validation(`Cannot create account with type "${code}" — it is a structural group or calculated total, not a posting account.`);
-	});
-	/**
-	* Seed standard posting accounts for an organization.
-	*/
-	repository.seedAccounts = async (orgId, options = {}) => {
-		requireOrgScope(orgField, orgId);
-		const postingTypes = country.getPostingAccountTypes();
-		const filter = {};
-		if (orgField && orgId != null) filter[orgField] = orgId;
-		const existing = await AccountModel.find(filter).select("accountNumber").lean();
-		const existingNumbers = new Set(existing.map((a) => a.accountNumber));
-		const toCreate = postingTypes.filter((at) => !existingNumbers.has(at.code)).map((at) => {
-			const doc = {
-				accountTypeCode: at.code,
-				accountNumber: at.code,
-				name: at.name
-			};
-			if (orgField && orgId != null) doc[orgField] = orgId;
-			return doc;
-		});
-		if (toCreate.length === 0) return {
-			created: 0,
-			skipped: existingNumbers.size
-		};
-		try {
-			return {
-				created: (await AccountModel.insertMany(toCreate, {
-					session: options.session ?? void 0,
-					ordered: false
-				})).length,
-				skipped: existingNumbers.size
-			};
-		} catch (err) {
-			const bulkError = err;
-			if (bulkError.code === 11e3 || bulkError.writeErrors) {
-				const insertedDocs = bulkError.insertedDocs ?? [];
-				return {
-					created: insertedDocs.length,
-					skipped: existingNumbers.size + (toCreate.length - insertedDocs.length)
-				};
-			}
-			throw err;
-		}
-	};
-	/**
-	* Bulk create accounts with validation and skip-if-exists logic.
-	*
-	* Uses a single batch query to check existing accounts (instead of N+1),
-	* and ordered: false on insertMany to handle concurrent race conditions
-	* gracefully (duplicate key errors on individual docs don't abort the batch).
-	*/
-	repository.bulkCreate = async (accounts, orgId) => {
-		requireOrgScope(orgField, orgId);
-		const results = {
-			created: [],
-			skipped: [],
-			errors: []
-		};
-		const validAccounts = [];
-		for (let i = 0; i < accounts.length; i++) {
-			const { accountTypeCode, accountNumber, name, active = true, isCashAccount = false } = accounts[i];
-			if (!accountTypeCode) {
-				results.errors.push({
-					index: i,
-					reason: "accountTypeCode is required"
-				});
-				continue;
-			}
-			const at = country.getAccountType(accountTypeCode);
-			if (!at) {
-				results.errors.push({
-					index: i,
-					accountTypeCode,
-					reason: "Invalid account type code"
-				});
-				continue;
-			}
-			if (!country.isPostingAccount(accountTypeCode)) {
-				results.errors.push({
-					index: i,
-					accountTypeCode,
-					reason: `Not a posting account (${at.isGroup ? "group" : "total"})`
-				});
-				continue;
-			}
-			const resolvedNumber = accountNumber ?? accountTypeCode;
-			const resolvedName = name ?? at.name ?? accountTypeCode;
-			validAccounts.push({
-				index: i,
-				accountTypeCode,
-				accountNumber: resolvedNumber,
-				name: resolvedName,
-				active: Boolean(active),
-				isCashAccount: Boolean(isCashAccount)
-			});
-		}
-		if (validAccounts.length === 0) return {
-			summary: {
-				total: accounts.length,
-				created: 0,
-				skipped: results.skipped.length,
-				errors: results.errors.length
-			},
-			...results
-		};
-		const existsFilter = { accountNumber: { $in: validAccounts.map((a) => a.accountNumber) } };
-		if (orgField && orgId != null) existsFilter[orgField] = orgId;
-		const existingDocs = await AccountModel.find(existsFilter).select("accountNumber").lean();
-		const existingNumbers = new Set(existingDocs.map((d) => d.accountNumber));
-		const toCreate = [];
-		for (const item of validAccounts) if (existingNumbers.has(item.accountNumber)) results.skipped.push({
-			index: item.index,
-			accountTypeCode: item.accountTypeCode,
-			reason: "Already exists"
-		});
-		else toCreate.push(item);
-		if (toCreate.length > 0) {
-			const docs = toCreate.map((item) => {
-				const doc = {
-					accountTypeCode: item.accountTypeCode,
-					accountNumber: item.accountNumber,
-					name: item.name,
-					active: item.active,
-					isCashAccount: item.isCashAccount
-				};
-				if (orgField && orgId != null) doc[orgField] = orgId;
-				return doc;
-			});
-			try {
-				const inserted = await AccountModel.insertMany(docs, { ordered: false });
-				results.created = toCreate.map((item, idx) => ({
-					accountTypeCode: item.accountTypeCode,
-					active: item.active,
-					isCashAccount: item.isCashAccount,
-					_id: inserted[idx]._id
-				}));
-			} catch (err) {
-				const bulkError = err;
-				if (bulkError.code === 11e3 || bulkError.writeErrors) {
-					const insertedDocs = bulkError.insertedDocs ?? [];
-					const insertedNumbers = new Set(insertedDocs.map((d) => d.accountNumber));
-					for (const item of toCreate) if (insertedNumbers.has(item.accountNumber)) {
-						const iDoc = insertedDocs.find((d) => d.accountNumber === item.accountNumber);
-						results.created.push({
-							accountTypeCode: item.accountTypeCode,
-							active: item.active,
-							isCashAccount: item.isCashAccount,
-							_id: iDoc?._id
-						});
-					} else results.skipped.push({
-						index: item.index,
-						accountTypeCode: item.accountTypeCode,
-						reason: "Already exists (concurrent insert)"
-					});
-				} else throw err;
-			}
-		}
-		return {
-			summary: {
-				total: accounts.length,
-				created: results.created.length,
-				skipped: results.skipped.length,
-				errors: results.errors.length
-			},
-			...results
-		};
-	};
-	if (typeof repository.registerMethod === "function") for (const name of ["seedAccounts", "bulkCreate"]) {
-		const fn = repository[name];
-		try {
-			delete repository[name];
-			repository.registerMethod(name, fn);
-		} catch {
-			repository[name] = fn;
-		}
-	}
-	return repository;
-}
-//#endregion
-//#region src/repositories/journal-entry.repository.ts
-/** Keys that are either handled explicitly or must not be copied */
-const ITEM_CORE_KEYS = new Set([
-	"account",
-	"debit",
-	"credit",
-	"label",
-	"date",
-	"taxDetails",
-	"_id",
-	"id"
-]);
-/**
-* Wire post/reverse onto an existing mongokit Repository.
-*
-* All reads use `repository.getByQuery()` so registered plugins
-* (multi-tenant, audit, cache) fire on every operation.
-*
-* @param repository - A mongokit Repository instance (already created)
-* @param _JournalEntryModel - (Deprecated) The Mongoose model — no longer used internally; kept for API compat
-* @param orgField - The multi-tenant field name (e.g. 'business')
-* @param strictness - Strictness rules (immutable, requireActor, requireApproval)
-*/
-function wireJournalEntryMethods(repository, _JournalEntryModel, orgField, strictness) {
-	const getByQuery = repository.getByQuery.bind(repository);
-	const create = repository.create.bind(repository);
-	const withTransaction = repository.withTransaction.bind(repository);
-	/** Build a tenant-scoped query for a single entry by ID (injection-safe) */
-	function buildQuery(id, orgId) {
-		validateScalarId(id, "entry ID");
-		if (orgId != null) validateScalarId(orgId, "organization ID");
-		const query = { _id: id };
-		if (orgField && orgId != null) query[orgField] = orgId;
-		return query;
-	}
-	/** Reject operator-injected objects like { $ne: null } but allow ObjectIds */
-	function validateScalarId(value, label) {
-		if (value == null || typeof value !== "object") return;
-		const obj = value;
-		if (typeof obj.toHexString === "function" || obj._bsontype === "ObjectId") return;
-		if (Object.keys(obj).some((k) => k.startsWith("$"))) throw Errors.validation(`Invalid ${label} — MongoDB operators are not allowed.`);
-	}
-	/** Fetch an entry via the repository (fires all hooks) */
-	async function findEntry(query, options) {
-		const opts = { lean: false };
-		if (options.populate) opts.populate = options.populate;
-		if (options.session) opts.session = options.session;
-		return await getByQuery(query, opts);
-	}
-	/**
-	* Post an entry (draft → posted).
-	* Validates items, balance, and accounts before changing state.
-	*/
-	repository.post = async (id, orgId, options = {}) => {
-		if (strictness?.requireActor && !options.actorId) throw Errors.validation("actorId is required for post operations.");
-		requireOrgScope(orgField, orgId);
-		const entry = await findEntry(buildQuery(id, orgId), {
-			session: options.session,
-			populate: "journalItems.account"
-		});
-		if (!entry) throw Errors.notFound("Entry not found");
-		if (entry.idempotencyKey && entry.state === "posted") return entry;
-		if (entry.state !== "draft") throw Errors.validation("Only draft entries can be posted");
-		if (strictness?.requireApproval) {
-			if (!entry.approvedBy || !entry.approvedAt) throw Errors.validation("Entry must be approved before posting. Both approvedBy and approvedAt are required.");
-		}
-		if (!entry.journalItems || entry.journalItems.length < 2) throw Errors.validation("Journal entry must have at least 2 items to post");
-		const missing = entry.journalItems.filter((i) => !i.account || i.account === "");
-		if (missing.length > 0) throw Errors.validation(`${missing.length} item(s) missing an account`);
-		const nullAccounts = entry.journalItems.filter((i) => {
-			const acct = i.account;
-			if (!acct) return true;
-			if (typeof acct === "string") return true;
-			if (typeof acct === "object" && !acct._id) return true;
-			return false;
-		});
-		if (nullAccounts.length > 0) throw Errors.validation(`${nullAccounts.length} item(s) reference accounts that do not exist. Ensure all accounts are created before posting.`);
-		if (orgField && orgId != null) {
-			const crossTenant = entry.journalItems.filter((i) => {
-				const acct = i.account;
-				if (!acct || typeof acct !== "object") return false;
-				return String(acct[orgField]) !== String(orgId);
-			});
-			if (crossTenant.length > 0) throw Errors.validation(`${crossTenant.length} item(s) reference accounts from another organization`);
-		}
-		const zeroed = entry.journalItems.filter((i) => (i.debit || 0) === 0 && (i.credit || 0) === 0);
-		if (zeroed.length > 0) throw Errors.validation(`${zeroed.length} item(s) have both debit and credit as zero`);
-		const bothSet = entry.journalItems.filter((i) => (i.debit || 0) > 0 && (i.credit || 0) > 0);
-		if (bothSet.length > 0) throw Errors.validation(`${bothSet.length} item(s) have both debit and credit set — each line must be debit OR credit, not both`);
-		const totalDebit = entry.journalItems.reduce((s, i) => s + (i.debit || 0), 0);
-		const totalCredit = entry.journalItems.reduce((s, i) => s + (i.credit || 0), 0);
-		if (totalDebit !== totalCredit) throw Errors.validation(`Entry is not balanced. Debit: ${totalDebit}, Credit: ${totalCredit}`);
-		entry.state = "posted";
-		entry.stateChangedAt = /* @__PURE__ */ new Date();
-		if (options.actorId) entry.postedBy = options.actorId;
-		await entry.save({ session: options.session });
-		return entry;
-	};
-	/**
-	* Unpost an entry (posted → draft).
-	* Resets state to draft so the entry can be edited and re-posted.
-	* Also clears the reversed flag if set, allowing full re-editing.
-	*/
-	repository.unpost = async (id, orgId, options = {}) => {
-		if (strictness?.immutable) throw Errors.immutable("Unpost is disabled in strict mode. Use reverse() to correct posted entries.");
-		if (strictness?.requireActor && !options.actorId) throw Errors.validation("actorId is required for unpost operations.");
-		requireOrgScope(orgField, orgId);
-		const entry = await findEntry(buildQuery(id, orgId), { session: options.session });
-		if (!entry) throw Errors.notFound("Entry not found");
-		if (entry.state !== "posted") throw Errors.validation("Only posted entries can be unposted");
-		if (entry.reversed) throw Errors.validation("Cannot unpost a reversed entry. The reversal entry is still posted and linked to this entry. Reverse the reversal entry first, or create a new correcting entry instead.");
-		entry.state = "draft";
-		entry.stateChangedAt = /* @__PURE__ */ new Date();
-		await entry.save({ session: options.session });
-		return entry;
-	};
-	/**
-	* Archive a draft entry (draft → archived).
-	* Used to discard unneeded drafts without deleting them, preserving audit trail.
-	* Only draft entries can be archived. Posted entries must be reversed instead.
-	*/
-	repository.archive = async (id, orgId, options = {}) => {
-		if (strictness?.requireActor && !options.actorId) throw Errors.validation("actorId is required for archive operations.");
-		requireOrgScope(orgField, orgId);
-		const entry = await findEntry(buildQuery(id, orgId), { session: options.session });
-		if (!entry) throw Errors.notFound("Entry not found");
-		if (entry.state !== "draft") throw Errors.validation("Only draft entries can be archived");
-		entry.state = "archived";
-		entry.stateChangedAt = /* @__PURE__ */ new Date();
-		await entry.save({ session: options.session });
-		return entry;
-	};
-	/**
-	* Duplicate an entry as a new draft.
-	* Copies journal items, journal type, and label. Assigns today's date.
-	*/
-	repository.duplicate = async (id, orgId, options = {}) => {
-		requireOrgScope(orgField, orgId);
-		const entry = await findEntry(buildQuery(id, orgId), { session: options.session });
-		if (!entry) throw Errors.notFound("Entry not found");
-		const duplicateData = {
-			journalType: entry.journalType,
-			state: "draft",
-			date: /* @__PURE__ */ new Date(),
-			label: entry.label ? `Copy of ${entry.label}` : "Duplicated entry",
-			journalItems: entry.journalItems.map((item) => {
-				const accountId = typeof item.account === "object" && item.account !== null ? item.account._id : item.account;
-				const extra = {};
-				for (const key of Object.keys(item)) if (!ITEM_CORE_KEYS.has(key)) extra[key] = item[key];
-				return {
-					...extra,
-					account: accountId,
-					debit: item.debit ?? 0,
-					credit: item.credit ?? 0,
-					label: item.label,
-					date: /* @__PURE__ */ new Date(),
-					taxDetails: item.taxDetails ?? []
-				};
-			})
-		};
-		if (orgField && entry[orgField] != null) duplicateData[orgField] = entry[orgField];
-		return await create(duplicateData, options.session ? { session: options.session } : {});
-	};
-	/**
-	* Reverse a posted entry by creating a mirror entry with flipped debits/credits.
-	* Marks the original as reversed and links both entries bidirectionally.
-	*
-	* Uses repository.withTransaction() for automatic retry on transient failures.
-	* Pass an external session to join a caller-managed transaction instead.
-	*
-	* Routes the reversal through repository.create() so all plugins (fiscal-lock,
-	* double-entry) enforce policy on the reversal entry.
-	*/
-	repository.reverse = async (id, orgId, options = {}) => {
-		if (strictness?.requireActor && !options.actorId) throw Errors.validation("actorId is required for reverse operations.");
-		requireOrgScope(orgField, orgId);
-		const query = buildQuery(id, orgId);
-		const doReverse = async (session) => {
-			const entry = await findEntry(query, {
-				session,
-				populate: "journalItems.account"
-			});
-			if (!entry) throw Errors.notFound("Entry not found");
-			if (entry.state !== "posted") throw Errors.validation("Only posted entries can be reversed");
-			if (entry.reversed) throw Errors.validation("Entry has already been reversed");
-			const reversalItems = entry.journalItems.map((item) => {
-				const accountId = typeof item.account === "object" && item.account !== null ? item.account._id : item.account;
-				const extra = {};
-				for (const key of Object.keys(item)) if (!ITEM_CORE_KEYS.has(key)) extra[key] = item[key];
-				return {
-					...extra,
-					account: accountId,
-					debit: item.credit ?? 0,
-					credit: item.debit ?? 0,
-					label: item.label ? `Reversal: ${item.label}` : void 0,
-					date: item.date,
-					taxDetails: item.taxDetails ?? []
-				};
-			});
-			const totalDebit = reversalItems.reduce((s, i) => s + i.debit, 0);
-			const totalCredit = reversalItems.reduce((s, i) => s + i.credit, 0);
-			const reversalData = {
-				journalType: entry.journalType ?? "MISC",
-				state: "posted",
-				date: options.reversalDate ?? /* @__PURE__ */ new Date(),
-				label: `Reversal of ${entry.referenceNumber ?? entry._id}`,
-				journalItems: reversalItems,
-				totalDebit,
-				totalCredit,
-				reversalOf: entry._id,
-				stateChangedAt: /* @__PURE__ */ new Date()
-			};
-			if (orgField && entry[orgField] != null) reversalData[orgField] = entry[orgField];
-			if (options.actorId) reversalData.postedBy = options.actorId;
-			const reversalEntry = await create(reversalData, session ? { session } : {});
-			entry.reversed = true;
-			entry.reversedBy = reversalEntry._id;
-			if (options.actorId) entry.reversedByUser = options.actorId;
-			await entry.save({ session });
-			return {
-				original: entry,
-				reversal: reversalEntry
-			};
-		};
-		if (options.session) return await doReverse(options.session);
-		if (withTransaction) return await withTransaction((session) => doReverse(session), { allowFallback: true });
-		return await doReverse();
-	};
-	const methodNames = [
-		"post",
-		"unpost",
-		"archive",
-		"duplicate",
-		"reverse"
-	];
-	if (typeof repository.registerMethod === "function") for (const name of methodNames) {
-		const fn = repository[name];
-		try {
-			delete repository[name];
-			repository.registerMethod(name, fn);
-		} catch {
-			repository[name] = fn;
-		}
-	}
-	return repository;
-}
-//#endregion
-//#region src/repositories/reconciliation.repository.ts
-/**
-* Wire reconciliation methods onto an existing mongokit Repository.
-*
-* - reconcile() uses repository.create() so hooks (multi-tenant, audit) fire
-* - unreconcile() uses repository.delete() so hooks fire
-* - Cross-repo reads (JournalEntryModel) use direct Model access (acceptable)
-*/
-function wireReconciliationMethods(repository, _ReconciliationModel, JournalEntryModel, orgField) {
-	const create = repository.create.bind(repository);
-	const deleteById = repository.delete.bind(repository);
-	/**
-	* Create a reconciliation record linking matched journal entries.
-	* Validates that all entries exist, are posted, and belong to the same account/org.
-	*/
-	repository.reconcile = async (input) => {
-		const { account, journalEntryIds, note, reconciledBy, organizationId } = input;
-		requireOrgScope(orgField, organizationId);
-		if (!journalEntryIds || journalEntryIds.length === 0) throw Errors.validation("journalEntryIds must contain at least one entry.");
-		const query = { _id: { $in: journalEntryIds } };
-		if (orgField && organizationId != null) query[orgField] = organizationId;
-		const entries = await JournalEntryModel.find(query).lean();
-		if (entries.length !== journalEntryIds.length) throw Errors.notFound(`Expected ${journalEntryIds.length} entries but found ${entries.length}. Some entries do not exist or belong to a different organization.`);
-		const notPosted = entries.filter((e) => e.state !== "posted");
-		if (notPosted.length > 0) throw Errors.validation(`${notPosted.length} entry(ies) are not posted. Only posted entries can be reconciled.`);
-		const accountStr = String(account);
-		for (const entry of entries) if (!entry.journalItems.some((item) => String(item.account) === accountStr)) throw Errors.validation(`Entry ${entry._id} does not contain any items for account ${account}.`);
-		let debitTotal = 0;
-		let creditTotal = 0;
-		for (const entry of entries) for (const item of entry.journalItems) if (String(item.account) === accountStr) {
-			debitTotal += item.debit ?? 0;
-			creditTotal += item.credit ?? 0;
-		}
-		const reconciliationData = {
-			account,
-			journalEntryIds,
-			debitTotal,
-			creditTotal,
-			difference: debitTotal - creditTotal,
-			note,
-			reconciledBy,
-			reconciledAt: /* @__PURE__ */ new Date()
-		};
-		if (orgField && organizationId != null) reconciliationData[orgField] = organizationId;
-		return await create(reconciliationData);
-	};
-	/**
-	* Remove a reconciliation record via repository.delete().
-	*/
-	repository.unreconcile = async (input) => {
-		const { reconciliationId, organizationId } = input;
-		requireOrgScope(orgField, organizationId);
-		if (orgField && organizationId != null) {
-			if (!await repository._executeQuery(async (Model) => Model.findOne({
-				_id: reconciliationId,
-				[orgField]: organizationId
-			}).select("_id").lean())) throw Errors.notFound("Reconciliation record not found.");
-		}
-		const result = await deleteById(String(reconciliationId));
-		if (!result.success) throw Errors.notFound("Reconciliation record not found.");
-		return result;
-	};
-	/**
-	* Find journal entries for an account that are NOT in any reconciliation record.
-	* Uses repository.getAll() for reconciliation lookups (hooks fire),
-	* and direct JournalEntryModel for cross-repo reads (acceptable).
-	*/
-	repository.getUnreconciled = async (input) => {
-		const { accountId, organizationId, limit = 100, skip = 0 } = input;
-		requireOrgScope(orgField, organizationId);
-		const reconFilter = { account: accountId };
-		if (orgField && organizationId != null) reconFilter[orgField] = organizationId;
-		const reconciliations = await repository._executeQuery(async (Model) => Model.find(reconFilter).select("journalEntryIds").lean());
-		const reconciledIds = /* @__PURE__ */ new Set();
-		for (const rec of reconciliations) for (const id of rec.journalEntryIds) reconciledIds.add(String(id));
-		const entryFilter = {
-			state: "posted",
-			"journalItems.account": accountId
-		};
-		if (orgField && organizationId != null) entryFilter[orgField] = organizationId;
-		if (reconciledIds.size > 0) entryFilter._id = { $nin: Array.from(reconciledIds) };
-		return await JournalEntryModel.find(entryFilter).sort({ date: -1 }).skip(skip).limit(limit).lean();
-	};
-	if (typeof repository.registerMethod === "function") for (const name of [
-		"reconcile",
-		"unreconcile",
-		"getUnreconciled"
-	]) {
-		const fn = repository[name];
-		try {
-			delete repository[name];
-			repository.registerMethod(name, fn);
-		} catch {
-			repository[name] = fn;
-		}
-	}
-	return repository;
-}
-//#endregion
-export { wireJournalEntryMethods as n, wireAccountMethods as r, wireReconciliationMethods as t };