@classytic/commerce-sdk 0.1.1 → 0.2.1

package/dist/platform/types/webhook.d.ts

@@ -0,0 +1,165 @@
+import { TransactionCategory, TransactionStatus } from "../../transaction/types/transaction.js";
+
+//#region src/platform/types/webhook.d.ts
+/**
+ * Supported payment gateway providers
+ * - manual: Built-in manual verification (cash, bank transfer, mobile money)
+ * - stripe: Stripe payment gateway
+ * - sslcommerz: SSLCommerz (Bangladesh)
+ * - bkash: bKash API integration
+ * - nagad: Nagad API integration
+ */
+type PaymentGatewayProvider = 'manual' | 'stripe' | 'sslcommerz' | 'bkash' | 'nagad';
+/**
+ * Request payload for manual payment verification
+ * POST /webhooks/payments/manual/verify
+ *
+ * Used by superadmin to verify manual payments (cash, bank transfer, bKash, Nagad)
+ */
+interface ManualVerifyPayload {
+  /** Transaction ID to verify (MongoDB ObjectId as string) */
+  transactionId: string;
+  /** Optional verification notes */
+  notes?: string;
+}
+/**
+ * Request payload for manual payment rejection
+ * POST /webhooks/payments/manual/reject
+ *
+ * Used by superadmin to reject invalid payments (fraud, invalid reference, etc.)
+ */
+interface ManualRejectPayload {
+  /** Transaction ID to reject (MongoDB ObjectId as string) */
+  transactionId: string;
+  /** Reason for rejection (required) */
+  reason: string;
+}
+/**
+ * Entity reference information from transaction
+ */
+interface TransactionEntityRef {
+  /** Reference model type (Order, Commission, etc.) */
+  referenceModel: string;
+  /** Reference document ID */
+  referenceId: string;
+}
+/**
+ * Successful verification response data
+ */
+interface ManualVerifyResponseData {
+  /** Transaction ID */
+  transactionId: string;
+  /** New transaction status */
+  status: TransactionStatus;
+  /** Transaction amount (in smallest currency unit) */
+  amount: number;
+  /** Transaction category */
+  category: TransactionCategory | string;
+  /** Verification timestamp (ISO 8601) */
+  verifiedAt: string;
+  /** User ID who verified */
+  verifiedBy: string;
+  /** Linked entity (Order, etc.) if exists */
+  entity: TransactionEntityRef | null;
+}
+/**
+ * Successful rejection response data
+ */
+interface ManualRejectResponseData {
+  /** Transaction ID */
+  transactionId: string;
+  /** Transaction status (always 'failed') */
+  status: 'failed';
+  /** Failure timestamp (ISO 8601) */
+  failedAt: string;
+  /** Rejection reason */
+  failureReason: string;
+}
+/**
+ * Provider webhook response data
+ */
+interface ProviderWebhookResponseData {
+  /** Webhook event type from provider */
+  event: string;
+  /** Provider's event ID */
+  eventId: string;
+  /** Transaction ID (if found) */
+  transactionId?: string;
+  /** Processing status */
+  status: 'processed' | 'already_processed';
+  /** Provider name */
+  provider: PaymentGatewayProvider;
+}
+/**
+ * Webhook error names for error handling
+ */
+type WebhookErrorName = 'TransactionNotFoundError' | 'AlreadyVerifiedError' | 'AlreadyRejectedError' | 'PaymentVerificationError' | 'PaymentRejectionError' | 'ProviderNotFoundError' | 'ValidationError' | 'ProviderError';
+/**
+ * Webhook error response
+ */
+interface WebhookErrorResponse {
+  success: false;
+  message: string;
+  error: WebhookErrorName | string;
+}
+/**
+ * Manual verification API response
+ */
+interface ManualVerifyResponse {
+  success: true;
+  message: string;
+  data: ManualVerifyResponseData;
+}
+/**
+ * Manual rejection API response
+ */
+interface ManualRejectResponse {
+  success: true;
+  message: string;
+  data: ManualRejectResponseData;
+}
+/**
+ * Provider webhook API response
+ */
+interface ProviderWebhookResponse {
+  success: true;
+  message: string;
+  data: ProviderWebhookResponseData;
+}
+/**
+ * Stripe webhook event types (common ones)
+ */
+type StripeWebhookEventType = 'payment_intent.succeeded' | 'payment_intent.payment_failed' | 'checkout.session.completed' | 'checkout.session.expired' | 'charge.refunded' | 'charge.dispute.created';
+/**
+ * SSLCommerz IPN status values
+ */
+type SSLCommerzStatus = 'VALID' | 'FAILED' | 'CANCELLED' | 'UNATTEMPTED' | 'EXPIRED';
+/**
+ * Generic provider webhook payload
+ * Each provider has different formats - this is the common interface
+ */
+interface ProviderWebhookPayload {
+  /** Provider-specific event/transaction ID */
+  id?: string;
+  /** Event type (provider-specific naming) */
+  type?: string;
+  /** Status (provider-specific) */
+  status?: string;
+  /** Nested data object (common in Stripe) */
+  data?: {
+    object?: {
+      id?: string;
+      payment_intent?: string;
+      metadata?: Record<string, string>;
+      [key: string]: unknown;
+    };
+    [key: string]: unknown;
+  };
+  /** SSLCommerz specific fields */
+  tran_id?: string;
+  val_id?: string;
+  /** Allow additional provider-specific fields */
+  [key: string]: unknown;
+}
+//#endregion
+export { ManualRejectPayload, ManualRejectResponse, ManualRejectResponseData, ManualVerifyPayload, ManualVerifyResponse, ManualVerifyResponseData, PaymentGatewayProvider, ProviderWebhookPayload, ProviderWebhookResponse, ProviderWebhookResponseData, SSLCommerzStatus, StripeWebhookEventType, TransactionEntityRef, WebhookErrorName, WebhookErrorResponse };

