@classytic/flow 0.1.4

package/dist/move-group.port-DHGoQA3d.d.mts

@@ -0,0 +1,56 @@
+import { l as GroupType } from "./index-CulWO137.mjs";
+import { i as PaginatedResult, r as ListQuery, t as FlowContext } from "./index-DFF0GJ4J.mjs";
+import { t as TransactionSession } from "./unit-of-work.port-CWEkrDKu.mjs";
+
+//#region src/domain/entities/stock-move-group.d.ts
+type MoveGroupStatus = 'draft' | 'confirmed' | 'allocated' | 'in_progress' | 'partially_done' | 'done' | 'cancelled';
+declare const MOVE_GROUP_STATUS_TRANSITIONS: Record<MoveGroupStatus, readonly MoveGroupStatus[]>;
+interface StockMoveGroup {
+  _id: string;
+  organizationId: string;
+  groupType: GroupType;
+  documentNumber: string;
+  sourceNodeId?: string;
+  destinationNodeId?: string;
+  status: MoveGroupStatus;
+  priority?: number;
+  routePlanId?: string;
+  counterparty?: {
+    type: string;
+    id: string;
+  };
+  requestedAt?: Date;
+  confirmedAt?: Date;
+  completedAt?: Date;
+  createdBy?: string;
+  modifiedBy?: string;
+  notes?: string;
+  metadata?: Record<string, unknown>;
+  createdAt?: Date;
+  updatedAt?: Date;
+}
+//#endregion
+//#region src/domain/ports/move-group.port.d.ts
+interface CreateMoveGroupInput {
+  organizationId: string;
+  groupType: string;
+  documentNumber: string;
+  sourceNodeId?: string;
+  destinationNodeId?: string;
+  priority?: number;
+  counterparty?: {
+    type: string;
+    id: string;
+  };
+  notes?: string;
+  createdBy: string;
+  metadata?: Record<string, unknown>;
+}
+interface MoveGroupPort {
+  create(input: CreateMoveGroupInput, session?: TransactionSession): Promise<StockMoveGroup>;
+  findById(id: string, ctx: FlowContext, session?: TransactionSession): Promise<StockMoveGroup | null>;
+  updateStatus(id: string, status: MoveGroupStatus, updates: Partial<StockMoveGroup>, session?: TransactionSession): Promise<StockMoveGroup>;
+  list(query: ListQuery, ctx: FlowContext, session?: TransactionSession): Promise<PaginatedResult<StockMoveGroup>>;
+}
+//#endregion
+export { StockMoveGroup as a, MoveGroupStatus as i, MoveGroupPort as n, MOVE_GROUP_STATUS_TRANSITIONS as r, CreateMoveGroupInput as t };

package/dist/move-status-DkaFp2GD.mjs

@@ -0,0 +1,38 @@
+//#region src/domain/enums/move-status.ts
+const MoveStatus = {
+	draft: "draft",
+	planned: "planned",
+	waiting: "waiting",
+	ready: "ready",
+	partially_done: "partially_done",
+	done: "done",
+	cancelled: "cancelled"
+};
+/** Valid status transitions for stock moves. */
+const MOVE_STATUS_TRANSITIONS = {
+	[MoveStatus.draft]: [
+		MoveStatus.planned,
+		MoveStatus.ready,
+		MoveStatus.done,
+		MoveStatus.cancelled
+	],
+	[MoveStatus.planned]: [
+		MoveStatus.waiting,
+		MoveStatus.ready,
+		MoveStatus.cancelled
+	],
+	[MoveStatus.waiting]: [MoveStatus.ready, MoveStatus.cancelled],
+	[MoveStatus.ready]: [
+		MoveStatus.partially_done,
+		MoveStatus.done,
+		MoveStatus.cancelled
+	],
+	[MoveStatus.partially_done]: [MoveStatus.done, MoveStatus.cancelled],
+	[MoveStatus.done]: [],
+	[MoveStatus.cancelled]: []
+};
+function isValidMoveTransition(from, to) {
+	return MOVE_STATUS_TRANSITIONS[from].includes(to);
+}
+//#endregion
+export { MoveStatus as n, isValidMoveTransition as r, MOVE_STATUS_TRANSITIONS as t };

package/dist/move.port-Qg1CYp7h.d.mts

