@classytic/commerce-sdk 0.1.1 → 0.2.1

package/dist/platform/hooks/promo.js

@@ -0,0 +1,451 @@
+"use client";
+
+import { getToastHandler } from "../../core/react/mutation.factory.js";
+import { createCrudHooks } from "../../core/react/crud.factory.js";
+import { evaluationApi, programApi, voucherApi } from "../api/promo.js";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+
+//#region src/platform/hooks/promo.ts
+/**
+* Promo Hooks
+*
+* React hooks for the promo engine: programs (CRUD + factory),
+* vouchers (generate, validate), and cart evaluation (preview, evaluate, commit).
+*/
+const programHooks = createCrudHooks({
+	api: programApi,
+	entityKey: "programs",
+	singular: "Program",
+	plural: "Programs"
+});
+const { KEYS: PROGRAM_KEYS, useList: usePrograms, useDetail: useProgramDetail, useActions: useProgramActions, useNavigation: useProgramNavigation } = programHooks;
+/**
+* Fetch a program with its rules and rewards pre-loaded
+*
+* @example
+* ```tsx
+* const { data: program, isLoading } = useFullProgram(token, programId);
+* console.log(program?.rules, program?.rewards);
+* ```
+*/
+function useFullProgram(token, id, options = {}) {
+	return useQuery({
+		queryKey: [
+			...PROGRAM_KEYS.all,
+			"full",
+			id
+		],
+		queryFn: async () => {
+			return (await programApi.getFullProgram({
+				token,
+				id
+			})).data;
+		},
+		enabled: !!token && !!id && options.enabled !== false,
+		staleTime: 30 * 1e3
+	});
+}
+/**
+* Transition a program status (activate / pause / archive)
+*
+* @example
+* ```tsx
+* const { transition, isTransitioning } = useProgramTransition(token);
+* await transition({ id: programId, action: "activate" });
+* ```
+*/
+function useProgramTransition(token) {
+	const queryClient = useQueryClient();
+	const toast = getToastHandler();
+	const mutation = useMutation({
+		mutationFn: async ({ id, action }) => {
+			return (await programApi.transition({
+				token,
+				id,
+				action
+			})).data;
+		},
+		onSuccess: (_data, { action }) => {
+			queryClient.invalidateQueries({ queryKey: PROGRAM_KEYS.all });
+			toast.success(`Program ${action}d`);
+		},
+		onError: (err) => {
+			toast.error(err.message || "Failed to transition program");
+		}
+	});
+	return {
+		transition: mutation.mutateAsync,
+		isTransitioning: mutation.isPending
+	};
+}
+/**
+* CRUD mutations for rules on a program
+*
+* @example
+* ```tsx
+* const { addRule, updateRule, removeRule } = useProgramRules(token);
+* await addRule({ programId, data: { minimumAmount: 500 } });
+* ```
+*/
+function useProgramRules(token) {
+	const queryClient = useQueryClient();
+	const toast = getToastHandler();
+	const invalidate = () => queryClient.invalidateQueries({ queryKey: PROGRAM_KEYS.all });
+	const addMutation = useMutation({
+		mutationFn: async ({ programId, data }) => {
+			return (await programApi.addRule({
+				token,
+				id: programId,
+				data
+			})).data;
+		},
+		onSuccess: () => {
+			invalidate();
+			toast.success("Rule added");
+		},
+		onError: (err) => toast.error(err.message || "Failed to add rule")
+	});
+	const updateMutation = useMutation({
+		mutationFn: async ({ programId, ruleId, data }) => {
+			return (await programApi.updateRule({
+				token,
+				programId,
+				ruleId,
+				data
+			})).data;
+		},
+		onSuccess: () => {
+			invalidate();
+			toast.success("Rule updated");
+		},
+		onError: (err) => toast.error(err.message || "Failed to update rule")
+	});
+	const removeMutation = useMutation({
+		mutationFn: async ({ programId, ruleId }) => {
+			await programApi.removeRule({
+				token,
+				programId,
+				ruleId
+			});
+		},
+		onSuccess: () => {
+			invalidate();
+			toast.success("Rule removed");
+		},
+		onError: (err) => toast.error(err.message || "Failed to remove rule")
+	});
+	return {
+		addRule: addMutation.mutateAsync,
+		isAddingRule: addMutation.isPending,
+		updateRule: updateMutation.mutateAsync,
+		isUpdatingRule: updateMutation.isPending,
+		removeRule: removeMutation.mutateAsync,
+		isRemovingRule: removeMutation.isPending
+	};
+}
+/**
+* CRUD mutations for rewards on a program
+*
+* @example
+* ```tsx
+* const { addReward, updateReward, removeReward } = useProgramRewards(token);
+* await addReward({ programId, data: { rewardType: 'discount', discountMode: 'percentage', discountAmount: 10 } });
+* ```
+*/
+function useProgramRewards(token) {
+	const queryClient = useQueryClient();
+	const toast = getToastHandler();
+	const invalidate = () => queryClient.invalidateQueries({ queryKey: PROGRAM_KEYS.all });
+	const addMutation = useMutation({
+		mutationFn: async ({ programId, data }) => {
+			return (await programApi.addReward({
+				token,
+				id: programId,
+				data
+			})).data;
+		},
+		onSuccess: () => {
+			invalidate();
+			toast.success("Reward added");
+		},
+		onError: (err) => toast.error(err.message || "Failed to add reward")
+	});
+	const updateMutation = useMutation({
+		mutationFn: async ({ programId, rewardId, data }) => {
+			return (await programApi.updateReward({
+				token,
+				programId,
+				rewardId,
+				data
+			})).data;
+		},
+		onSuccess: () => {
+			invalidate();
+			toast.success("Reward updated");
+		},
+		onError: (err) => toast.error(err.message || "Failed to update reward")
+	});
+	const removeMutation = useMutation({
+		mutationFn: async ({ programId, rewardId }) => {
+			await programApi.removeReward({
+				token,
+				programId,
+				rewardId
+			});
+		},
+		onSuccess: () => {
+			invalidate();
+			toast.success("Reward removed");
+		},
+		onError: (err) => toast.error(err.message || "Failed to remove reward")
+	});
+	return {
+		addReward: addMutation.mutateAsync,
+		isAddingReward: addMutation.isPending,
+		updateReward: updateMutation.mutateAsync,
+		isUpdatingReward: updateMutation.isPending,
+		removeReward: removeMutation.mutateAsync,
+		isRemovingReward: removeMutation.isPending
+	};
+}
+const VOUCHER_KEYS = {
+	all: ["vouchers"],
+	detail: (id) => ["vouchers", id],
+	byCode: (code) => [
+		"vouchers",
+		"code",
+		code
+	]
+};
+/**
+* Batch-generate voucher codes
+*
+* @example
+* ```tsx
+* const { generate, isGenerating } = useVoucherGenerate(token);
+* const vouchers = await generate({ programId, count: 50 });
+* ```
+*/
+function useVoucherGenerate(token) {
+	const queryClient = useQueryClient();
+	const toast = getToastHandler();
+	const mutation = useMutation({
+		mutationFn: async (data) => {
+			return (await voucherApi.generateCodes({
+				token,
+				data
+			})).data;
+		},
+		onSuccess: (_data, variables) => {
+			queryClient.invalidateQueries({ queryKey: VOUCHER_KEYS.all });
+			queryClient.invalidateQueries({ queryKey: PROGRAM_KEYS.all });
+			toast.success(`${variables.count} voucher codes generated`);
+		},
+		onError: (err) => toast.error(err.message || "Failed to generate codes")
+	});
+	return {
+		generate: mutation.mutateAsync,
+		isGenerating: mutation.isPending
+	};
+}
+/**
+* Generate a single voucher code
+*
+* @example
+* ```tsx
+* const { generateSingle, isGenerating } = useVoucherGenerateSingle(token);
+* const voucher = await generateSingle({ programId, code: "WELCOME50" });
+* ```
+*/
+function useVoucherGenerateSingle(token) {
+	const queryClient = useQueryClient();
+	const toast = getToastHandler();
+	const mutation = useMutation({
+		mutationFn: async (data) => {
+			return (await voucherApi.generateSingle({
+				token,
+				data
+			})).data;
+		},
+		onSuccess: () => {
+			queryClient.invalidateQueries({ queryKey: VOUCHER_KEYS.all });
+			queryClient.invalidateQueries({ queryKey: PROGRAM_KEYS.all });
+			toast.success("Voucher code generated");
+		},
+		onError: (err) => toast.error(err.message || "Failed to generate code")
+	});
+	return {
+		generateSingle: mutation.mutateAsync,
+		isGenerating: mutation.isPending
+	};
+}
+/**
+* Validate a voucher code
+*
+* @example
+* ```tsx
+* const { validate, isValidating } = useVoucherValidate(token);
+* const result = await validate("SUMMER20");
+* if (result.valid) { ... }
+* ```
+*/
+function useVoucherValidate(token) {
+	const toast = getToastHandler();
+	const mutation = useMutation({
+		mutationFn: async (code) => {
+			return (await voucherApi.validateCode({
+				token,
+				code
+			})).data;
+		},
+		onError: (err) => toast.error(err.message || "Failed to validate code")
+	});
+	return {
+		validate: mutation.mutateAsync,
+		isValidating: mutation.isPending,
+		result: mutation.data
+	};
+}
+/**
+* Cancel a voucher
+*
+* @example
+* ```tsx
+* const { cancel, isCancelling } = useVoucherCancel(token);
+* await cancel(voucherId);
+* ```
+*/
+function useVoucherCancel(token) {
+	const queryClient = useQueryClient();
+	const toast = getToastHandler();
+	const mutation = useMutation({
+		mutationFn: async (id) => {
+			return (await voucherApi.cancel({
+				token,
+				id
+			})).data;
+		},
+		onSuccess: () => {
+			queryClient.invalidateQueries({ queryKey: VOUCHER_KEYS.all });
+			toast.success("Voucher cancelled");
+		},
+		onError: (err) => toast.error(err.message || "Failed to cancel voucher")
+	});
+	return {
+		cancel: mutation.mutateAsync,
+		isCancelling: mutation.isPending
+	};
+}
+const EVALUATION_KEYS = { all: ["evaluations"] };
+/**
+* Preview promo evaluation (dry-run, no side effects)
+*
+* @example
+* ```tsx
+* const { preview, isPreviewing, result } = usePromoPreview(token);
+* const evaluation = await preview({ items, subtotal: 1500, codes: ["SUMMER20"] });
+* ```
+*/
+function usePromoPreview(token) {
+	const mutation = useMutation({ mutationFn: async (data) => {
+		return (await evaluationApi.preview({
+			token,
+			data
+		})).data;
+	} });
+	return {
+		preview: mutation.mutateAsync,
+		isPreviewing: mutation.isPending,
+		result: mutation.data
+	};
+}
+/**
+* Evaluate cart (reserves usage counts, must be committed or rolled back)
+*
+* @example
+* ```tsx
+* const { evaluate, isEvaluating } = usePromoEvaluate(token);
+* const result = await evaluate({ items, subtotal: 1500, codes: ["SUMMER20"] });
+* // Later: commit or rollback
+* ```
+*/
+function usePromoEvaluate(token) {
+	const toast = getToastHandler();
+	const mutation = useMutation({
+		mutationFn: async (data) => {
+			return (await evaluationApi.evaluate({
+				token,
+				data
+			})).data;
+		},
+		onError: (err) => toast.error(err.message || "Failed to evaluate promotions")
+	});
+	return {
+		evaluate: mutation.mutateAsync,
+		isEvaluating: mutation.isPending,
+		result: mutation.data
+	};
+}
+/**
+* Commit an evaluation to an order
+*
+* @example
+* ```tsx
+* const { commit, isCommitting } = usePromoCommit(token);
+* await commit({ evaluationId, orderId });
+* ```
+*/
+function usePromoCommit(token) {
+	const queryClient = useQueryClient();
+	const toast = getToastHandler();
+	const mutation = useMutation({
+		mutationFn: async ({ evaluationId, orderId }) => {
+			return (await evaluationApi.commit({
+				token,
+				evaluationId,
+				orderId
+			})).data;
+		},
+		onSuccess: () => {
+			queryClient.invalidateQueries({ queryKey: PROGRAM_KEYS.all });
+			queryClient.invalidateQueries({ queryKey: VOUCHER_KEYS.all });
+			toast.success("Promotions committed to order");
+		},
+		onError: (err) => toast.error(err.message || "Failed to commit promotions")
+	});
+	return {
+		commit: mutation.mutateAsync,
+		isCommitting: mutation.isPending
+	};
+}
+/**
+* Rollback an uncommitted evaluation
+*
+* @example
+* ```tsx
+* const { rollback, isRollingBack } = usePromoRollback(token);
+* await rollback(evaluationId);
+* ```
+*/
+function usePromoRollback(token) {
+	const toast = getToastHandler();
+	const mutation = useMutation({
+		mutationFn: async (evaluationId) => {
+			await evaluationApi.rollback({
+				token,
+				evaluationId
+			});
+		},
+		onSuccess: () => {
+			toast.success("Evaluation rolled back");
+		},
+		onError: (err) => toast.error(err.message || "Failed to rollback evaluation")
+	});
+	return {
+		rollback: mutation.mutateAsync,
+		isRollingBack: mutation.isPending
+	};
+}
+
+//#endregion
+export { EVALUATION_KEYS, PROGRAM_KEYS, VOUCHER_KEYS, programHooks, useFullProgram, useProgramActions, useProgramDetail, useProgramNavigation, useProgramRewards, useProgramRules, useProgramTransition, usePrograms, usePromoCommit, usePromoEvaluate, usePromoPreview, usePromoRollback, useVoucherCancel, useVoucherGenerate, useVoucherGenerateSingle, useVoucherValidate };