package/dist/sales/api/cart.d.ts

@@ -0,0 +1,34 @@
+import { BaseApi } from "../../core/api-factory.js";
+import { AddCartItemPayload, Cart } from "../types/cart.js";
+
+//#region src/sales/api/cart.d.ts
+declare class CartApi extends BaseApi<Cart> {
+  constructor();
+  /** GET /api/v1/cart — Get current user's cart (auto-creates if missing) */
+  getCart(): Promise<Cart>;
+  /** POST /api/v1/cart/items — Add item to cart */
+  addItem({
+    data
+  }: {
+    data: AddCartItemPayload;
+  }): Promise<Cart>;
+  /** PATCH /api/v1/cart/items/:itemId — Update cart item quantity */
+  updateItem({
+    itemId,
+    quantity
+  }: {
+    itemId: string;
+    quantity: number;
+  }): Promise<Cart>;
+  /** DELETE /api/v1/cart/items/:itemId — Remove item from cart */
+  removeItem({
+    itemId
+  }: {
+    itemId: string;
+  }): Promise<Cart>;
+  /** DELETE /api/v1/cart — Clear all items */
+  clear(): Promise<Cart>;
+}
+declare const cartApi: CartApi;
+//#endregion
+export { cartApi };

package/dist/sales/api/cart.js

@@ -0,0 +1,38 @@
+import { BaseApi } from "../../core/api-factory.js";
+
+//#region src/sales/api/cart.ts
+/**
+* Cart API Client
+*
+* Base URL: /api/v1/cart
+* All endpoints require authentication (Bearer token, auto-injected).
+*/
+var CartApi = class extends BaseApi {
+	constructor() {
+		super("cart");
+	}
+	/** GET /api/v1/cart — Get current user's cart (auto-creates if missing) */
+	async getCart() {
+		return (await this.request("GET", this.baseUrl)).data;
+	}
+	/** POST /api/v1/cart/items — Add item to cart */
+	async addItem({ data }) {
+		return (await this.request("POST", `${this.baseUrl}/items`, { data })).data;
+	}
+	/** PATCH /api/v1/cart/items/:itemId — Update cart item quantity */
+	async updateItem({ itemId, quantity }) {
+		return (await this.request("PATCH", `${this.baseUrl}/items/${itemId}`, { data: { quantity } })).data;
+	}
+	/** DELETE /api/v1/cart/items/:itemId — Remove item from cart */
+	async removeItem({ itemId }) {
+		return (await this.request("DELETE", `${this.baseUrl}/items/${itemId}`)).data;
+	}
+	/** DELETE /api/v1/cart — Clear all items */
+	async clear() {
+		return (await this.request("DELETE", this.baseUrl)).data;
+	}
+};
+const cartApi = new CartApi();
+
+//#endregion
+export { cartApi };