@@ -0,0 +1,89 @@
+import { f as MoveStatus, u as OperationType } from "./index-CulWO137.mjs";
+import { a as QueryOptions, t as FlowContext } from "./index-DFF0GJ4J.mjs";
+import { t as TransactionSession } from "./unit-of-work.port-CWEkrDKu.mjs";
+
+//#region src/domain/value-objects/tracking-assignment.d.ts
+type TrackingAssignment = {
+  trackingMode: 'none';
+  quantity: number;
+  expiresAt?: Date;
+} | {
+  trackingMode: 'lot';
+  lotId?: string;
+  lotCode: string;
+  quantity: number;
+  expiresAt?: Date;
+} | {
+  trackingMode: 'serial';
+  serialCode: string;
+  quantity: 1;
+  expiresAt?: Date;
+};
+//#endregion
+//#region src/domain/entities/stock-move.d.ts
+interface StockMove {
+  _id: string;
+  organizationId: string;
+  moveGroupId: string;
+  referenceType?: string;
+  referenceId?: string;
+  operationType: OperationType;
+  skuRef: string;
+  sourceLocationId: string;
+  destinationLocationId: string;
+  trackingAssignments?: TrackingAssignment[];
+  uom?: string;
+  quantityPlanned: number;
+  quantityReserved?: number;
+  quantityDone?: number;
+  status: MoveStatus;
+  scheduledAt?: Date;
+  executedAt?: Date;
+  cancelledAt?: Date;
+  reservationIds?: string[];
+  policySnapshot?: Record<string, unknown>;
+  createdBy?: string;
+  modifiedBy?: string;
+  metadata?: Record<string, unknown>;
+  createdAt?: Date;
+  updatedAt?: Date;
+}
+/**
+ * Validate a move status transition. Throws if invalid.
+ */
+declare function assertMoveTransition(move: StockMove, targetStatus: MoveStatus): void;
+//#endregion
+//#region src/domain/ports/move.port.d.ts
+interface CreateMoveInput {
+  moveGroupId: string;
+  operationType: string;
+  skuRef: string;
+  sourceLocationId: string;
+  destinationLocationId: string;
+  quantityPlanned: number;
+  uom?: string;
+  trackingAssignments?: Array<{
+    trackingMode: string;
+    lotId?: string;
+    lotCode?: string;
+    serialCode?: string;
+    quantity: number;
+    expiresAt?: Date;
+  }>;
+  scheduledAt?: Date;
+  referenceType?: string;
+  referenceId?: string;
+  metadata?: Record<string, unknown>;
+}
+interface MovePort {
+  create(input: CreateMoveInput & {
+    organizationId: string;
+    createdBy: string;
+  }, session?: TransactionSession): Promise<StockMove>;
+  findById(id: string, ctx: FlowContext, session?: TransactionSession): Promise<StockMove | null>;
+  findByGroupId(groupId: string, ctx: FlowContext, session?: TransactionSession): Promise<StockMove[]>;
+  updateStatus(id: string, status: MoveStatus, updates: Partial<StockMove>, session?: TransactionSession): Promise<StockMove>;
+  findMany(filter: Record<string, unknown>, ctx: FlowContext, session?: TransactionSession, options?: QueryOptions): Promise<StockMove[]>;
+}
+//#endregion
+export { TrackingAssignment as a, assertMoveTransition as i, MovePort as n, StockMove as r, CreateMoveInput as t };

package/dist/package.service-4tcAwBbr.mjs

