@classytic/commerce-sdk 0.1.2 → 0.2.1

package/dist/inventory/api/movement.js

@@ -0,0 +1,75 @@
+import { handleApiRequest } from "../../core/api-handler.js";
+import { BaseApi } from "../../core/api-factory.js";
+
+//#region src/inventory/api/movement.ts
+/**
+* Movement API - Stock Audit Trail
+*
+* Every stock change creates an immutable StockMovement record.
+* Types: purchase, sale, return, adjustment, transfer_in, transfer_out, initial, recount
+*/
+var MovementApi = class extends BaseApi {
+	constructor(config = {}) {
+		super("inventory/movements", config);
+	}
+	/**
+	* Get stock movements (audit trail)
+	* GET /inventory/movements
+	*
+	* @param params - Filters (productId, branchId, type, startDate, endDate, page, limit, sort, after/cursor)
+	*/
+	async list({ token, params = {}, options = {} }) {
+		const processedParams = this.prepareParams(params);
+		const queryString = this.createQueryString(processedParams);
+		return handleApiRequest("GET", `${this.baseUrl}?${queryString}`, {
+			token,
+			cache: this.config.cache,
+			...options
+		});
+	}
+	/**
+	* Get movements by type
+	* GET /inventory/movements?type=<type>
+	*/
+	async listByType({ token, type, params = {}, options = {} }) {
+		return this.list({
+			token,
+			params: {
+				...params,
+				type
+			},
+			options
+		});
+	}
+	/**
+	* Get movements for a specific product
+	* GET /inventory/movements?productId=<id>
+	*/
+	async listByProduct({ token, productId, params = {}, options = {} }) {
+		return this.list({
+			token,
+			params: {
+				...params,
+				productId
+			},
+			options
+		});
+	}
+	/**
+	* Get low stock items
+	* GET /inventory/low-stock
+	*/
+	async lowStock({ token, params = {}, options = {} }) {
+		const processedParams = this.prepareParams(params);
+		const queryString = this.createQueryString(processedParams);
+		return handleApiRequest("GET", `${this.baseUrl.replace("/movements", "/low-stock")}?${queryString}`, {
+			token,
+			cache: this.config.cache,
+			...options
+		});
+	}
+};
+const movementApi = new MovementApi();
+
+//#endregion
+export { MovementApi, movementApi };

package/dist/inventory/api/package.d.ts