package/dist/sales/api/customer.d.ts

@@ -0,0 +1,40 @@
+import { ApiResponse, BaseApi, RequestOptions } from "../../core/api-factory.js";
+import { Customer, CustomerPayload, CustomerQueryParams } from "../types/customer.js";
+
+//#region src/sales/api/customer.d.ts
+type FetchOptions = Omit<RequestOptions, 'token' | 'organizationId'>;
+declare class CustomerApi extends BaseApi<Customer, CustomerPayload, CustomerPayload> {
+  constructor(config?: {});
+  /**
+   * Get current user's customer profile
+   * GET /customers/me
+   */
+  getMe({
+    token,
+    options
+  }: {
+    token: string;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<Customer>>;
+  /**
+   * Membership actions
+   * POST /customers/:id/membership
+   */
+  membershipAction({
+    token,
+    id,
+    data
+  }: {
+    token: string;
+    id: string;
+    data: {
+      action: 'enroll' | 'deactivate' | 'reactivate' | 'adjust';
+      points?: number;
+      reason?: string;
+      type?: 'bonus' | 'correction' | 'manual_redemption' | 'redemption' | 'expiry';
+    };
+  }): Promise<ApiResponse<Customer>>;
+}
+declare const customerApi: CustomerApi;
+//#endregion
+export { CustomerApi, customerApi };

package/dist/sales/api/customer.js

@@ -0,0 +1,52 @@
+import { handleApiRequest } from "../../core/api-handler.js";
+import { BaseApi } from "../../core/api-factory.js";
+
+//#region src/sales/api/customer.ts
+/**
+* Customer API - CRUD + helper endpoint
+*
+* Standard CRUD (inherited from BaseApi):
+* - getAll({ token, params }) - list with filtering/search/pagination
+* - getById({ token, id }) - get by ID
+* - update({ token, id, data }) - update (admin/staff rules apply)
+* - delete({ token, id }) - delete (admin only)
+*
+* Notes:
+* - Customers may be auto-created by backend workflows; some environments may not expose create.
+*
+* Extra endpoint:
+* - getMe({ token }) - current user's customer profile
+*/
+var CustomerApi = class extends BaseApi {
+	constructor(config = {}) {
+		super("customers", config);
+	}
+	/**
+	* Get current user's customer profile
+	* GET /customers/me
+	*/
+	async getMe({ token, options = {} }) {
+		if (!token) throw new Error("Authentication required");
+		return handleApiRequest("GET", `${this.baseUrl}/me`, {
+			token,
+			cache: this.config.cache,
+			...options
+		});
+	}
+	/**
+	* Membership actions
+	* POST /customers/:id/membership
+	*/
+	async membershipAction({ token, id, data }) {
+		if (!token) throw new Error("Authentication required");
+		return handleApiRequest("POST", `${this.baseUrl}/${id}/membership`, {
+			token,
+			body: data,
+			cache: this.config.cache
+		});
+	}
+};
+const customerApi = new CustomerApi();
+
+//#endregion
+export { CustomerApi, customerApi };

package/dist/sales/api/earning-rules.d.ts

@@ -0,0 +1,54 @@
+import { CreateEarningRulePayload, EarningRuleListParams, EarningRuleListResponse, EarningRuleResponse, UpdateEarningRulePayload } from "../types/earning-rules.js";
+
+//#region src/sales/api/earning-rules.d.ts
+type RequestOptions = {
+  cache?: RequestCache;
+  next?: Record<string, unknown>;
+};
+declare class EarningRulesApi {
+  private get baseUrl();
+  list({
+    token,
+    params,
+    options
+  }: {
+    token: string;
+    params?: EarningRuleListParams;
+    options?: RequestOptions;
+  }): Promise<EarningRuleListResponse>;
+  get({
+    token,
+    ruleId,
+    options
+  }: {
+    token: string;
+    ruleId: string;
+    options?: RequestOptions;
+  }): Promise<EarningRuleResponse>;
+  create({
+    token,
+    data
+  }: {
+    token: string;
+    data: CreateEarningRulePayload;
+  }): Promise<EarningRuleResponse>;
+  update({
+    token,
+    ruleId,
+    data
+  }: {
+    token: string;
+    ruleId: string;
+    data: UpdateEarningRulePayload;
+  }): Promise<EarningRuleResponse>;
+  deactivate({
+    token,
+    ruleId
+  }: {
+    token: string;
+    ruleId: string;
+  }): Promise<EarningRuleResponse>;
+}
+declare const earningRulesApi: EarningRulesApi;
+//#endregion
+export { EarningRulesApi, earningRulesApi };

package/dist/sales/api/earning-rules.js

@@ -0,0 +1,56 @@
+import { getBaseUrl, handleApiRequest } from "../../core/api-handler.js";
+
+//#region src/sales/api/earning-rules.ts
+/**
+* Earning Rules API
+*
+* API client for loyalty earning rule endpoints.
+*
+* Endpoints:
+* - GET    /loyalty/earning-rules           — list
+* - GET    /loyalty/earning-rules/:ruleId   — get
+* - POST   /loyalty/earning-rules           — create
+* - PUT    /loyalty/earning-rules/:ruleId   — update
+* - POST   /loyalty/earning-rules/:ruleId/deactivate
+*/
+var EarningRulesApi = class {
+	get baseUrl() {
+		return `${getBaseUrl()}/loyalty/earning-rules`;
+	}
+	async list({ token, params = {}, options = {} }) {
+		const searchParams = new URLSearchParams();
+		if (params.page) searchParams.set("page", String(params.page));
+		if (params.limit) searchParams.set("limit", String(params.limit));
+		if (params.status) searchParams.set("status", params.status);
+		const qs = searchParams.toString();
+		return handleApiRequest("GET", `${this.baseUrl}${qs ? `?${qs}` : ""}`, {
+			token,
+			...options
+		});
+	}
+	async get({ token, ruleId, options = {} }) {
+		return handleApiRequest("GET", `${this.baseUrl}/${ruleId}`, {
+			token,
+			...options
+		});
+	}
+	async create({ token, data }) {
+		return handleApiRequest("POST", this.baseUrl, {
+			token,
+			body: data
+		});
+	}
+	async update({ token, ruleId, data }) {
+		return handleApiRequest("PUT", `${this.baseUrl}/${ruleId}`, {
+			token,
+			body: data
+		});
+	}
+	async deactivate({ token, ruleId }) {
+		return handleApiRequest("POST", `${this.baseUrl}/${ruleId}/deactivate`, { token });
+	}
+};
+const earningRulesApi = new EarningRulesApi();
+
+//#endregion
+export { EarningRulesApi, earningRulesApi };

package/dist/sales/api/index.d.ts

@@ -0,0 +1,9 @@
+import { CustomerQueryParams } from "../types/customer.js";
+import { cartApi } from "./cart.js";
+import { orderApi } from "./order.js";
+import { CustomerApi, customerApi } from "./customer.js";
+import { posApi } from "./pos.js";
+import { LoyaltyApi, loyaltyApi } from "./loyalty.js";
+import { EarningRulesApi, earningRulesApi } from "./earning-rules.js";
+import { TiersApi, tiersApi } from "./tiers.js";
+import { ReferralsApi, referralsApi } from "./referrals.js";

package/dist/sales/api/loyalty.d.ts

@@ -0,0 +1,54 @@
+import { BaseApi } from "../../core/api-factory.js";
+import { AdjustPointsPayload, AdjustPointsResponse, EnrollMemberPayload, LoyaltyHistoryParams, LoyaltyHistoryResponse, LoyaltyMemberDetailResponse, LoyaltyMemberResponse, LoyaltyMyStatusResponse } from "../types/loyalty.js";
+
+//#region src/sales/api/loyalty.d.ts
+declare class LoyaltyApi extends BaseApi {
+  constructor();
+  /** POST /loyalty/members — Enroll a customer */
+  enroll({
+    data
+  }: {
+    data: EnrollMemberPayload;
+  }): Promise<LoyaltyMemberResponse>;
+  /** GET /loyalty/members/:customerId — Get member details + balance */
+  getMember({
+    customerId
+  }: {
+    customerId: string;
+  }): Promise<LoyaltyMemberDetailResponse>;
+  /** POST /loyalty/members/:customerId/deactivate */
+  deactivate({
+    customerId
+  }: {
+    customerId: string;
+  }): Promise<LoyaltyMemberResponse>;
+  /** POST /loyalty/members/:customerId/reactivate */
+  reactivate({
+    customerId
+  }: {
+    customerId: string;
+  }): Promise<LoyaltyMemberResponse>;
+  /** POST /loyalty/members/:customerId/adjust — Adjust points */
+  adjustPoints({
+    customerId,
+    data
+  }: {
+    customerId: string;
+    data: AdjustPointsPayload;
+  }): Promise<AdjustPointsResponse>;
+  /** GET /loyalty/members/:customerId/history — Transaction ledger */
+  getHistory({
+    customerId,
+    params
+  }: {
+    customerId: string;
+    params?: LoyaltyHistoryParams;
+  }): Promise<LoyaltyHistoryResponse>;
+  /** POST /loyalty/me/enroll — Self-enroll */
+  selfEnroll(): Promise<LoyaltyMemberResponse>;
+  /** GET /loyalty/me — My loyalty status */
+  getMyStatus(): Promise<LoyaltyMyStatusResponse>;
+}
+declare const loyaltyApi: LoyaltyApi;
+//#endregion
+export { LoyaltyApi, loyaltyApi };

package/dist/sales/api/loyalty.js

@@ -0,0 +1,57 @@
+import { BaseApi } from "../../core/api-factory.js";
+
+//#region src/sales/api/loyalty.ts
+/**
+* Loyalty API
+*
+* Endpoints:
+* - POST   /loyalty/members                      — enroll
+* - GET    /loyalty/members/:customerId           — get member + balance
+* - POST   /loyalty/members/:customerId/deactivate
+* - POST   /loyalty/members/:customerId/reactivate
+* - POST   /loyalty/members/:customerId/adjust    — adjust points
+* - GET    /loyalty/members/:customerId/history    — transaction ledger
+* - POST   /loyalty/me/enroll                     — self-enroll
+* - GET    /loyalty/me                            — my loyalty status
+*/
+var LoyaltyApi = class extends BaseApi {
+	constructor() {
+		super("loyalty");
+	}
+	/** POST /loyalty/members — Enroll a customer */
+	async enroll({ data }) {
+		return this.request("POST", `${this.baseUrl}/members`, { data });
+	}
+	/** GET /loyalty/members/:customerId — Get member details + balance */
+	async getMember({ customerId }) {
+		return this.request("GET", `${this.baseUrl}/members/${customerId}`);
+	}
+	/** POST /loyalty/members/:customerId/deactivate */
+	async deactivate({ customerId }) {
+		return this.request("POST", `${this.baseUrl}/members/${customerId}/deactivate`);
+	}
+	/** POST /loyalty/members/:customerId/reactivate */
+	async reactivate({ customerId }) {
+		return this.request("POST", `${this.baseUrl}/members/${customerId}/reactivate`);
+	}
+	/** POST /loyalty/members/:customerId/adjust — Adjust points */
+	async adjustPoints({ customerId, data }) {
+		return this.request("POST", `${this.baseUrl}/members/${customerId}/adjust`, { data });
+	}
+	/** GET /loyalty/members/:customerId/history — Transaction ledger */
+	async getHistory({ customerId, params = {} }) {
+		return this.request("GET", `${this.baseUrl}/members/${customerId}/history`, { params });
+	}
+	/** POST /loyalty/me/enroll — Self-enroll */
+	async selfEnroll() {
+		return this.request("POST", `${this.baseUrl}/me/enroll`);
+	}
+	/** GET /loyalty/me — My loyalty status */
+	async getMyStatus() {
+		return this.request("GET", `${this.baseUrl}/me`);
+	}
+};
+const loyaltyApi = new LoyaltyApi();
+
+//#endregion
+export { LoyaltyApi, loyaltyApi };