package/dist/platform/hooks/user.d.ts

@@ -0,0 +1,24 @@
+import { CreateUserPayload, UpdateUserPayload, User } from "../types/user.js";
+import * as _classytic_arc_next_query0 from "@classytic/arc-next/query";
+import * as _classytic_arc_next0 from "@classytic/arc-next";
+
+//#region src/platform/hooks/user.d.ts
+/**
+ * User hooks using createCrudHooks factory
+ *
+ * Provides:
+ * - useUsers: List users with filtering/pagination
+ * - useUserDetail: Get single user
+ * - useUserActions: Create, update, delete mutations
+ * - useUserNavigation: Navigation between users
+ */
+declare const userHooks: _classytic_arc_next0.CrudHooksReturn<User, CreateUserPayload, UpdateUserPayload>;
+declare const USER_KEYS: _classytic_arc_next_query0.QueryKeys, useUsers: {
+    (params?: Record<string, unknown>, options?: _classytic_arc_next_query0.ListQueryOptions<User> | undefined): _classytic_arc_next_query0.ListQueryResult<User>;
+    (token: string | null, params?: Record<string, unknown>, options?: _classytic_arc_next_query0.ListQueryOptions<User> | undefined): _classytic_arc_next_query0.ListQueryResult<User>;
+  }, useUserDetail: {
+    (id: string | null, options?: _classytic_arc_next_query0.DetailQueryOptions<User> | undefined): _classytic_arc_next_query0.DetailQueryResult<User>;
+    (id: string | null, token: string | null, options?: _classytic_arc_next_query0.DetailQueryOptions<User> | undefined): _classytic_arc_next_query0.DetailQueryResult<User>;
+  }, useUserActions: () => _classytic_arc_next0.CrudActions<User, CreateUserPayload, UpdateUserPayload>, useUserNavigation: () => _classytic_arc_next0.NavigateFn<User>;
+//#endregion
+export { USER_KEYS, useUserActions, useUserDetail, useUserNavigation, useUsers, userHooks };

package/dist/platform/hooks/user.js

@@ -0,0 +1,30 @@
+"use client";
+
+import { createCrudHooks } from "../../core/react/crud.factory.js";
+import { userApi } from "../api/user.js";
+
+//#region src/platform/hooks/user.ts
+/**
+* User Hooks
+*
+* React hooks for user CRUD operations using the factory pattern.
+*/
+/**
+* User hooks using createCrudHooks factory
+*
+* Provides:
+* - useUsers: List users with filtering/pagination
+* - useUserDetail: Get single user
+* - useUserActions: Create, update, delete mutations
+* - useUserNavigation: Navigation between users
+*/
+const userHooks = createCrudHooks({
+	api: userApi,
+	entityKey: "users",
+	singular: "User",
+	plural: "Users"
+});
+const { KEYS: USER_KEYS, useList: useUsers, useDetail: useUserDetail, useActions: useUserActions, useNavigation: useUserNavigation } = userHooks;
+
+//#endregion
+export { USER_KEYS, useUserActions, useUserDetail, useUserNavigation, useUsers, userHooks };