@classytic/commerce-sdk 0.1.2 → 0.2.1

package/dist/payments/api/payment.d.ts

@@ -0,0 +1,89 @@
+import { ApiResponse } from "../../core/api-factory.js";
+import { RejectPaymentPayload, RejectResult, VerificationResult, VerifyPaymentPayload } from "../types/payment.js";
+
+//#region src/payments/api/payment.d.ts
+interface FetchOptions {
+  cache?: RequestCache;
+  revalidate?: number;
+  tags?: string[];
+}
+/**
+ * Payment API for admin payment management
+ *
+ * Manual Payment Verification Flow:
+ * 1. Customer places order → Transaction created with status 'pending'
+ * 2. Customer pays via bKash/Nagad/bank transfer/cash
+ * 3. Admin verifies payment via verifyPayment() endpoint
+ * 4. Backend updates transaction to 'verified'
+ * 5. Order status auto-updates to 'confirmed', payment status to 'verified'
+ *
+ * Endpoints:
+ * - POST /webhooks/payments/manual/verify - Verify pending payment (superadmin)
+ * - POST /webhooks/payments/manual/reject - Reject pending payment (superadmin)
+ */
+declare class PaymentApi {
+  private baseUrl;
+  /**
+   * Verify a manual payment (Admin/Superadmin only)
+   * POST /webhooks/payments/manual/verify
+   *
+   * Use this when admin confirms a customer's manual payment
+   * (bKash, Nagad, bank transfer, cash, etc.)
+   *
+   * After verification:
+   * - Transaction status → 'verified'
+   * - Order payment status → 'verified'
+   * - Order status → 'confirmed' (if was 'pending')
+   *
+   * @example
+   * const result = await paymentApi.verifyPayment({
+   *   token: adminToken,
+   *   data: {
+   *     transactionId: '507f1f77bcf86cd799439011',
+   *     notes: 'Verified bKash payment TrxID: ABC123'
+   *   }
+   * });
+   */
+  verifyPayment({
+    token,
+    data,
+    options
+  }: {
+    token: string;
+    data: VerifyPaymentPayload;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<VerificationResult>>;
+  /**
+   * Reject a manual payment (Admin/Superadmin only)
+   * POST /webhooks/payments/manual/reject
+   *
+   * Use this when admin rejects a customer's payment claim
+   * (invalid reference, insufficient amount, fraud, etc.)
+   *
+   * After rejection:
+   * - Transaction status → 'failed'
+   * - Order payment status → 'failed'
+   * - Reason recorded in transaction
+   *
+   * @example
+   * const result = await paymentApi.rejectPayment({
+   *   token: adminToken,
+   *   data: {
+   *     transactionId: '507f1f77bcf86cd799439011',
+   *     reason: 'Invalid bKash TrxID - payment not found'
+   *   }
+   * });
+   */
+  rejectPayment({
+    token,
+    data,
+    options
+  }: {
+    token: string;
+    data: RejectPaymentPayload;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<RejectResult>>;
+}
+declare const paymentApi: PaymentApi;
+//#endregion
+export { PaymentApi, paymentApi };

package/dist/payments/api/payment.js

@@ -0,0 +1,93 @@
+import { handleApiRequest } from "../../core/api-handler.js";
+
+//#region src/payments/api/payment.ts
+/**
+* Payment API for admin payment management
+*
+* Manual Payment Verification Flow:
+* 1. Customer places order → Transaction created with status 'pending'
+* 2. Customer pays via bKash/Nagad/bank transfer/cash
+* 3. Admin verifies payment via verifyPayment() endpoint
+* 4. Backend updates transaction to 'verified'
+* 5. Order status auto-updates to 'confirmed', payment status to 'verified'
+*
+* Endpoints:
+* - POST /webhooks/payments/manual/verify - Verify pending payment (superadmin)
+* - POST /webhooks/payments/manual/reject - Reject pending payment (superadmin)
+*/
+var PaymentApi = class {
+	constructor() {
+		this.baseUrl = "/webhooks/payments";
+	}
+	/**
+	* Verify a manual payment (Admin/Superadmin only)
+	* POST /webhooks/payments/manual/verify
+	*
+	* Use this when admin confirms a customer's manual payment
+	* (bKash, Nagad, bank transfer, cash, etc.)
+	*
+	* After verification:
+	* - Transaction status → 'verified'
+	* - Order payment status → 'verified'
+	* - Order status → 'confirmed' (if was 'pending')
+	*
+	* @example
+	* const result = await paymentApi.verifyPayment({
+	*   token: adminToken,
+	*   data: {
+	*     transactionId: '507f1f77bcf86cd799439011',
+	*     notes: 'Verified bKash payment TrxID: ABC123'
+	*   }
+	* });
+	*/
+	async verifyPayment({ token, data, options = {} }) {
+		if (!data.transactionId) throw new Error("Transaction ID is required");
+		return handleApiRequest("POST", `${this.baseUrl}/manual/verify`, {
+			token,
+			body: {
+				transactionId: data.transactionId,
+				...data.notes && { notes: data.notes }
+			},
+			cache: "no-store",
+			...options
+		});
+	}
+	/**
+	* Reject a manual payment (Admin/Superadmin only)
+	* POST /webhooks/payments/manual/reject
+	*
+	* Use this when admin rejects a customer's payment claim
+	* (invalid reference, insufficient amount, fraud, etc.)
+	*
+	* After rejection:
+	* - Transaction status → 'failed'
+	* - Order payment status → 'failed'
+	* - Reason recorded in transaction
+	*
+	* @example
+	* const result = await paymentApi.rejectPayment({
+	*   token: adminToken,
+	*   data: {
+	*     transactionId: '507f1f77bcf86cd799439011',
+	*     reason: 'Invalid bKash TrxID - payment not found'
+	*   }
+	* });
+	*/
+	async rejectPayment({ token, data, options = {} }) {
+		if (!data.transactionId) throw new Error("Transaction ID is required");
+		if (!data.reason) throw new Error("Rejection reason is required");
+		return handleApiRequest("POST", `${this.baseUrl}/manual/reject`, {
+			token,
+			body: {
+				transactionId: data.transactionId,
+				reason: data.reason
+			},
+			cache: "no-store",
+			...options
+		});
+	}
+};
+const paymentApi = new PaymentApi();
+
+//#endregion
+export { PaymentApi, paymentApi };

package/dist/payments/hooks/payment.d.ts

@@ -0,0 +1,53 @@
+import { RejectPaymentPayload, RejectResult, VerificationResult, VerifyPaymentPayload } from "../types/payment.js";
+
+//#region src/payments/hooks/payment.d.ts
+interface UsePaymentActionsReturn {
+  verifyPayment: (data: VerifyPaymentPayload) => Promise<VerificationResult>;
+  isVerifying: boolean;
+  rejectPayment: (data: RejectPaymentPayload) => Promise<RejectResult>;
+  isRejecting: boolean;
+  isLoading: boolean;
+}
+/**
+ * Payment verification actions for admin
+ *
+ * Manual Payment Verification Flow:
+ * 1. Customer places order → Transaction created with status 'pending'
+ * 2. Customer pays via bKash/Nagad/bank transfer/cash
+ * 3. Admin verifies payment via verifyPayment()
+ * 4. Backend updates transaction to 'verified'
+ * 5. Order status auto-updates to 'confirmed', payment status to 'verified'
+ *
+ * @param token - Auth token (admin/superadmin)
+ *
+ * @example
+ * ```tsx
+ * function PaymentVerifier({ transaction }) {
+ *   const { verifyPayment, rejectPayment, isLoading } = usePaymentActions(token);
+ *
+ *   const handleVerify = async () => {
+ *     await verifyPayment({
+ *       transactionId: transaction._id,
+ *       notes: 'Verified bKash payment TrxID: ABC123',
+ *     });
+ *   };
+ *
+ *   const handleReject = async () => {
+ *     await rejectPayment({
+ *       transactionId: transaction._id,
+ *       reason: 'Invalid bKash TrxID - payment not found',
+ *     });
+ *   };
+ *
+ *   return (
+ *     <>
+ *       <Button onClick={handleVerify} disabled={isLoading}>Verify</Button>
+ *       <Button onClick={handleReject} disabled={isLoading}>Reject</Button>
+ *     </>
+ *   );
+ * }
+ * ```
+ */
+declare function usePaymentActions(token: string): UsePaymentActionsReturn;
+//#endregion
+export { UsePaymentActionsReturn, usePaymentActions };

package/dist/payments/hooks/payment.js

@@ -0,0 +1,93 @@
+"use client";
+
+import { getToastHandler } from "../../core/react/mutation.factory.js";
+import { paymentApi } from "../api/payment.js";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+
+//#region src/payments/hooks/payment.ts
+/**
+* Payment verification actions for admin
+*
+* Manual Payment Verification Flow:
+* 1. Customer places order → Transaction created with status 'pending'
+* 2. Customer pays via bKash/Nagad/bank transfer/cash
+* 3. Admin verifies payment via verifyPayment()
+* 4. Backend updates transaction to 'verified'
+* 5. Order status auto-updates to 'confirmed', payment status to 'verified'
+*
+* @param token - Auth token (admin/superadmin)
+*
+* @example
+* ```tsx
+* function PaymentVerifier({ transaction }) {
+*   const { verifyPayment, rejectPayment, isLoading } = usePaymentActions(token);
+*
+*   const handleVerify = async () => {
+*     await verifyPayment({
+*       transactionId: transaction._id,
+*       notes: 'Verified bKash payment TrxID: ABC123',
+*     });
+*   };
+*
+*   const handleReject = async () => {
+*     await rejectPayment({
+*       transactionId: transaction._id,
+*       reason: 'Invalid bKash TrxID - payment not found',
+*     });
+*   };
+*
+*   return (
+*     <>
+*       <Button onClick={handleVerify} disabled={isLoading}>Verify</Button>
+*       <Button onClick={handleReject} disabled={isLoading}>Reject</Button>
+*     </>
+*   );
+* }
+* ```
+*/
+function usePaymentActions(token) {
+	const queryClient = useQueryClient();
+	const toast = getToastHandler();
+	const verifyMutation = useMutation({
+		mutationFn: (data) => paymentApi.verifyPayment({
+			token,
+			data
+		}),
+		onSuccess: () => {
+			toast.success("Payment verified successfully");
+			queryClient.invalidateQueries({ queryKey: ["orders"] });
+			queryClient.invalidateQueries({ queryKey: ["transactions"] });
+		},
+		onError: (error) => {
+			toast.error(error.message || "Failed to verify payment");
+		}
+	});
+	const rejectMutation = useMutation({
+		mutationFn: (data) => paymentApi.rejectPayment({
+			token,
+			data
+		}),
+		onSuccess: () => {
+			toast.success("Payment rejected");
+			queryClient.invalidateQueries({ queryKey: ["orders"] });
+			queryClient.invalidateQueries({ queryKey: ["transactions"] });
+		},
+		onError: (error) => {
+			toast.error(error.message || "Failed to reject payment");
+		}
+	});
+	return {
+		verifyPayment: async (data) => {
+			return (await verifyMutation.mutateAsync(data)).data;
+		},
+		isVerifying: verifyMutation.isPending,
+		rejectPayment: async (data) => {
+			return (await rejectMutation.mutateAsync(data)).data;
+		},
+		isRejecting: rejectMutation.isPending,
+		isLoading: verifyMutation.isPending || rejectMutation.isPending
+	};
+}
+
+//#endregion
+export { usePaymentActions };

package/dist/payments/index.d.ts

@@ -1,55 +1,4 @@
-import { a as VerifyPaymentPayload, V as VerificationResult, b as RejectPaymentPayload, R as RejectResult } from '../payment-BRboLqvU.js';
-export { P as PaymentApi, T as TransactionEntity, p as paymentApi } from '../payment-BRboLqvU.js';
-import '../api-factory-B_h4RKBm.js';
-
-interface UsePaymentActionsReturn {
-    verifyPayment: (data: VerifyPaymentPayload) => Promise<VerificationResult>;
-    isVerifying: boolean;
-    rejectPayment: (data: RejectPaymentPayload) => Promise<RejectResult>;
-    isRejecting: boolean;
-    isLoading: boolean;
-}
-
-/**
- * Payment verification actions for admin
- *
- * Manual Payment Verification Flow:
- * 1. Customer places order → Transaction created with status 'pending'
- * 2. Customer pays via bKash/Nagad/bank transfer/cash
- * 3. Admin verifies payment via verifyPayment()
- * 4. Backend updates transaction to 'verified'
- * 5. Order status auto-updates to 'confirmed', payment status to 'verified'
- *
- * @param token - Auth token (admin/superadmin)
- *
- * @example
- * ```tsx
- * function PaymentVerifier({ transaction }) {
- *   const { verifyPayment, rejectPayment, isLoading } = usePaymentActions(token);
- *
- *   const handleVerify = async () => {
- *     await verifyPayment({
- *       transactionId: transaction._id,
- *       notes: 'Verified bKash payment TrxID: ABC123',
- *     });
- *   };
- *
- *   const handleReject = async () => {
- *     await rejectPayment({
- *       transactionId: transaction._id,
- *       reason: 'Invalid bKash TrxID - payment not found',
- *     });
- *   };
- *
- *   return (
- *     <>
- *       <Button onClick={handleVerify} disabled={isLoading}>Verify</Button>
- *       <Button onClick={handleReject} disabled={isLoading}>Reject</Button>
- *     </>
- *   );
- * }
- * ```
- */
-declare function usePaymentActions(token: string): UsePaymentActionsReturn;
-
-export { RejectPaymentPayload, RejectResult, type UsePaymentActionsReturn, VerificationResult, VerifyPaymentPayload, usePaymentActions };
+import { RejectPaymentPayload, RejectResult, TransactionEntity, VerificationResult, VerifyPaymentPayload } from "./types/payment.js";
+import { PaymentApi, paymentApi } from "./api/payment.js";
+import { UsePaymentActionsReturn, usePaymentActions } from "./hooks/payment.js";
+export { PaymentApi, type RejectPaymentPayload, type RejectResult, type TransactionEntity, type UsePaymentActionsReturn, type VerificationResult, type VerifyPaymentPayload, paymentApi, usePaymentActions };

package/dist/payments/index.js

@@ -1,6 +1,4 @@
-"use client";
-export { PaymentApi, paymentApi, usePaymentActions } from '../chunk-5E57JODA.js';
-import '../chunk-U3XT35GZ.js';
-import '../chunk-IHCBBLLW.js';
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map
+import { PaymentApi, paymentApi } from "./api/payment.js";
+import { usePaymentActions } from "./hooks/payment.js";
+
+export { PaymentApi, paymentApi, usePaymentActions };

package/dist/payments/types/payment.d.ts

@@ -0,0 +1,50 @@
+//#region src/payments/types/payment.d.ts
+type PaymentStatus = "pending" | "verified" | "failed" | "refunded" | "partially_refunded" | "cancelled";
+/**
+ * Transaction reference info
+ */
+interface TransactionEntity {
+  referenceModel: "Order";
+  referenceId: string;
+}
+/**
+ * Verification result returned from backend
+ */
+interface VerificationResult {
+  transactionId: string;
+  status: PaymentStatus;
+  amount: number;
+  category: string;
+  verifiedAt: string;
+  verifiedBy: string;
+  entity: TransactionEntity | null;
+}
+/**
+ * Reject result returned from backend
+ */
+interface RejectResult {
+  transactionId: string;
+  status: "failed";
+  failedAt: string;
+  failureReason: string;
+}
+/**
+ * Verify payment request payload
+ */
+interface VerifyPaymentPayload {
+  /** Transaction ID (MongoDB ObjectId) */
+  transactionId: string;
+  /** Optional verification notes */
+  notes?: string;
+}
+/**
+ * Reject payment request payload
+ */
+interface RejectPaymentPayload {
+  /** Transaction ID (MongoDB ObjectId) */
+  transactionId: string;
+  /** Reason for rejection */
+  reason: string;
+}
+//#endregion
+export { RejectPaymentPayload, RejectResult, TransactionEntity, VerificationResult, VerifyPaymentPayload };

package/dist/permissions/checker.d.ts

@@ -0,0 +1,125 @@
+//#region src/permissions/checker.d.ts
+/**
+ * Permission Checker — client-side RBAC resolution.
+ *
+ * Mirrors be-prod/src/config/permissions/ exactly.
+ * Takes allRoles (system + branch member role) and returns flat can* booleans.
+ *
+ * Usage:
+ *   const { allRoles } = useBranch();
+ *   const can = createPermissionChecker(allRoles);
+ *   if (can.products.delete) { ... }
+ */
+type BranchHierarchyRole = "head_office" | "sub_branch";
+interface BranchContext {
+  /** Inventory hierarchy: head_office or sub_branch */
+  branchRole?: BranchHierarchyRole | string;
+}
+type StockAdjustmentCapability = {
+  mode: "none";
+  reason: string;
+} | {
+  mode: "set_any";
+} | {
+  mode: "set_decrease_only";
+  max: number;
+  reason: string;
+};
+declare function getStockAdjustmentCapability(userRoles: string[], branch: BranchContext | null, currentStock: number): StockAdjustmentCapability;
+interface Permissions {
+  isAdmin: boolean;
+  isSuperAdmin: boolean;
+  products: {
+    list: boolean;
+    create: boolean;
+    update: boolean;
+    delete: boolean;
+    syncStock: boolean;
+  };
+  categories: {
+    list: boolean;
+    create: boolean;
+    delete: boolean;
+  };
+  orders: {
+    list: boolean;
+    create: boolean;
+    updateStatus: boolean;
+    cancel: boolean;
+    delete: boolean;
+  };
+  customers: {
+    list: boolean;
+    create: boolean;
+    delete: boolean;
+  };
+  promos: {
+    list: boolean;
+    create: boolean;
+    delete: boolean;
+  };
+  users: {
+    list: boolean;
+    create: boolean;
+    update: boolean;
+    delete: boolean;
+  };
+  branches: {
+    list: boolean;
+    create: boolean;
+    update: boolean;
+    delete: boolean;
+  };
+  pos: {
+    access: boolean;
+  };
+  inventory: {
+    view: boolean;
+    viewAll: boolean;
+    adjust: boolean;
+    purchase: boolean;
+    purchaseView: boolean;
+    transferCreate: boolean;
+    transferReceive: boolean;
+    transferView: boolean;
+    stockRequestCreate: boolean;
+    stockRequestApprove: boolean;
+    supplierManage: boolean;
+    supplierView: boolean;
+    movements: boolean;
+    lotManage: boolean;
+    lotView: boolean;
+    packageManage: boolean;
+    packageView: boolean;
+    procurementCreate: boolean;
+    procurementView: boolean;
+    replenishmentManage: boolean;
+    replenishmentView: boolean;
+    costView: boolean;
+    traceView: boolean;
+    reportView: boolean;
+  };
+  finance: {
+    view: boolean;
+    manage: boolean;
+  };
+  accounting: {
+    view: boolean;
+    manage: boolean;
+  };
+  loyalty: {
+    view: boolean;
+    manage: boolean;
+  };
+  media: {
+    view: boolean;
+    manage: boolean;
+  };
+  cms: {
+    view: boolean;
+    manage: boolean;
+  };
+}
+declare function createPermissionChecker(allRoles: string[]): Permissions;
+//#endregion
+export { BranchContext, Permissions, StockAdjustmentCapability, createPermissionChecker, getStockAdjustmentCapability };