@@ -0,0 +1,95 @@
+import { t as assertTenantContext } from "./tenant-guard-6Ne-BILP.mjs";
+//#region src/services/package.service.ts
+var PackageService = class {
+	constructor(packageModel, quantPort) {
+		this.packageModel = packageModel;
+		this.quantPort = quantPort;
+	}
+	async create(input, ctx) {
+		assertTenantContext(ctx);
+		return (await this.packageModel.create([{
+			organizationId: ctx.organizationId,
+			name: input.name ?? `PKG-${Date.now()}`,
+			barcode: input.barcode ?? `PKG-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+			packageTypeId: input.packageTypeId,
+			parentPackageId: input.parentPackageId,
+			locationId: input.locationId,
+			baseWeight: input.baseWeight ?? 0,
+			maxWeight: input.maxWeight,
+			packageUse: input.packageUse ?? "disposable"
+		}]))[0].toObject();
+	}
+	async nest(childId, parentId, ctx) {
+		assertTenantContext(ctx);
+		const updated = await this.packageModel.findOneAndUpdate({
+			_id: childId,
+			organizationId: ctx.organizationId
+		}, { $set: { parentPackageId: parentId } }, { returnDocument: "after" }).lean();
+		if (!updated) throw new Error(`Package ${childId} not found`);
+		return updated;
+	}
+	async unnest(childId, ctx) {
+		assertTenantContext(ctx);
+		const updated = await this.packageModel.findOneAndUpdate({
+			_id: childId,
+			organizationId: ctx.organizationId
+		}, { $unset: { parentPackageId: 1 } }, { returnDocument: "after" }).lean();
+		if (!updated) throw new Error(`Package ${childId} not found`);
+		return updated;
+	}
+	async getContents(packageId, ctx) {
+		assertTenantContext(ctx);
+		const pkg = await this.packageModel.findOne({
+			_id: packageId,
+			organizationId: ctx.organizationId
+		}).lean();
+		if (!pkg) throw new Error(`Package ${packageId} not found`);
+		return {
+			package: pkg,
+			childPackages: await this.packageModel.find({
+				parentPackageId: packageId,
+				organizationId: ctx.organizationId
+			}).lean(),
+			allQuants: (pkg.locationId ? await this.quantPort.findMany({
+				organizationId: ctx.organizationId,
+				locationId: pkg.locationId
+			}, ctx) : []).map((q) => ({
+				skuRef: q.skuRef,
+				locationId: q.locationId,
+				quantity: q.quantityOnHand
+			}))
+		};
+	}
+	async getWeight(packageId, ctx) {
+		assertTenantContext(ctx);
+		const pkg = await this.packageModel.findOne({
+			_id: packageId,
+			organizationId: ctx.organizationId
+		}).lean();
+		if (!pkg) throw new Error(`Package ${packageId} not found`);
+		const children = await this.packageModel.find({
+			parentPackageId: packageId,
+			organizationId: ctx.organizationId
+		}).lean();
+		let contentWeight = 0;
+		for (const child of children) {
+			const childWeight = await this.getWeight(child._id.toString(), ctx);
+			contentWeight += childWeight.totalWeight;
+		}
+		const baseWeight = pkg.baseWeight ?? 0;
+		return {
+			baseWeight,
+			contentWeight,
+			totalWeight: baseWeight + contentWeight
+		};
+	}
+	async findByBarcode(barcode, ctx) {
+		assertTenantContext(ctx);
+		return await this.packageModel.findOne({
+			barcode,
+			organizationId: ctx.organizationId
+		}).lean();
+	}
+};
+//#endregion
+export { PackageService as t };

package/dist/package.service-C605NaBQ.d.mts

@@ -0,0 +1,42 @@
+import { t as FlowContext } from "./index-DFF0GJ4J.mjs";
+import { t as StockPackage } from "./stock-package-BIarxbDS.mjs";
+import { r as QuantPort } from "./quant.port-BBa66PBT.mjs";
+import { Model } from "mongoose";
+
+//#region src/services/package.service.d.ts
+interface CreatePackageInput {
+  name?: string;
+  barcode?: string;
+  packageTypeId?: string;
+  parentPackageId?: string;
+  locationId?: string;
+  baseWeight?: number;
+  maxWeight?: number;
+  packageUse?: 'disposable' | 'reusable';
+}
+interface PackageContents {
+  package: StockPackage;
+  childPackages: StockPackage[];
+  allQuants: Array<{
+    skuRef: string;
+    locationId: string;
+    quantity: number;
+  }>;
+}
+declare class PackageService {
+  private packageModel;
+  private quantPort;
+  constructor(packageModel: Model<any>, quantPort: QuantPort);
+  create(input: CreatePackageInput, ctx: FlowContext): Promise<StockPackage>;
+  nest(childId: string, parentId: string, ctx: FlowContext): Promise<StockPackage>;
+  unnest(childId: string, ctx: FlowContext): Promise<StockPackage>;
+  getContents(packageId: string, ctx: FlowContext): Promise<PackageContents>;
+  getWeight(packageId: string, ctx: FlowContext): Promise<{
+    baseWeight: number;
+    contentWeight: number;
+    totalWeight: number;
+  }>;
+  findByBarcode(barcode: string, ctx: FlowContext): Promise<StockPackage | null>;
+}
+//#endregion
+export { PackageContents as n, PackageService as r, CreatePackageInput as t };

package/dist/packaging/index.d.mts

@@ -0,0 +1,2 @@
+import { n as PackageContents, r as PackageService, t as CreatePackageInput } from "../package.service-C605NaBQ.mjs";
+export { type CreatePackageInput, type PackageContents, PackageService };

package/dist/packaging/index.mjs

@@ -0,0 +1,2 @@
+import { t as PackageService } from "../package.service-4tcAwBbr.mjs";
+export { PackageService };

package/dist/procurement/index.d.mts

@@ -0,0 +1,2 @@
+import { a as CreateProcurementInput, i as ReplenishmentTrigger, n as ReplenishmentScope, o as ProcurementService, r as ReplenishmentService, s as ReceivePayload, t as ReplenishmentEvaluation } from "../replenishment.service-HO0sDhB_.mjs";
+export { type CreateProcurementInput, ProcurementService, type ReceivePayload, type ReplenishmentEvaluation, type ReplenishmentScope, ReplenishmentService, type ReplenishmentTrigger };

package/dist/procurement/index.mjs

@@ -0,0 +1,2 @@
+import { n as ProcurementService, t as ReplenishmentService } from "../replenishment.service-BT9P-HKM.mjs";
+export { ProcurementService, ReplenishmentService };

package/dist/quant.port-BBa66PBT.d.mts

@@ -0,0 +1,42 @@
+import { a as QueryOptions, t as FlowContext } from "./index-DFF0GJ4J.mjs";
+import { n as StockQuant, t as QuantIdentity } from "./stock-quant-CZhgvTu7.mjs";
+import { t as TransactionSession } from "./unit-of-work.port-CWEkrDKu.mjs";
+
+//#region src/domain/ports/quant.port.d.ts
+interface AvailabilityQuery {
+  skuRef?: string;
+  locationId?: string;
+  nodeId?: string;
+  lotId?: string;
+  stockStatus?: string;
+}
+interface Availability {
+  quantityOnHand: number;
+  quantityReserved: number;
+  quantityAvailable: number;
+  quantityIncoming: number;
+  quantityOutgoing: number;
+  breakdowns: StockQuant[];
+}
+interface QuantUpdate {
+  organizationId: string;
+  skuRef: string;
+  locationId: string;
+  lotId?: string;
+  ownerRef?: string;
+  stockStatus?: string;
+  quantityDelta: number;
+  reservedDelta?: number;
+  inDate?: Date;
+  unitCost?: number;
+}
+interface QuantPort {
+  getAvailability(query: AvailabilityQuery, ctx: FlowContext, session?: TransactionSession): Promise<Availability>;
+  upsert(update: QuantUpdate, session?: TransactionSession): Promise<StockQuant>;
+  batchUpsert?(updates: QuantUpdate[], session?: TransactionSession): Promise<void>;
+  findByIdentity(identity: QuantIdentity, session?: TransactionSession): Promise<StockQuant | null>;
+  findMany(filter: Record<string, unknown>, ctx: FlowContext, session?: TransactionSession, options?: QueryOptions): Promise<StockQuant[]>;
+  deleteAll(ctx: FlowContext, session?: TransactionSession): Promise<void>;
+}
+//#endregion
+export { QuantUpdate as i, AvailabilityQuery as n, QuantPort as r, Availability as t };

package/dist/removal-policy-BItBB8FD.d.mts

@@ -0,0 +1,29 @@
+import { n as StockQuant } from "./stock-quant-CZhgvTu7.mjs";
+import { n as AllocationResult } from "./allocation-policy-my_HfzdV.mjs";
+
+//#region src/domain/policies/putaway-policy.d.ts
+/**
+ * Putaway policy — decides where to store received goods.
+ */
+interface PutawayPolicy {
+  name: string;
+  resolve(skuRef: string, quantity: number, nodeId: string, context: {
+    lotId?: string;
+    vendorRef?: string;
+    skuCategory?: string;
+  }): Promise<{
+    locationId: string;
+  } | null>;
+}
+//#endregion
+//#region src/domain/policies/removal-policy.d.ts
+/**
+ * Removal policy — decides which physical stock to pick.
+ * Same shape as AllocationPolicy but used at pick time.
+ */
+interface RemovalPolicy {
+  name: string;
+  resolve(skuRef: string, quantity: number, candidates: StockQuant[]): AllocationResult;
+}
+//#endregion
+export { PutawayPolicy as n, RemovalPolicy as t };

package/dist/replenishment-rule.port-DnEYtbyD.d.mts

@@ -0,0 +1,78 @@
+import { a as QueryOptions, i as PaginatedResult, r as ListQuery, t as FlowContext } from "./index-DFF0GJ4J.mjs";
+import { t as TransactionSession } from "./unit-of-work.port-CWEkrDKu.mjs";
+
+//#region src/domain/entities/procurement-order.d.ts
+type ProcurementStatus = 'draft' | 'approved' | 'ordered' | 'partially_received' | 'received' | 'cancelled';
+interface ProcurementItem {
+  skuRef: string;
+  quantity: number;
+  quantityReceived: number;
+  unitCost: number;
+  expectedAt?: Date;
+}
+interface ProcurementOrder {
+  _id: string;
+  organizationId: string;
+  orderNumber: string;
+  vendorRef: string;
+  destinationNodeId: string;
+  destinationLocationId?: string;
+  status: ProcurementStatus;
+  items: ProcurementItem[];
+  expectedAt?: Date;
+  receivedAt?: Date;
+  sourceDemandRefs?: string[];
+  createdBy?: string;
+  modifiedBy?: string;
+  metadata?: Record<string, unknown>;
+  createdAt?: Date;
+  updatedAt?: Date;
+}
+//#endregion
+//#region src/domain/entities/replenishment-rule.d.ts
+interface ReplenishmentRule {
+  _id: string;
+  organizationId: string;
+  scopeType: 'organization' | 'node' | 'location';
+  scopeRef: string;
+  skuRef: string;
+  locationId?: string;
+  triggerType: 'reorder_point' | 'min_max' | 'scheduled';
+  reorderPoint: number;
+  targetLevel: number;
+  preferredSourceType?: 'vendor' | 'internal_transfer';
+  preferredSourceRef?: string;
+  procurementMode?: 'purchase' | 'transfer' | 'manufacture';
+  leadTimeDays?: number;
+  minOrderQty?: number;
+  maxOrderQty?: number;
+  multipleOf?: number;
+  safetyStock?: number;
+  enabled: boolean;
+  metadata?: Record<string, unknown>;
+  createdAt?: Date;
+  updatedAt?: Date;
+}
+//#endregion
+//#region src/domain/ports/procurement.port.d.ts
+interface ProcurementPort {
+  create(input: Omit<ProcurementOrder, '_id' | 'createdAt' | 'updatedAt'>, session?: TransactionSession): Promise<ProcurementOrder>;
+  findById(id: string, ctx: FlowContext, session?: TransactionSession): Promise<ProcurementOrder | null>;
+  updateStatus(id: string, status: ProcurementStatus, updates: Partial<ProcurementOrder>, session?: TransactionSession): Promise<ProcurementOrder>;
+  findMany(filter: Record<string, unknown>, ctx: FlowContext, session?: TransactionSession, options?: QueryOptions): Promise<ProcurementOrder[]>;
+  list(query: ListQuery, ctx: FlowContext, session?: TransactionSession): Promise<PaginatedResult<ProcurementOrder>>;
+}
+//#endregion
+//#region src/domain/ports/replenishment-rule.port.d.ts
+interface ReplenishmentRulePort {
+  findByNode(nodeId: string, ctx: FlowContext, session?: TransactionSession): Promise<ReplenishmentRule[]>;
+  findBySkuRef(skuRef: string, ctx: FlowContext, session?: TransactionSession): Promise<ReplenishmentRule[]>;
+  list(ctx: FlowContext, session?: TransactionSession): Promise<ReplenishmentRule[]>;
+  findMany(filter: Record<string, unknown>, ctx: FlowContext, session?: TransactionSession, options?: QueryOptions): Promise<ReplenishmentRule[]>;
+  create(input: Omit<ReplenishmentRule, '_id' | 'createdAt' | 'updatedAt'>, session?: TransactionSession): Promise<ReplenishmentRule>;
+  findById(id: string, ctx: FlowContext, session?: TransactionSession): Promise<ReplenishmentRule | null>;
+  delete(id: string, ctx: FlowContext, session?: TransactionSession): Promise<void>;
+  update(id: string, updates: Partial<ReplenishmentRule>, ctx: FlowContext, session?: TransactionSession): Promise<ReplenishmentRule>;
+}
+//#endregion
+export { ProcurementOrder as a, ProcurementItem as i, ProcurementPort as n, ProcurementStatus as o, ReplenishmentRule as r, ReplenishmentRulePort as t };