@classytic/commerce-sdk 0.1.0

package/dist/chunk-OF5M6R2S.js

@@ -0,0 +1,769 @@
+import { BaseApi } from './chunk-I5TIKUIQ.js';
+import { createQueryKeys, createCrudHooks } from './chunk-B6MPVOV7.js';
+import { getToastHandler } from './chunk-U3XT35GZ.js';
+import { handleApiRequest } from './chunk-VR36QVX2.js';
+import { useQuery, useQueryClient, useMutation } from '@tanstack/react-query';
+
+// src/platform/api/config.ts
+var PlatformConfigApi = class {
+  constructor() {
+    this.baseUrl = "/api/v1/platform";
+  }
+  /**
+   * Get platform configuration
+   *
+   * @param options.token - Optional access token (public without, authenticated with)
+   * @param options.select - Optional field selection (e.g., "paymentMethods", "checkout,vat")
+   * @returns Platform configuration (full or selected fields)
+   *
+   * @example
+   * // Full config (public)
+   * const config = await platformConfigApi.getConfig({});
+   *
+   * // Selected fields (public)
+   * const config = await platformConfigApi.getConfig({ select: "paymentMethods" });
+   *
+   * // Authenticated (admin sees more fields)
+   * const config = await platformConfigApi.getConfig({ token, select: "checkout,vat" });
+   */
+  async getConfig({
+    token,
+    select
+  } = {}) {
+    const queryParams = select ? `?select=${select}` : "";
+    return handleApiRequest("GET", `${this.baseUrl}/config${queryParams}`, {
+      token: token ?? void 0,
+      cache: token ? "no-store" : "force-cache",
+      revalidate: token ? void 0 : 3600,
+      // 1 hour for public
+      tags: ["platform-config"]
+    });
+  }
+  /**
+   * Update platform configuration
+   *
+   * @param options.token - Admin access token (required)
+   * @param options.data - Configuration data to update (partial update)
+   * @returns Updated platform configuration
+   *
+   * @example
+   * // Update payment methods
+   * await platformConfigApi.updateConfig({
+   *   token,
+   *   data: {
+   *     paymentMethods: [
+   *       { type: 'cash', name: 'Cash on Delivery', isActive: true },
+   *       { type: 'mfs', provider: 'bkash', name: 'bKash', walletNumber: '01712345678' },
+   *     ]
+   *   }
+   * });
+   *
+   * // Update checkout settings
+   * await platformConfigApi.updateConfig({
+   *   token,
+   *   data: {
+   *     checkout: {
+   *       freeDeliveryThreshold: 2000,
+   *       deliveryZones: [
+   *         { name: 'Dhaka', region: 'dhaka', price: 60, estimatedDays: 2, isActive: true }
+   *       ]
+   *     }
+   *   }
+   * });
+   */
+  async updateConfig({
+    token,
+    data
+  }) {
+    if (!token) {
+      throw new Error("Authentication required to update platform config");
+    }
+    return handleApiRequest("PATCH", `${this.baseUrl}/config`, {
+      token,
+      body: data,
+      tags: ["platform-config"]
+    });
+  }
+  /**
+   * Get payment methods only
+   * Convenience method for checkout/POS
+   *
+   * @param options.token - Optional access token
+   * @returns Platform config with only paymentMethods field
+   */
+  async getPaymentMethods({
+    token
+  } = {}) {
+    return this.getConfig({ token, select: "paymentMethods" });
+  }
+  /**
+   * Get checkout settings only
+   * Convenience method for checkout flow
+   *
+   * @param options.token - Optional access token
+   * @returns Platform config with only checkout field
+   */
+  async getCheckoutSettings({
+    token
+  } = {}) {
+    return this.getConfig({ token, select: "checkout" });
+  }
+  /**
+   * Get delivery zones
+   * Convenience method for delivery selection
+   *
+   * @param options.token - Optional access token
+   * @returns Platform config with checkout.deliveryZones
+   */
+  async getDeliveryZones({
+    token
+  } = {}) {
+    return this.getConfig({ token, select: "checkout" });
+  }
+  /**
+   * Get VAT configuration
+   * Convenience method for invoice/tax calculations
+   *
+   * @param options.token - Optional access token
+   * @returns Platform config with only vat field
+   */
+  async getVatConfig({
+    token
+  } = {}) {
+    return this.getConfig({ token, select: "vat" });
+  }
+  /**
+   * Get membership configuration
+   * Convenience method for loyalty programs
+   *
+   * @param options.token - Optional access token
+   * @returns Platform config with only membership field
+   */
+  async getMembershipConfig({
+    token
+  } = {}) {
+    return this.getConfig({ token, select: "membership" });
+  }
+};
+var platformConfigApi = new PlatformConfigApi();
+var platformApi = platformConfigApi;
+var businessApi = platformConfigApi;
+
+// src/platform/api/branch.ts
+var BranchApi = class extends BaseApi {
+  constructor(config = {}) {
+    super("branches", config);
+  }
+  /**
+   * Get branch by code
+   * GET /branches/code/:code
+   *
+   * @example
+   * branchApi.getByCode({ token, code: 'DHK-1' })
+   */
+  async getByCode({
+    token,
+    code,
+    options = {}
+  }) {
+    if (!code) {
+      throw new Error("Branch code is required");
+    }
+    return handleApiRequest("GET", `${this.baseUrl}/code/${code}`, {
+      token,
+      cache: this.config.cache,
+      ...options
+    });
+  }
+  /**
+   * Get default branch (auto-creates if none exists)
+   * GET /branches/default
+   *
+   * @example
+   * branchApi.getDefault({ token })
+   */
+  async getDefault({
+    token,
+    options = {}
+  }) {
+    return handleApiRequest("GET", `${this.baseUrl}/default`, {
+      token,
+      cache: this.config.cache,
+      ...options
+    });
+  }
+  // For active branches, use: getAll({ token, params: { isActive: true } })
+  /**
+   * Set a branch as the default
+   * POST /branches/:id/set-default
+   *
+   * @example
+   * branchApi.setDefault({ token, id: '507f1f77bcf86cd799439011' })
+   */
+  async setDefault({
+    token,
+    id,
+    options = {}
+  }) {
+    if (!id) {
+      throw new Error("Branch ID is required");
+    }
+    return handleApiRequest("POST", `${this.baseUrl}/${id}/set-default`, {
+      token,
+      ...options
+    });
+  }
+};
+var branchApi = new BranchApi();
+
+// src/platform/api/user.ts
+var UserApi = class extends BaseApi {
+  constructor(config = {}) {
+    super("users", config);
+  }
+};
+var userApi = new UserApi();
+
+// src/platform/api/coupon.ts
+var CouponApi = class extends BaseApi {
+  constructor(config = {}) {
+    super("coupons", config);
+  }
+  /**
+   * Validate coupon by code with order amount
+   * POST /coupons/validate/:code
+   *
+   * @example
+   * const result = await couponApi.validateCoupon({
+   *   code: 'SUMMER20',
+   *   data: { orderAmount: 1500 }
+   * });
+   *
+   * if (result.data?.valid) {
+   *   console.log('Discount:', result.data.discountAmount);
+   * }
+   */
+  async validateCoupon({
+    code,
+    data,
+    options = {}
+  }) {
+    return handleApiRequest("POST", `${this.baseUrl}/validate/${code}`, {
+      cache: this.config.cache,
+      body: data,
+      ...options
+    });
+  }
+};
+var couponApi = new CouponApi();
+
+// src/platform/api/webhook.ts
+var WebhookApi = class {
+  constructor() {
+    this.baseUrl = "/webhooks/payments";
+  }
+  /**
+   * Verify a manual payment (superadmin only)
+   * POST /webhooks/payments/manual/verify
+   *
+   * Flow:
+   * 1. Customer places order with manual payment (cash, bKash, Nagad, bank)
+   * 2. Customer pays and provides transaction reference
+   * 3. Admin verifies payment via this endpoint
+   * 4. Transaction status -> 'verified'
+   * 5. Order payment status -> 'verified', order status -> 'confirmed'
+   *
+   * @param params.transactionId - Transaction ID to verify
+   * @param params.notes - Optional verification notes
+   * @param params.token - Auth token (superadmin required)
+   * @param params.options - Additional fetch options
+   * @returns Verification result with transaction details
+   *
+   * @example
+   * ```typescript
+   * const result = await webhookApi.verifyPayment({
+   *   token: adminToken,
+   *   transactionId: '507f1f77bcf86cd799439011',
+   *   notes: 'Verified bKash TrxID via app',
+   * });
+   * ```
+   */
+  async verifyPayment({
+    token,
+    transactionId,
+    notes,
+    options = {}
+  }) {
+    if (!transactionId) throw new Error("Transaction ID is required");
+    if (!token) throw new Error("Authentication required");
+    const body = { transactionId };
+    if (notes) body.notes = notes;
+    return handleApiRequest("POST", `${this.baseUrl}/manual/verify`, {
+      token,
+      body,
+      cache: "no-store",
+      ...options
+    });
+  }
+  /**
+   * Reject a manual payment (superadmin only)
+   * POST /webhooks/payments/manual/reject
+   *
+   * Flow:
+   * 1. Customer claims to have paid but admin finds issue
+   * 2. Admin rejects payment with reason via this endpoint
+   * 3. Transaction status -> 'failed', failureReason recorded
+   * 4. Order payment status -> 'failed'
+   *
+   * Common rejection reasons:
+   * - Invalid transaction reference
+   * - Amount mismatch
+   * - Duplicate claim
+   * - Suspected fraud
+   * - Payment not received
+   *
+   * @param params.transactionId - Transaction ID to reject
+   * @param params.reason - Rejection reason (required)
+   * @param params.token - Auth token (superadmin required)
+   * @param params.options - Additional fetch options
+   * @returns Rejection result with failure details
+   *
+   * @example
+   * ```typescript
+   * const result = await webhookApi.rejectPayment({
+   *   token: adminToken,
+   *   transactionId: '507f1f77bcf86cd799439011',
+   *   reason: 'Invalid bKash TrxID - no matching transaction found',
+   * });
+   * ```
+   */
+  async rejectPayment({
+    token,
+    transactionId,
+    reason,
+    options = {}
+  }) {
+    if (!transactionId) throw new Error("Transaction ID is required");
+    if (!reason) throw new Error("Rejection reason is required");
+    if (!token) throw new Error("Authentication required");
+    const body = { transactionId, reason };
+    return handleApiRequest("POST", `${this.baseUrl}/manual/reject`, {
+      token,
+      body,
+      cache: "no-store",
+      ...options
+    });
+  }
+  /**
+   * Alias for verifyPayment - more explicit naming
+   * @deprecated Use verifyPayment instead
+   */
+  async verifyManualPayment(params) {
+    return this.verifyPayment(params);
+  }
+  /**
+   * Alias for rejectPayment - more explicit naming
+   * @deprecated Use rejectPayment instead
+   */
+  async rejectManualPayment(params) {
+    return this.rejectPayment(params);
+  }
+};
+var webhookApi = new WebhookApi();
+
+// src/platform/api/export.ts
+var ExportApi = class {
+  constructor() {
+    this.basePath = "/api/v1/export";
+  }
+  /**
+   * Build query string from export parameters
+   */
+  buildQueryString(params) {
+    const searchParams = new URLSearchParams();
+    if (params.select) {
+      searchParams.append("select", params.select);
+    }
+    if (params.filter) {
+      const filterString = typeof params.filter === "string" ? params.filter : JSON.stringify(params.filter);
+      searchParams.append("filter", filterString);
+    }
+    return searchParams.toString();
+  }
+  /**
+   * Export data to CSV format
+   * GET /export/csv
+   *
+   * Returns CSV file as blob for download or processing.
+   *
+   * @example
+   * // Export all products
+   * const blob = await exportApi.toCSV({ token, collection: 'product' });
+   *
+   * // Export filtered transactions
+   * const blob = await exportApi.toCSV({
+   *   token,
+   *   collection: 'transaction',
+   *   filter: { status: 'verified' },
+   *   select: 'amount,method,status,createdAt'
+   * });
+   */
+  async toCSV({
+    token,
+    collection,
+    filter,
+    select,
+    options = {}
+  }) {
+    const params = this.buildQueryString({ filter, select });
+    const url = `${this.basePath}/csv?collection=${collection}${params ? `&${params}` : ""}`;
+    const response = await handleApiRequest("GET", url, {
+      token,
+      cache: "no-store",
+      ...options
+    });
+    return response.data;
+  }
+  /**
+   * Export data to XLSX (Excel) format
+   * GET /export/xlsx
+   *
+   * Returns Excel file as blob for download or processing.
+   *
+   * @example
+   * // Export stock movements
+   * const blob = await exportApi.toXLSX({
+   *   token,
+   *   collection: 'stockMovement',
+   *   filter: { type: 'sale', createdAt: { $gte: '2024-01-01' } }
+   * });
+   */
+  async toXLSX({
+    token,
+    collection,
+    filter,
+    select,
+    options = {}
+  }) {
+    const params = this.buildQueryString({ filter, select });
+    const url = `${this.basePath}/xlsx?collection=${collection}${params ? `&${params}` : ""}`;
+    const response = await handleApiRequest("GET", url, {
+      token,
+      cache: "no-store",
+      ...options
+    });
+    return response.data;
+  }
+  /**
+   * Export data with specified format
+   * Convenience method for format-agnostic exports
+   *
+   * @example
+   * const format = userPreference.exportFormat; // 'csv' | 'xlsx'
+   * const blob = await exportApi.export({
+   *   token,
+   *   format,
+   *   collection: 'customer',
+   *   select: 'name,phone,email'
+   * });
+   */
+  async export({
+    token,
+    format,
+    collection,
+    filter,
+    select,
+    options = {}
+  }) {
+    if (format === "csv") {
+      return this.toCSV({ token, collection, filter, select, options });
+    } else {
+      return this.toXLSX({ token, collection, filter, select, options });
+    }
+  }
+  /**
+   * Trigger browser download of blob
+   * Creates temporary link and clicks it to download file
+   *
+   * @example
+   * const blob = await exportApi.toCSV({ token, collection: 'product' });
+   * exportApi.downloadFile(blob, 'products.csv');
+   */
+  downloadFile(blob, filename) {
+    const url = window.URL.createObjectURL(blob);
+    const link = document.createElement("a");
+    link.href = url;
+    link.download = filename;
+    document.body.appendChild(link);
+    link.click();
+    document.body.removeChild(link);
+    window.URL.revokeObjectURL(url);
+  }
+  /**
+   * Get suggested filename based on collection and format
+   *
+   * @example
+   * const filename = exportApi.getSuggestedFilename('product', 'csv');
+   * // Returns: 'products-2024-12-11.csv'
+   */
+  getSuggestedFilename(collection, format) {
+    const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+    const collectionPlural = collection.endsWith("y") ? collection.slice(0, -1) + "ies" : collection + "s";
+    return `${collectionPlural}-${date}.${format}`;
+  }
+};
+var exportApi = new ExportApi();
+async function exportAndDownload({
+  token,
+  format,
+  collection,
+  filter,
+  select,
+  filename
+}) {
+  const blob = await exportApi.export({ token, format, collection, filter, select });
+  const finalFilename = filename || exportApi.getSuggestedFilename(collection, format);
+  exportApi.downloadFile(blob, finalFilename);
+}
+async function readCSVBlob(blob) {
+  return blob.text();
+}
+function parseCSV(csvText) {
+  const lines = csvText.trim().split("\n");
+  if (lines.length < 2) return [];
+  const headers = lines[0].split(",").map((h) => h.trim());
+  const data = [];
+  for (let i = 1; i < lines.length; i++) {
+    const values = lines[i].split(",").map((v) => v.trim());
+    const row = {};
+    headers.forEach((header, index) => {
+      row[header] = values[index] || "";
+    });
+    data.push(row);
+  }
+  return data;
+}
+var ExportFilters = {
+  /** Orders by date range */
+  ordersByDateRange: (startDate, endDate) => ({
+    createdAt: { $gte: startDate, $lte: endDate }
+  }),
+  /** Orders by status */
+  ordersByStatus: (status) => Array.isArray(status) ? { status: { $in: status } } : { status },
+  /** Transactions by date and status */
+  transactionsByDate: (startDate, endDate, status) => ({
+    transactionDate: { $gte: startDate, $lte: endDate },
+    ...status && { status }
+  }),
+  /** Stock movements by type and date */
+  movementsByType: (type, startDate, endDate) => ({
+    type,
+    ...startDate && endDate && { createdAt: { $gte: startDate, $lte: endDate } }
+  }),
+  /** Products by category */
+  productsByCategory: (category) => Array.isArray(category) ? { category: { $in: category } } : { category },
+  /** Customers with orders */
+  customersWithOrders: () => ({
+    "stats.totalOrders": { $gt: 0 }
+  })
+};
+var ExportFields = {
+  /** Product essentials */
+  productBasic: "name,sku,basePrice,quantity,category",
+  productFull: "name,sku,barcode,basePrice,costPrice,quantity,category,isActive",
+  /** Order essentials */
+  orderBasic: "orderNumber,customer,status,totalAmount,createdAt",
+  orderFull: "orderNumber,customer,items,totalAmount,status,paymentStatus,deliveryMethod,createdAt",
+  /** Customer essentials */
+  customerBasic: "name,phone,email",
+  customerFull: "name,phone,email,stats,addresses,createdAt",
+  /** Transaction essentials */
+  transactionBasic: "amount,method,status,transactionDate",
+  transactionFull: "amount,type,method,status,referenceModel,referenceId,transactionDate",
+  /** Stock essentials */
+  stockBasic: "product,branch,quantity,reorderPoint",
+  stockFull: "product,variantSku,branch,quantity,reservedQuantity,costPrice,reorderPoint",
+  /** Movement essentials */
+  movementBasic: "product,branch,type,quantity,balanceAfter,createdAt",
+  movementFull: "product,variantSku,branch,type,quantity,balanceAfter,costPerUnit,reference,actor,createdAt"
+};
+
+// src/platform/types/branch.ts
+function isHeadOffice(branch) {
+  return branch.role === "head_office";
+}
+function isSubBranch(branch) {
+  return branch.role === "sub_branch";
+}
+var PLATFORM_KEYS = createQueryKeys("platform-config");
+function usePlatformConfig(token = null, select = null) {
+  const queryResult = useQuery({
+    queryKey: [...PLATFORM_KEYS.all, select],
+    queryFn: async () => {
+      const response = await platformConfigApi.getConfig({ token, select });
+      if (response.success && response.data) {
+        return response.data;
+      }
+      throw new Error(response.message || "Failed to fetch platform config");
+    },
+    staleTime: token ? 0 : 5 * 60 * 1e3,
+    // 5 minutes for public, 0 for authenticated
+    gcTime: 10 * 60 * 1e3
+    // 10 minutes
+  });
+  return {
+    config: queryResult.data,
+    isLoading: queryResult.isLoading,
+    isError: queryResult.isError,
+    error: queryResult.error,
+    refetch: queryResult.refetch
+  };
+}
+function useUpdatePlatformConfig(token) {
+  const queryClient = useQueryClient();
+  const toast = getToastHandler();
+  const mutation = useMutation({
+    mutationFn: async (data) => {
+      if (!token) {
+        throw new Error("Authentication required");
+      }
+      const response = await platformConfigApi.updateConfig({ token, data });
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message || "Failed to update platform config");
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: PLATFORM_KEYS.all });
+      toast.success("Configuration updated successfully");
+    },
+    onError: (error) => {
+      toast.error(error.message || "Failed to update configuration");
+    }
+  });
+  return {
+    updateConfig: mutation.mutateAsync,
+    isUpdating: mutation.isPending,
+    error: mutation.error
+  };
+}
+function usePaymentMethods(token = null) {
+  const queryResult = useQuery({
+    queryKey: [...PLATFORM_KEYS.all, "paymentMethods"],
+    queryFn: async () => {
+      const response = await platformConfigApi.getPaymentMethods({ token });
+      if (response.success) {
+        return response.data?.paymentMethods || [];
+      }
+      throw new Error(response.message || "Failed to fetch payment methods");
+    },
+    staleTime: 5 * 60 * 1e3,
+    gcTime: 10 * 60 * 1e3
+  });
+  return {
+    paymentMethods: queryResult.data || [],
+    isLoading: queryResult.isLoading,
+    isError: queryResult.isError,
+    error: queryResult.error,
+    refetch: queryResult.refetch
+  };
+}
+function useDeliveryZones(token = null) {
+  const queryResult = useQuery({
+    queryKey: [...PLATFORM_KEYS.all, "checkout"],
+    queryFn: async () => {
+      const response = await platformConfigApi.getCheckoutSettings({ token });
+      if (response.success) {
+        return response.data?.checkout || {};
+      }
+      throw new Error(response.message || "Failed to fetch checkout settings");
+    },
+    staleTime: 5 * 60 * 1e3,
+    gcTime: 10 * 60 * 1e3
+  });
+  const checkout = queryResult.data;
+  return {
+    deliveryZones: checkout?.deliveryZones || [],
+    freeDeliveryThreshold: checkout?.freeDeliveryThreshold || 0,
+    allowStorePickup: checkout?.allowStorePickup || false,
+    pickupBranches: checkout?.pickupBranches || [],
+    isLoading: queryResult.isLoading,
+    isError: queryResult.isError,
+    error: queryResult.error,
+    refetch: queryResult.refetch
+  };
+}
+function useMembershipConfig(token = null) {
+  const queryResult = useQuery({
+    queryKey: [...PLATFORM_KEYS.all, "membership"],
+    queryFn: async () => {
+      const response = await platformConfigApi.getMembershipConfig({ token });
+      if (response.success) {
+        return response.data?.membership || null;
+      }
+      throw new Error(response.message || "Failed to fetch membership config");
+    },
+    staleTime: 5 * 60 * 1e3,
+    gcTime: 10 * 60 * 1e3
+  });
+  return {
+    membership: queryResult.data,
+    isLoading: queryResult.isLoading,
+    isError: queryResult.isError,
+    error: queryResult.error,
+    refetch: queryResult.refetch
+  };
+}
+
+// src/platform/hooks/branch.ts
+var branchHooks = createCrudHooks({
+  api: branchApi,
+  entityKey: "branches",
+  singular: "Branch",
+  plural: "Branches",
+  defaults: {
+    staleTime: 15 * 60 * 1e3
+    // 15 minutes (branches rarely change)
+  }
+});
+var {
+  KEYS: BRANCH_KEYS,
+  useList: useBranches,
+  useDetail: useBranchDetail,
+  useActions: useBranchActions,
+  useNavigation: useBranchNavigation
+} = branchHooks;
+
+// src/platform/hooks/user.ts
+var userHooks = createCrudHooks({
+  api: userApi,
+  entityKey: "users",
+  singular: "User",
+  plural: "Users"
+});
+var {
+  KEYS: USER_KEYS,
+  useList: useUsers,
+  useDetail: useUserDetail,
+  useActions: useUserActions,
+  useNavigation: useUserNavigation
+} = userHooks;
+
+// src/platform/hooks/coupon.ts
+var couponHooks = createCrudHooks({
+  api: couponApi,
+  entityKey: "coupons",
+  singular: "Coupon",
+  plural: "Coupons"
+});
+var {
+  KEYS: COUPON_KEYS,
+  useList: useCoupons,
+  useDetail: useCouponDetail,
+  useActions: useCouponActions,
+  useNavigation: useCouponNavigation
+} = couponHooks;
+
+export { BRANCH_KEYS, BranchApi, COUPON_KEYS, CouponApi, ExportApi, ExportFields, ExportFilters, PLATFORM_KEYS, PlatformConfigApi, USER_KEYS, UserApi, WebhookApi, branchApi, branchHooks, businessApi, couponApi, couponHooks, exportAndDownload, exportApi, isHeadOffice, isSubBranch, parseCSV, platformApi, platformConfigApi, readCSVBlob, useBranchActions, useBranchDetail, useBranchNavigation, useBranches, useCouponActions, useCouponDetail, useCouponNavigation, useCoupons, useDeliveryZones, useMembershipConfig, usePaymentMethods, usePlatformConfig, useUpdatePlatformConfig, useUserActions, useUserDetail, useUserNavigation, useUsers, userApi, userHooks, webhookApi };
+//# sourceMappingURL=chunk-OF5M6R2S.js.map
+//# sourceMappingURL=chunk-OF5M6R2S.js.map