@@ -0,0 +1,97 @@
+import { ApiResponse, BaseApi, RequestOptions } from "../../core/api-factory.js";
+
+//#region src/inventory/api/package.d.ts
+type FetchOptions = Omit<RequestOptions, "token" | "organizationId">;
+interface StockPackage {
+  _id: string;
+  organizationId: string;
+  barcode: string;
+  parentPackageId?: string;
+  locationId?: string;
+  packageType?: "reusable" | "disposable";
+  baseWeight?: number;
+  maxWeight?: number;
+  status?: string;
+}
+interface PackageContents {
+  children: StockPackage[];
+  quants: Array<{
+    skuRef: string;
+    quantityOnHand: number;
+  }>;
+  totalWeight?: number;
+}
+interface CreatePackagePayload {
+  barcode?: string;
+  locationId?: string;
+  packageType?: "reusable" | "disposable";
+  baseWeight?: number;
+  maxWeight?: number;
+  metadata?: Record<string, unknown>;
+}
+declare class PackageApi extends BaseApi<StockPackage, CreatePackagePayload, Partial<CreatePackagePayload>> {
+  constructor(config?: {});
+  list({
+    token,
+    locationId,
+    options
+  }: {
+    token: string;
+    locationId?: string;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<StockPackage[]>>;
+  getById({
+    token,
+    id,
+    options
+  }: {
+    token: string;
+    id: string;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<StockPackage>>;
+  create({
+    token,
+    data,
+    options
+  }: {
+    token: string;
+    data: CreatePackagePayload;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<StockPackage>>;
+  getContents({
+    token,
+    id,
+    options
+  }: {
+    token: string;
+    id: string;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<PackageContents>>;
+  nest({
+    token,
+    id,
+    childPackageId,
+    options
+  }: {
+    token: string;
+    id: string;
+    childPackageId: string;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<{
+    nested: boolean;
+  }>>;
+  unnest({
+    token,
+    id,
+    options
+  }: {
+    token: string;
+    id: string;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<{
+    unnested: boolean;
+  }>>;
+}
+declare const packageApi: PackageApi;
+//#endregion
+export { CreatePackagePayload, PackageApi, PackageContents, StockPackage, packageApi };

package/dist/inventory/api/package.js

@@ -0,0 +1,56 @@
+import { handleApiRequest } from "../../core/api-handler.js";
+import { BaseApi } from "../../core/api-factory.js";
+
+//#region src/inventory/api/package.ts
+/**
+* Package Management API — Flow-native container management (Standard+)
+*/
+var PackageApi = class extends BaseApi {
+	constructor(config = {}) {
+		super("inventory/packages", config);
+	}
+	async list({ token, locationId, options = {} }) {
+		const params = new URLSearchParams();
+		if (locationId) params.set("locationId", locationId);
+		return handleApiRequest("GET", `${this.baseUrl}?${params}`, {
+			token,
+			...options
+		});
+	}
+	async getById({ token, id, options = {} }) {
+		return handleApiRequest("GET", `${this.baseUrl}/${id}`, {
+			token,
+			...options
+		});
+	}
+	async create({ token, data, options = {} }) {
+		return handleApiRequest("POST", this.baseUrl, {
+			token,
+			body: data,
+			...options
+		});
+	}
+	async getContents({ token, id, options = {} }) {
+		return handleApiRequest("GET", `${this.baseUrl}/${id}/contents`, {
+			token,
+			...options
+		});
+	}
+	async nest({ token, id, childPackageId, options = {} }) {
+		return handleApiRequest("POST", `${this.baseUrl}/${id}/nest`, {
+			token,
+			body: { childPackageId },
+			...options
+		});
+	}
+	async unnest({ token, id, options = {} }) {
+		return handleApiRequest("POST", `${this.baseUrl}/${id}/unnest`, {
+			token,
+			...options
+		});
+	}
+};
+const packageApi = new PackageApi();
+
+//#endregion
+export { PackageApi, packageApi };

package/dist/inventory/api/procurement.d.ts

@@ -0,0 +1,110 @@
+import { ApiResponse, BaseApi, RequestOptions } from "../../core/api-factory.js";
+
+//#region src/inventory/api/procurement.d.ts
+type FetchOptions = Omit<RequestOptions, "token" | "organizationId">;
+interface ProcurementItem {
+  skuRef: string;
+  quantity: number;
+  quantityReceived?: number;
+  unitCost?: number;
+  expectedDate?: string;
+  lotCode?: string;
+}
+interface ProcurementOrder {
+  _id: string;
+  organizationId: string;
+  documentNumber: string;
+  vendorRef?: string;
+  status: "draft" | "approved" | "ordered" | "partially_received" | "received" | "cancelled";
+  items: ProcurementItem[];
+  destinationNodeId?: string;
+  destinationLocationId?: string;
+  notes?: string;
+  createdAt?: string;
+  updatedAt?: string;
+}
+interface CreateProcurementPayload {
+  vendorRef?: string;
+  items: Array<{
+    skuRef: string;
+    quantity: number;
+    unitCost?: number;
+    expectedDate?: string;
+    lotCode?: string;
+  }>;
+  destinationNodeId?: string;
+  destinationLocationId?: string;
+  notes?: string;
+}
+interface ReceiveProcurementPayload {
+  items: Array<{
+    skuRef: string;
+    quantity: number;
+    lotCode?: string;
+  }>;
+  locationId?: string;
+}
+declare class ProcurementApi extends BaseApi<ProcurementOrder, CreateProcurementPayload, Partial<CreateProcurementPayload>> {
+  constructor(config?: {});
+  list({
+    token,
+    status,
+    vendorRef,
+    options
+  }: {
+    token: string;
+    status?: string;
+    vendorRef?: string;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<ProcurementOrder[]>>;
+  getById({
+    token,
+    id,
+    options
+  }: {
+    token: string;
+    id: string;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<ProcurementOrder>>;
+  create({
+    token,
+    data,
+    options
+  }: {
+    token: string;
+    data: CreateProcurementPayload;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<ProcurementOrder>>;
+  receive({
+    token,
+    id,
+    data,
+    options
+  }: {
+    token: string;
+    id: string;
+    data: ReceiveProcurementPayload;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<ProcurementOrder>>;
+  approve({
+    token,
+    id,
+    options
+  }: {
+    token: string;
+    id: string;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<ProcurementOrder>>;
+  cancel({
+    token,
+    id,
+    options
+  }: {
+    token: string;
+    id: string;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<ProcurementOrder>>;
+}
+declare const procurementApi: ProcurementApi;
+//#endregion
+export { CreateProcurementPayload, ProcurementApi, ProcurementItem, ProcurementOrder, ReceiveProcurementPayload, procurementApi };

package/dist/inventory/api/procurement.js

@@ -0,0 +1,59 @@
+import { handleApiRequest } from "../../core/api-handler.js";
+import { BaseApi } from "../../core/api-factory.js";
+
+//#region src/inventory/api/procurement.ts
+/**
+* Procurement API — Flow-native procurement orders (Standard+)
+*/
+var ProcurementApi = class extends BaseApi {
+	constructor(config = {}) {
+		super("inventory/procurement", config);
+	}
+	async list({ token, status, vendorRef, options = {} }) {
+		const params = new URLSearchParams();
+		if (status) params.set("status", status);
+		if (vendorRef) params.set("vendorRef", vendorRef);
+		return handleApiRequest("GET", `${this.baseUrl}?${params}`, {
+			token,
+			...options
+		});
+	}
+	async getById({ token, id, options = {} }) {
+		return handleApiRequest("GET", `${this.baseUrl}/${id}`, {
+			token,
+			...options
+		});
+	}
+	async create({ token, data, options = {} }) {
+		return handleApiRequest("POST", this.baseUrl, {
+			token,
+			body: data,
+			...options
+		});
+	}
+	async receive({ token, id, data, options = {} }) {
+		return handleApiRequest("POST", `${this.baseUrl}/${id}/receive`, {
+			token,
+			body: data,
+			...options
+		});
+	}
+	async approve({ token, id, options = {} }) {
+		return handleApiRequest("POST", `${this.baseUrl}/${id}/action`, {
+			token,
+			body: { action: "approve" },
+			...options
+		});
+	}
+	async cancel({ token, id, options = {} }) {
+		return handleApiRequest("POST", `${this.baseUrl}/${id}/action`, {
+			token,
+			body: { action: "cancel" },
+			...options
+		});
+	}
+};
+const procurementApi = new ProcurementApi();
+
+//#endregion
+export { ProcurementApi, procurementApi };

package/dist/inventory/api/purchase.d.ts

@@ -0,0 +1,106 @@
+import { ApiResponse, BaseApi, RequestOptions } from "../../core/api-factory.js";
+import { CreatePurchasePayload, Purchase, PurchaseActionType, StockEntry, StockMovement, UpdatePurchasePayload } from "../types/inventory.js";
+//#region src/inventory/api/purchase.d.ts
+type FetchOptions = Omit<RequestOptions, "token" | "organizationId">;
+declare class PurchaseApi extends BaseApi<Purchase, CreatePurchasePayload, UpdatePurchasePayload> {
+  constructor(config?: {});
+  /**
+   * Perform a purchase action (receive/pay/cancel)
+   * POST /inventory/purchases/:id/action
+   */
+  action({
+    token,
+    id,
+    action,
+    data,
+    options
+  }: {
+    token: string;
+    id: string;
+    action: PurchaseActionType;
+    data?: Record<string, unknown>;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<Purchase>>;
+  /**
+   * Receive a purchase (auto-approves draft and creates stock movements)
+   * POST /inventory/purchases/:id/action { action: 'receive' }
+   */
+  receive({
+    token,
+    id,
+    options
+  }: {
+    token: string;
+    id: string;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<Purchase>>;
+  /**
+   * Record payment for a purchase
+   * POST /inventory/purchases/:id/action { action: 'pay', amount, method, reference }
+   */
+  pay({
+    token,
+    id,
+    amount,
+    method,
+    reference,
+    accountNumber,
+    walletNumber,
+    bankName,
+    accountName,
+    proofUrl,
+    transactionDate,
+    notes,
+    options
+  }: {
+    token: string;
+    id: string;
+    amount: number;
+    method: string;
+    reference?: string;
+    accountNumber?: string;
+    walletNumber?: string;
+    bankName?: string;
+    accountName?: string;
+    proofUrl?: string;
+    transactionDate?: string;
+    notes?: string;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<Purchase>>;
+  /**
+   * Cancel a purchase (draft or approved only)
+   * POST /inventory/purchases/:id/action { action: 'cancel', reason }
+   */
+  cancel({
+    token,
+    id,
+    reason,
+    options
+  }: {
+    token: string;
+    id: string;
+    reason?: string;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<Purchase>>;
+  /**
+   * Record a stock purchase (legacy method)
+   * Creates and optionally auto-receives a purchase
+   *
+   * @deprecated Use create() with autoReceive: true instead
+   */
+  recordPurchase({
+    token,
+    data,
+    options
+  }: {
+    token: string;
+    data: CreatePurchasePayload;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<{
+    stockEntries: StockEntry[];
+    movements: StockMovement[];
+  }>>;
+}
+declare const purchaseApi: PurchaseApi;
+//#endregion
+export { PurchaseApi, purchaseApi };

package/dist/inventory/api/purchase.js

@@ -0,0 +1,115 @@
+import { handleApiRequest } from "../../core/api-handler.js";
+import { BaseApi } from "../../core/api-factory.js";
+
+//#region src/inventory/api/purchase.ts
+/**
+* Purchase API - Supplier Invoices & Stock Entry
+*
+* Base path: /api/v1/inventory/purchases
+*
+* Purchases are the only official way to bring new inventory into the system.
+* They are Head Office only and drive COGS (weighted average cost).
+*
+* Standard CRUD:
+* - create({ token, data }) - Create purchase invoice (draft)
+* - getAll({ token, params }) - List purchases with filtering
+* - getById({ token, id }) - Get purchase by ID
+* - update({ token, id, data }) - Update draft purchase
+*
+* Actions (Stripe pattern):
+* - receive({ token, id }) - Receive purchase (creates stock movements)
+* - pay({ token, id, amount, method, reference }) - Record payment
+* - cancel({ token, id, reason }) - Cancel draft/approved purchase
+*/
+var PurchaseApi = class extends BaseApi {
+	constructor(config = {}) {
+		super("inventory/purchases", config);
+	}
+	/**
+	* Perform a purchase action (receive/pay/cancel)
+	* POST /inventory/purchases/:id/action
+	*/
+	async action({ token, id, action, data = {}, options = {} }) {
+		if (!id) throw new Error("Purchase ID is required");
+		return handleApiRequest("POST", `${this.baseUrl}/${id}/action`, {
+			token,
+			body: {
+				action,
+				...data
+			},
+			cache: this.config.cache,
+			...options
+		});
+	}
+	/**
+	* Receive a purchase (auto-approves draft and creates stock movements)
+	* POST /inventory/purchases/:id/action { action: 'receive' }
+	*/
+	async receive({ token, id, options = {} }) {
+		return this.action({
+			token,
+			id,
+			action: "receive",
+			options
+		});
+	}
+	/**
+	* Record payment for a purchase
+	* POST /inventory/purchases/:id/action { action: 'pay', amount, method, reference }
+	*/
+	async pay({ token, id, amount, method, reference, accountNumber, walletNumber, bankName, accountName, proofUrl, transactionDate, notes, options = {} }) {
+		return this.action({
+			token,
+			id,
+			action: "pay",
+			data: {
+				amount,
+				method,
+				reference,
+				accountNumber,
+				walletNumber,
+				bankName,
+				accountName,
+				proofUrl,
+				transactionDate,
+				notes
+			},
+			options
+		});
+	}
+	/**
+	* Cancel a purchase (draft or approved only)
+	* POST /inventory/purchases/:id/action { action: 'cancel', reason }
+	*/
+	async cancel({ token, id, reason, options = {} }) {
+		return this.action({
+			token,
+			id,
+			action: "cancel",
+			data: { reason },
+			options
+		});
+	}
+	/**
+	* Record a stock purchase (legacy method)
+	* Creates and optionally auto-receives a purchase
+	*
+	* @deprecated Use create() with autoReceive: true instead
+	*/
+	async recordPurchase({ token, data, options = {} }) {
+		const payload = {
+			...data,
+			autoReceive: true
+		};
+		return handleApiRequest("POST", this.baseUrl, {
+			token,
+			body: payload,
+			cache: this.config.cache,
+			...options
+		});
+	}
+};
+const purchaseApi = new PurchaseApi();
+
+//#endregion
+export { PurchaseApi, purchaseApi };