@classytic/flow 0.1.4

package/dist/repositories-nZXJKvLW.mjs

@@ -0,0 +1,842 @@
+import { h as ValidationError } from "./domain-errors-D7S9ydNF.mjs";
+import { AggregationBuilder, createRepository } from "@classytic/mongokit";
+import { Types } from "mongoose";
+//#region src/repositories/types.ts
+/**
+* Cast the opaque TransactionSession to Mongoose ClientSession.
+* This is the one unavoidable branded-type cast in the repo layer — the port
+* uses an opaque type so services never touch mongoose directly.
+*/
+function toSession(session) {
+	return session;
+}
+/** Returns true if the string is a valid MongoDB ObjectId. */
+function isValidId(id) {
+	return Types.ObjectId.isValid(id);
+}
+/** Convert FlowContext organizationId (string) to ObjectId for MongoDB queries. */
+function toOrgId(ctx) {
+	return new Types.ObjectId(ctx.organizationId);
+}
+/**
+* Extract docs from MongoKit's PaginationResult or raw array.
+* - Paginated result (offset, keyset, aggregate): returns `.docs`
+* - Raw array (from noPagination: true / findAll): returns as-is
+*/
+function extractDocs(result) {
+	if (Array.isArray(result)) return result;
+	return result.docs;
+}
+/**
+* Narrow a PaginationResult to its offset variant with full metadata.
+* Safe to call when you know the query used offset pagination (page param).
+*/
+function asOffsetResult(result) {
+	return result;
+}
+//#endregion
+//#region src/repositories/cost-layer.repository.ts
+var CostLayerRepository = class {
+	repo;
+	constructor(model, plugins = []) {
+		this.repo = createRepository(model, plugins);
+	}
+	async create(input, session) {
+		return this.repo.create({ ...input }, {
+			session: toSession(session),
+			organizationId: input.organizationId
+		});
+	}
+	async drain(id, quantity, ctx, session) {
+		return this.repo.update(id, { $inc: { remainingQty: -quantity } }, {
+			session: toSession(session),
+			organizationId: ctx.organizationId,
+			lean: true
+		});
+	}
+	async findBySkuRef(skuRef, locationId, ctx, session) {
+		return this.repo.findAll({
+			skuRef,
+			locationId,
+			organizationId: toOrgId(ctx)
+		}, {
+			session: toSession(session),
+			lean: true,
+			organizationId: ctx.organizationId
+		});
+	}
+	async findMany(filter, ctx, session, options) {
+		return this.repo.findAll({
+			...filter,
+			organizationId: toOrgId(ctx)
+		}, {
+			session: toSession(session),
+			lean: true,
+			organizationId: ctx.organizationId,
+			...options
+		});
+	}
+	async findOrderedForConsumption(skuRef, locationId, method, ctx, session) {
+		const sortField = method === "fifo" ? "receivedAt" : "expiresAt";
+		return this.repo.findAll({
+			skuRef,
+			locationId,
+			remainingQty: { $gt: 0 },
+			organizationId: toOrgId(ctx)
+		}, {
+			session: toSession(session),
+			lean: true,
+			sort: { [sortField]: 1 }
+		});
+	}
+};
+//#endregion
+//#region src/repositories/count.repository.ts
+var CountRepository = class {
+	countRepo;
+	lineRepo;
+	constructor(countModel, lineModel, plugins = []) {
+		this.countRepo = createRepository(countModel, plugins);
+		this.lineRepo = createRepository(lineModel, plugins);
+	}
+	async create(input, session) {
+		return this.countRepo.create({ ...input }, {
+			session: toSession(session),
+			organizationId: input.organizationId
+		});
+	}
+	async findById(id, ctx, session) {
+		if (!isValidId(id)) return null;
+		return this.countRepo.getByQuery({
+			_id: id,
+			organizationId: toOrgId(ctx)
+		}, {
+			session: toSession(session),
+			lean: true,
+			throwOnNotFound: false
+		});
+	}
+	async updateStatus(id, status, updates, session) {
+		return this.countRepo.update(id, {
+			...updates,
+			status
+		}, {
+			session: toSession(session),
+			lean: true
+		});
+	}
+	async submitLines(countId, lines, session) {
+		const enriched = lines.map((line) => ({
+			...line,
+			countId
+		}));
+		return this.lineRepo.createMany(enriched, { session: toSession(session) });
+	}
+	async getLines(countId, ctx, session) {
+		return this.lineRepo.findAll({
+			countId,
+			organizationId: toOrgId(ctx)
+		}, {
+			session: toSession(session),
+			lean: true,
+			sort: { createdAt: -1 },
+			organizationId: ctx.organizationId
+		});
+	}
+};
+//#endregion
+//#region src/domain/entities/location.ts
+/**
+* Validate that adding a parent doesn't create a cycle.
+* Pass the full location list for the node to check hierarchy.
+*/
+function validateLocationHierarchy(locationId, parentLocationId, allLocations) {
+	if (locationId === parentLocationId) throw new ValidationError(`Location ${locationId} cannot be its own parent`);
+	const visited = /* @__PURE__ */ new Set();
+	let current = parentLocationId;
+	while (current) {
+		if (current === locationId) throw new ValidationError(`Circular reference: setting parent would create cycle involving ${locationId}`);
+		if (visited.has(current)) break;
+		visited.add(current);
+		current = allLocations.find((l) => l._id === current)?.parentLocationId;
+	}
+}
+//#endregion
+//#region src/repositories/location.repository.ts
+var LocationRepository = class {
+	repo;
+	constructor(model, plugins = []) {
+		this.repo = createRepository(model, plugins);
+	}
+	async findById(id, ctx, session) {
+		if (!isValidId(id)) return null;
+		return this.repo.getByQuery({
+			_id: id,
+			organizationId: toOrgId(ctx)
+		}, {
+			session: toSession(session),
+			lean: true,
+			throwOnNotFound: false
+		});
+	}
+	async findByNode(nodeId, ctx, session) {
+		return this.repo.findAll({
+			nodeId,
+			organizationId: toOrgId(ctx)
+		}, {
+			session: toSession(session),
+			lean: true,
+			sort: { sortOrder: 1 },
+			organizationId: ctx.organizationId
+		});
+	}
+	async findByBarcode(barcode, ctx, session) {
+		return this.repo.getByQuery({
+			barcode,
+			organizationId: toOrgId(ctx)
+		}, {
+			session: toSession(session),
+			lean: true,
+			throwOnNotFound: false
+		});
+	}
+	async findByCode(code, nodeId, ctx, session) {
+		return this.repo.getByQuery({
+			code,
+			nodeId,
+			organizationId: toOrgId(ctx)
+		}, {
+			session: toSession(session),
+			lean: true,
+			throwOnNotFound: false
+		});
+	}
+	async getTree(nodeId, ctx, session) {
+		return this.repo.findAll({
+			nodeId,
+			organizationId: toOrgId(ctx)
+		}, {
+			session: toSession(session),
+			lean: true,
+			sort: { sortOrder: 1 },
+			organizationId: ctx.organizationId
+		});
+	}
+	async create(input, session) {
+		if (input.parentLocationId) {
+			const inputWithId = input;
+			if (inputWithId._id && input.parentLocationId === String(inputWithId._id)) throw new Error("Location cannot be its own parent");
+		}
+		return this.repo.create({ ...input }, {
+			session: toSession(session),
+			organizationId: input.organizationId
+		});
+	}
+	async update(id, updates, ctx, session) {
+		if (updates.parentLocationId) {
+			const current = await this.findById(id, ctx, session);
+			if (current) {
+				const allLocations = await this.getTree(current.nodeId, ctx, session);
+				validateLocationHierarchy(id, updates.parentLocationId, allLocations);
+			}
+		}
+		return this.repo.update(id, { ...updates }, {
+			session: toSession(session),
+			organizationId: ctx.organizationId,
+			lean: true
+		});
+	}
+};
+//#endregion
+//#region src/repositories/lot.repository.ts
+var LotRepository = class {
+	repo;
+	constructor(model, plugins = []) {
+		this.repo = createRepository(model, plugins);
+	}
+	async findById(id, ctx, session) {
+		if (!isValidId(id)) return null;
+		return this.repo.getByQuery({
+			_id: id,
+			organizationId: toOrgId(ctx)
+		}, {
+			session: toSession(session),
+			lean: true,
+			throwOnNotFound: false
+		});
+	}
+	async findByCode(lotCode, skuRef, ctx, session) {
+		const query = {
+			lotCode,
+			organizationId: toOrgId(ctx)
+		};
+		if (skuRef) query.skuRef = skuRef;
+		return this.repo.getByQuery(query, {
+			session: toSession(session),
+			lean: true,
+			throwOnNotFound: false
+		});
+	}
+	async findBySerial(serialCode, skuRef, ctx, session) {
+		const query = {
+			serialCode,
+			organizationId: toOrgId(ctx)
+		};
+		if (skuRef) query.skuRef = skuRef;
+		return this.repo.getByQuery(query, {
+			session: toSession(session),
+			lean: true,
+			throwOnNotFound: false
+		});
+	}
+	async findMany(filter, ctx, session, options) {
+		return this.repo.findAll({
+			...filter,
+			organizationId: toOrgId(ctx)
+		}, {
+			session: toSession(session),
+			lean: true,
+			organizationId: ctx.organizationId,
+			...options
+		});
+	}
+	async create(input, session) {
+		return this.repo.create({ ...input }, {
+			session: toSession(session),
+			organizationId: input.organizationId
+		});
+	}
+	async update(id, updates, ctx, session) {
+		return this.repo.update(id, { ...updates }, {
+			session: toSession(session),
+			organizationId: ctx.organizationId,
+			lean: true
+		});
+	}
+};
+//#endregion
+//#region src/repositories/move.repository.ts
+var MoveRepository = class {
+	repo;
+	constructor(model, plugins = []) {
+		this.repo = createRepository(model, plugins);
+	}
+	async create(input, session) {
+		return this.repo.create({ ...input }, {
+			session: toSession(session),
+			organizationId: input.organizationId
+		});
+	}
+	async findById(id, ctx, session) {
+		if (!isValidId(id)) return null;
+		return this.repo.getByQuery({
+			_id: id,
+			organizationId: toOrgId(ctx)
+		}, {
+			session: toSession(session),
+			lean: true,
+			throwOnNotFound: false
+		});
+	}
+	async findByGroupId(groupId, ctx, session) {
+		return this.repo.findAll({
+			moveGroupId: groupId,
+			organizationId: toOrgId(ctx)
+		}, {
+			session: toSession(session),
+			lean: true,
+			organizationId: ctx.organizationId
+		});
+	}
+	async updateStatus(id, status, updates, session) {
+		return this.repo.update(id, {
+			...updates,
+			status
+		}, {
+			session: toSession(session),
+			lean: true
+		});
+	}
+	async findMany(filter, ctx, session, options) {
+		return this.repo.findAll({
+			...filter,
+			organizationId: toOrgId(ctx)
+		}, {
+			session: toSession(session),
+			lean: true,
+			organizationId: ctx.organizationId,
+			...options
+		});
+	}
+};
+//#endregion
+//#region src/repositories/move-group.repository.ts
+var MoveGroupRepository = class {
+	repo;
+	constructor(model, plugins = []) {
+		this.repo = createRepository(model, plugins);
+	}
+	async create(input, session) {
+		return this.repo.create({ ...input }, {
+			session: toSession(session),
+			organizationId: input.organizationId
+		});
+	}
+	async findById(id, ctx, session) {
+		if (!isValidId(id)) return null;
+		return this.repo.getByQuery({
+			_id: id,
+			organizationId: toOrgId(ctx)
+		}, {
+			session: toSession(session),
+			lean: true,
+			throwOnNotFound: false
+		});
+	}
+	async updateStatus(id, status, updates, session) {
+		return this.repo.update(id, {
+			...updates,
+			status
+		}, {
+			session: toSession(session),
+			lean: true
+		});
+	}
+	async list(query, ctx, session) {
+		const page = query.page ?? 1;
+		const pageSize = query.pageSize ?? 20;
+		const sort = query.sort ?? { createdAt: -1 };
+		const filters = {
+			...query.filter,
+			organizationId: toOrgId(ctx)
+		};
+		const offsetResult = await this.repo.getAll({
+			filters,
+			sort,
+			page,
+			limit: pageSize
+		}, {
+			session: toSession(session),
+			lean: true,
+			organizationId: ctx.organizationId
+		});
+		return {
+			data: offsetResult.docs,
+			total: offsetResult.total,
+			page: offsetResult.page,
+			pageSize,
+			hasMore: offsetResult.hasNext
+		};
+	}
+};
+//#endregion
+//#region src/repositories/node.repository.ts
+var NodeRepository = class {
+	repo;
+	constructor(model, plugins = []) {
+		this.repo = createRepository(model, plugins);
+	}
+	async findById(id, ctx, session) {
+		if (!isValidId(id)) return null;
+		return this.repo.getByQuery({
+			_id: id,
+			organizationId: toOrgId(ctx)
+		}, {
+			session: toSession(session),
+			lean: true,
+			throwOnNotFound: false
+		});
+	}
+	async findDefault(ctx, session) {
+		return this.repo.getByQuery({
+			isDefault: true,
+			organizationId: toOrgId(ctx)
+		}, {
+			session: toSession(session),
+			lean: true,
+			throwOnNotFound: false
+		});
+	}
+	async list(ctx, session) {
+		return this.repo.findAll({ organizationId: toOrgId(ctx) }, {
+			session: toSession(session),
+			lean: true,
+			organizationId: ctx.organizationId
+		});
+	}
+	async create(input, session) {
+		return this.repo.create({ ...input }, {
+			session: toSession(session),
+			organizationId: input.organizationId
+		});
+	}
+	async update(id, updates, ctx, session) {
+		return this.repo.update(id, { ...updates }, {
+			session: toSession(session),
+			organizationId: ctx.organizationId,
+			lean: true
+		});
+	}
+};
+//#endregion
+//#region src/repositories/procurement.repository.ts
+var ProcurementRepository = class {
+	repo;
+	constructor(model, plugins = []) {
+		this.repo = createRepository(model, plugins);
+	}
+	async create(input, session) {
+		return this.repo.create({ ...input }, {
+			session: toSession(session),
+			organizationId: input.organizationId
+		});
+	}
+	async findById(id, ctx, session) {
+		if (!isValidId(id)) return null;
+		return this.repo.getByQuery({
+			_id: id,
+			organizationId: toOrgId(ctx)
+		}, {
+			session: toSession(session),
+			lean: true,
+			throwOnNotFound: false
+		});
+	}
+	async updateStatus(id, status, updates, session) {
+		return this.repo.update(id, {
+			...updates,
+			status
+		}, {
+			session: toSession(session),
+			lean: true
+		});
+	}
+	async findMany(filter, ctx, session, options) {
+		return this.repo.findAll({
+			...filter,
+			organizationId: toOrgId(ctx)
+		}, {
+			session: toSession(session),
+			lean: true,
+			organizationId: ctx.organizationId,
+			...options
+		});
+	}
+	async list(query, ctx, session) {
+		const page = query.page ?? 1;
+		const pageSize = query.pageSize ?? 20;
+		const sort = query.sort ?? { createdAt: -1 };
+		const filters = {
+			...query.filter,
+			organizationId: toOrgId(ctx)
+		};
+		const offsetResult = await this.repo.getAll({
+			filters,
+			sort,
+			page,
+			limit: pageSize
+		}, {
+			session: toSession(session),
+			lean: true,
+			organizationId: ctx.organizationId
+		});
+		return {
+			data: offsetResult.docs,
+			total: offsetResult.total,
+			page: offsetResult.page,
+			pageSize,
+			hasMore: offsetResult.hasNext
+		};
+	}
+};
+//#endregion
+//#region src/repositories/quant.repository.ts
+function toObjectId(value) {
+	return new Types.ObjectId(value);
+}
+var QuantRepository = class {
+	repo;
+	constructor(model, plugins = []) {
+		this.repo = createRepository(model, plugins);
+	}
+	async getAvailability(query, ctx, session) {
+		const match = { organizationId: toObjectId(ctx.organizationId) };
+		if (query.skuRef) match.skuRef = query.skuRef;
+		if (query.locationId) match.locationId = query.locationId;
+		if (query.lotId) match.lotId = typeof query.lotId === "string" ? toObjectId(query.lotId) : query.lotId;
+		if (query.stockStatus) match.stockStatus = query.stockStatus;
+		if (query.nodeId) {
+			const locationIds = (await this.repo.Model.db.collection("locations").find({
+				organizationId: toObjectId(ctx.organizationId),
+				nodeId: toObjectId(query.nodeId)
+			}, { projection: { _id: 1 } }).toArray()).map((l) => l._id.toString());
+			if (query.locationId) if (locationIds.includes(query.locationId)) match.locationId = query.locationId;
+			else match.locationId = { $in: [] };
+			else match.locationId = { $in: locationIds };
+		}
+		const pipeline = new AggregationBuilder().match(match).group({
+			_id: null,
+			quantityOnHand: { $sum: "$quantityOnHand" },
+			quantityReserved: { $sum: "$quantityReserved" },
+			quantityAvailable: { $sum: "$quantityAvailable" },
+			quantityIncoming: { $sum: { $ifNull: ["$quantityIncoming", 0] } },
+			quantityOutgoing: { $sum: { $ifNull: ["$quantityOutgoing", 0] } },
+			breakdowns: { $push: "$$ROOT" }
+		}).build();
+		const [result] = await this.repo.aggregate(pipeline, {
+			session: toSession(session),
+			organizationId: ctx.organizationId
+		});
+		if (!result) return {
+			quantityOnHand: 0,
+			quantityReserved: 0,
+			quantityAvailable: 0,
+			quantityIncoming: 0,
+			quantityOutgoing: 0,
+			breakdowns: []
+		};
+		return {
+			quantityOnHand: result.quantityOnHand,
+			quantityReserved: result.quantityReserved,
+			quantityAvailable: result.quantityAvailable,
+			quantityIncoming: result.quantityIncoming,
+			quantityOutgoing: result.quantityOutgoing,
+			breakdowns: result.breakdowns
+		};
+	}
+	async upsert(update, session) {
+		const filter = {
+			organizationId: update.organizationId,
+			skuRef: update.skuRef,
+			locationId: update.locationId
+		};
+		if (update.lotId != null) filter.lotId = update.lotId;
+		else filter.lotId = null;
+		if (update.ownerRef != null) filter.ownerRef = update.ownerRef;
+		else filter.ownerRef = null;
+		const setStage = {
+			quantityOnHand: { $add: [{ $ifNull: ["$quantityOnHand", 0] }, update.quantityDelta] },
+			quantityReserved: { $add: [{ $ifNull: ["$quantityReserved", 0] }, update.reservedDelta ?? 0] },
+			lastMovementAt: /* @__PURE__ */ new Date()
+		};
+		if (update.stockStatus) setStage.stockStatus = update.stockStatus;
+		if (update.unitCost !== void 0) setStage.unitCost = update.unitCost;
+		if (update.inDate) setStage.inDate = { $min: [{ $ifNull: ["$inDate", update.inDate] }, update.inDate] };
+		const pipeline = [{ $set: setStage }, { $set: { quantityAvailable: { $subtract: ["$quantityOnHand", "$quantityReserved"] } } }];
+		return await this.repo.Model.findOneAndUpdate(filter, pipeline, {
+			upsert: true,
+			returnDocument: "after",
+			session: toSession(session),
+			updatePipeline: true
+		}).lean().exec();
+	}
+	async batchUpsert(updates, session) {
+		if (updates.length === 0) return;
+		const ops = updates.map((update) => {
+			const filter = {
+				organizationId: update.organizationId,
+				skuRef: update.skuRef,
+				locationId: update.locationId,
+				lotId: update.lotId ?? null,
+				ownerRef: update.ownerRef ?? null
+			};
+			const setStage = {
+				quantityOnHand: { $add: [{ $ifNull: ["$quantityOnHand", 0] }, update.quantityDelta] },
+				quantityReserved: { $add: [{ $ifNull: ["$quantityReserved", 0] }, update.reservedDelta ?? 0] },
+				lastMovementAt: /* @__PURE__ */ new Date()
+			};
+			if (update.stockStatus) setStage.stockStatus = update.stockStatus;
+			if (update.unitCost !== void 0) setStage.unitCost = update.unitCost;
+			if (update.inDate) setStage.inDate = { $min: [{ $ifNull: ["$inDate", update.inDate] }, update.inDate] };
+			return { updateOne: {
+				filter,
+				update: [{ $set: setStage }, { $set: { quantityAvailable: { $subtract: ["$quantityOnHand", "$quantityReserved"] } } }],
+				upsert: true
+			} };
+		});
+		await this.repo.Model.bulkWrite(ops, {
+			session: toSession(session),
+			ordered: false
+		});
+	}
+	async findByIdentity(identity, session) {
+		return this.repo.getByQuery({
+			organizationId: new Types.ObjectId(identity.organizationId),
+			skuRef: identity.skuRef,
+			locationId: identity.locationId,
+			lotId: identity.lotId ?? null,
+			ownerRef: identity.ownerRef ?? null
+		}, {
+			session: toSession(session),
+			lean: true,
+			throwOnNotFound: false
+		});
+	}
+	async findMany(filter, ctx, session, options) {
+		return this.repo.findAll({
+			...filter,
+			organizationId: toOrgId(ctx)
+		}, {
+			session: toSession(session),
+			lean: true,
+			organizationId: ctx.organizationId,
+			...options
+		});
+	}
+	async deleteAll(ctx, session) {
+		await this.repo.Model.deleteMany({ organizationId: toObjectId(ctx.organizationId) }).session(toSession(session) ?? null).exec();
+	}
+};
+//#endregion
+//#region src/repositories/replenishment-rule.repository.ts
+var ReplenishmentRuleRepository = class {
+	repo;
+	constructor(model, plugins = []) {
+		this.repo = createRepository(model, plugins);
+	}
+	async findByNode(nodeId, ctx, session) {
+		return this.repo.findAll({
+			scopeRef: nodeId,
+			scopeType: "node",
+			organizationId: toOrgId(ctx)
+		}, {
+			session: toSession(session),
+			lean: true,
+			organizationId: ctx.organizationId
+		});
+	}
+	async findBySkuRef(skuRef, ctx, session) {
+		return this.repo.findAll({
+			skuRef,
+			organizationId: toOrgId(ctx)
+		}, {
+			session: toSession(session),
+			lean: true,
+			organizationId: ctx.organizationId
+		});
+	}
+	async list(ctx, session) {
+		return this.repo.findAll({ organizationId: toOrgId(ctx) }, {
+			session: toSession(session),
+			lean: true,
+			organizationId: ctx.organizationId
+		});
+	}
+	async findById(id, ctx, session) {
+		if (!isValidId(id)) return null;
+		return this.repo.getByQuery({
+			_id: id,
+			organizationId: toOrgId(ctx)
+		}, {
+			session: toSession(session),
+			lean: true,
+			throwOnNotFound: false
+		});
+	}
+	async delete(id, ctx, session) {
+		await this.repo.delete(id, {
+			session: toSession(session),
+			organizationId: ctx.organizationId
+		});
+	}
+	async findMany(filter, ctx, session, options) {
+		return this.repo.findAll({
+			...filter,
+			organizationId: toOrgId(ctx)
+		}, {
+			session: toSession(session),
+			lean: true,
+			organizationId: ctx.organizationId,
+			...options
+		});
+	}
+	async create(input, session) {
+		return this.repo.create({ ...input }, {
+			session: toSession(session),
+			organizationId: input.organizationId
+		});
+	}
+	async update(id, updates, ctx, session) {
+		return this.repo.update(id, { ...updates }, {
+			session: toSession(session),
+			organizationId: ctx.organizationId,
+			lean: true
+		});
+	}
+};
+//#endregion
+//#region src/repositories/reservation.repository.ts
+var ReservationRepository = class {
+	repo;
+	constructor(model, plugins = []) {
+		this.repo = createRepository(model, plugins);
+	}
+	async create(input, session) {
+		return this.repo.create({ ...input }, {
+			session: toSession(session),
+			organizationId: input.organizationId
+		});
+	}
+	async findById(id, ctx, session) {
+		if (!isValidId(id)) return null;
+		return this.repo.getByQuery({
+			_id: id,
+			organizationId: toOrgId(ctx)
+		}, {
+			session: toSession(session),
+			lean: true,
+			throwOnNotFound: false
+		});
+	}
+	async findByOwner(ownerType, ownerId, ctx, session) {
+		return this.repo.findAll({
+			ownerType,
+			ownerId,
+			organizationId: toOrgId(ctx)
+		}, {
+			session: toSession(session),
+			lean: true,
+			organizationId: ctx.organizationId
+		});
+	}
+	async updateStatus(id, status, updates, session) {
+		return this.repo.update(id, {
+			...updates,
+			status
+		}, {
+			session: toSession(session),
+			lean: true
+		});
+	}
+	async findExpired(asOf, ctx, session) {
+		return this.repo.findAll({
+			status: "active",
+			expiresAt: { $lt: asOf },
+			organizationId: toOrgId(ctx)
+		}, {
+			session: toSession(session),
+			lean: true,
+			organizationId: ctx.organizationId
+		});
+	}
+};
+//#endregion
+//#region src/repositories/index.ts
+function createRepositories(models, plugins) {
+	const p = plugins ?? {};
+	return {
+		quant: new QuantRepository(models.StockQuant, p.quant),
+		move: new MoveRepository(models.StockMove, p.move),
+		moveGroup: new MoveGroupRepository(models.StockMoveGroup, p.moveGroup),
+		reservation: new ReservationRepository(models.Reservation, p.reservation),
+		location: new LocationRepository(models.Location, p.location),
+		node: new NodeRepository(models.InventoryNode, p.node),
+		lot: new LotRepository(models.StockLot, p.lot),
+		costLayer: new CostLayerRepository(models.CostLayer, p.costLayer),
+		procurement: new ProcurementRepository(models.ProcurementOrder, p.procurement),
+		count: new CountRepository(models.InventoryCount, models.CountLine, p.count),
+		replenishmentRule: new ReplenishmentRuleRepository(models.ReplenishmentRule, p.replenishmentRule)
+	};
+}
+//#endregion
+export { ProcurementRepository as a, MoveRepository as c, CountRepository as d, CostLayerRepository as f, toSession as g, toOrgId as h, QuantRepository as i, LotRepository as l, extractDocs as m, ReservationRepository as n, NodeRepository as o, asOffsetResult as p, ReplenishmentRuleRepository as r, MoveGroupRepository as s, createRepositories as t, LocationRepository as u };