@classytic/commerce-sdk 0.1.1 → 0.2.1

package/dist/node_modules/@tanstack/query-core/build/modern/hydration-C-jfQLut.d.ts

@@ -0,0 +1,270 @@
+//#region node_modules/@tanstack/query-core/build/modern/hydration-C-jfQLut.d.ts
+interface Register {}
+type DefaultError = Register extends {
+  defaultError: infer TError;
+} ? TError : Error;
+interface InfiniteData<TData, TPageParam = unknown> {
+  pages: Array<TData>;
+  pageParams: Array<TPageParam>;
+}
+interface ResultOptions {
+  throwOnError?: boolean;
+}
+interface RefetchOptions extends ResultOptions {
+  /**
+   * If set to `true`, a currently running request will be cancelled before a new request is made
+   *
+   * If set to `false`, no refetch will be made if there is already a request running.
+   *
+   * Defaults to `true`.
+   */
+  cancelRefetch?: boolean;
+}
+type QueryStatus = 'pending' | 'error' | 'success';
+type FetchStatus = 'fetching' | 'paused' | 'idle';
+interface QueryObserverBaseResult<TData = unknown, TError = DefaultError> {
+  /**
+   * The last successfully resolved data for the query.
+   */
+  data: TData | undefined;
+  /**
+   * The timestamp for when the query most recently returned the `status` as `"success"`.
+   */
+  dataUpdatedAt: number;
+  /**
+   * The error object for the query, if an error was thrown.
+   * - Defaults to `null`.
+   */
+  error: TError | null;
+  /**
+   * The timestamp for when the query most recently returned the `status` as `"error"`.
+   */
+  errorUpdatedAt: number;
+  /**
+   * The failure count for the query.
+   * - Incremented every time the query fails.
+   * - Reset to `0` when the query succeeds.
+   */
+  failureCount: number;
+  /**
+   * The failure reason for the query retry.
+   * - Reset to `null` when the query succeeds.
+   */
+  failureReason: TError | null;
+  /**
+   * The sum of all errors.
+   */
+  errorUpdateCount: number;
+  /**
+   * A derived boolean from the `status` variable, provided for convenience.
+   * - `true` if the query attempt resulted in an error.
+   */
+  isError: boolean;
+  /**
+   * Will be `true` if the query has been fetched.
+   */
+  isFetched: boolean;
+  /**
+   * Will be `true` if the query has been fetched after the component mounted.
+   * - This property can be used to not show any previously cached data.
+   */
+  isFetchedAfterMount: boolean;
+  /**
+   * A derived boolean from the `fetchStatus` variable, provided for convenience.
+   * - `true` whenever the `queryFn` is executing, which includes initial `pending` as well as background refetch.
+   */
+  isFetching: boolean;
+  /**
+   * Is `true` whenever the first fetch for a query is in-flight.
+   * - Is the same as `isFetching && isPending`.
+   */
+  isLoading: boolean;
+  /**
+   * Will be `pending` if there's no cached data and no query attempt was finished yet.
+   */
+  isPending: boolean;
+  /**
+   * Will be `true` if the query failed while fetching for the first time.
+   */
+  isLoadingError: boolean;
+  /**
+   * @deprecated `isInitialLoading` is being deprecated in favor of `isLoading`
+   * and will be removed in the next major version.
+   */
+  isInitialLoading: boolean;
+  /**
+   * A derived boolean from the `fetchStatus` variable, provided for convenience.
+   * - The query wanted to fetch, but has been `paused`.
+   */
+  isPaused: boolean;
+  /**
+   * Will be `true` if the data shown is the placeholder data.
+   */
+  isPlaceholderData: boolean;
+  /**
+   * Will be `true` if the query failed while refetching.
+   */
+  isRefetchError: boolean;
+  /**
+   * Is `true` whenever a background refetch is in-flight, which _does not_ include initial `pending`.
+   * - Is the same as `isFetching && !isPending`.
+   */
+  isRefetching: boolean;
+  /**
+   * Will be `true` if the data in the cache is invalidated or if the data is older than the given `staleTime`.
+   */
+  isStale: boolean;
+  /**
+   * A derived boolean from the `status` variable, provided for convenience.
+   * - `true` if the query has received a response with no errors and is ready to display its data.
+   */
+  isSuccess: boolean;
+  /**
+   * `true` if this observer is enabled, `false` otherwise.
+   */
+  isEnabled: boolean;
+  /**
+   * A function to manually refetch the query.
+   */
+  refetch: (options?: RefetchOptions) => Promise<QueryObserverResult<TData, TError>>;
+  /**
+   * The status of the query.
+   * - Will be:
+   *   - `pending` if there's no cached data and no query attempt was finished yet.
+   *   - `error` if the query attempt resulted in an error.
+   *   - `success` if the query has received a response with no errors and is ready to display its data.
+   */
+  status: QueryStatus;
+  /**
+   * The fetch status of the query.
+   * - `fetching`: Is `true` whenever the queryFn is executing, which includes initial `pending` as well as background refetch.
+   * - `paused`: The query wanted to fetch, but has been `paused`.
+   * - `idle`: The query is not fetching.
+   * - See [Network Mode](https://tanstack.com/query/latest/docs/framework/react/guides/network-mode) for more information.
+   */
+  fetchStatus: FetchStatus;
+  /**
+   * A stable promise that will be resolved with the data of the query.
+   * Requires the `experimental_prefetchInRender` feature flag to be enabled.
+   * @example
+   *
+   * ### Enabling the feature flag
+   * ```ts
+   * const client = new QueryClient({
+   *   defaultOptions: {
+   *     queries: {
+   *       experimental_prefetchInRender: true,
+   *     },
+   *   },
+   * })
+   * ```
+   *
+   * ### Usage
+   * ```tsx
+   * import { useQuery } from '@tanstack/react-query'
+   * import React from 'react'
+   * import { fetchTodos, type Todo } from './api'
+   *
+   * function TodoList({ query }: { query: UseQueryResult<Todo[], Error> }) {
+   *   const data = React.use(query.promise)
+   *
+   *   return (
+   *     <ul>
+   *       {data.map(todo => (
+   *         <li key={todo.id}>{todo.title}</li>
+   *       ))}
+   *     </ul>
+   *   )
+   * }
+   *
+   * export function App() {
+   *   const query = useQuery({ queryKey: ['todos'], queryFn: fetchTodos })
+   *
+   *   return (
+   *     <>
+   *       <h1>Todos</h1>
+   *       <React.Suspense fallback={<div>Loading...</div>}>
+   *         <TodoList query={query} />
+   *       </React.Suspense>
+   *     </>
+   *   )
+   * }
+   * ```
+   */
+  promise: Promise<TData>;
+}
+interface QueryObserverPendingResult<TData = unknown, TError = DefaultError> extends QueryObserverBaseResult<TData, TError> {
+  data: undefined;
+  error: null;
+  isError: false;
+  isPending: true;
+  isLoadingError: false;
+  isRefetchError: false;
+  isSuccess: false;
+  isPlaceholderData: false;
+  status: 'pending';
+}
+interface QueryObserverLoadingResult<TData = unknown, TError = DefaultError> extends QueryObserverBaseResult<TData, TError> {
+  data: undefined;
+  error: null;
+  isError: false;
+  isPending: true;
+  isLoading: true;
+  isLoadingError: false;
+  isRefetchError: false;
+  isSuccess: false;
+  isPlaceholderData: false;
+  status: 'pending';
+}
+interface QueryObserverLoadingErrorResult<TData = unknown, TError = DefaultError> extends QueryObserverBaseResult<TData, TError> {
+  data: undefined;
+  error: TError;
+  isError: true;
+  isPending: false;
+  isLoading: false;
+  isLoadingError: true;
+  isRefetchError: false;
+  isSuccess: false;
+  isPlaceholderData: false;
+  status: 'error';
+}
+interface QueryObserverRefetchErrorResult<TData = unknown, TError = DefaultError> extends QueryObserverBaseResult<TData, TError> {
+  data: TData;
+  error: TError;
+  isError: true;
+  isPending: false;
+  isLoading: false;
+  isLoadingError: false;
+  isRefetchError: true;
+  isSuccess: false;
+  isPlaceholderData: false;
+  status: 'error';
+}
+interface QueryObserverSuccessResult<TData = unknown, TError = DefaultError> extends QueryObserverBaseResult<TData, TError> {
+  data: TData;
+  error: null;
+  isError: false;
+  isPending: false;
+  isLoading: false;
+  isLoadingError: false;
+  isRefetchError: false;
+  isSuccess: true;
+  isPlaceholderData: false;
+  status: 'success';
+}
+interface QueryObserverPlaceholderResult<TData = unknown, TError = DefaultError> extends QueryObserverBaseResult<TData, TError> {
+  data: TData;
+  isError: false;
+  error: null;
+  isPending: false;
+  isLoading: false;
+  isLoadingError: false;
+  isRefetchError: false;
+  isSuccess: true;
+  isPlaceholderData: true;
+  status: 'success';
+}
+type DefinedQueryObserverResult<TData = unknown, TError = DefaultError> = QueryObserverRefetchErrorResult<TData, TError> | QueryObserverSuccessResult<TData, TError>;
+type QueryObserverResult<TData = unknown, TError = DefaultError> = DefinedQueryObserverResult<TData, TError> | QueryObserverLoadingErrorResult<TData, TError> | QueryObserverLoadingResult<TData, TError> | QueryObserverPendingResult<TData, TError> | QueryObserverPlaceholderResult<TData, TError>;
+//#endregion
+export { InfiniteData, QueryObserverResult, RefetchOptions };

package/dist/notifications/api/notification.d.ts

@@ -0,0 +1,15 @@
+import { MarkAllReadResponse, MarkReadResponse, NotificationListParams, NotificationListResponse, UnreadCountResponse } from "../types/index.js";
+
+//#region src/notifications/api/notification.d.ts
+declare class NotificationApi {
+  private endpoint;
+  list(params?: NotificationListParams): Promise<NotificationListResponse>;
+  getUnreadCount(): Promise<UnreadCountResponse>;
+  markRead(id: string): Promise<MarkReadResponse>;
+  markAllRead(): Promise<MarkAllReadResponse>;
+  /** Get the SSE stream URL (for EventSource constructor). */
+  getStreamUrl(token: string, organizationId?: string): string;
+}
+declare const notificationApi: NotificationApi;
+//#endregion
+export { NotificationApi, notificationApi };

package/dist/notifications/api/notification.js

@@ -0,0 +1,43 @@
+import { getBaseUrl, handleApiRequest } from "../../core/api-handler.js";
+
+//#region src/notifications/api/notification.ts
+/**
+* Notification API Client
+*
+* Custom API class for in-app notifications.
+* Read-heavy, not standard CRUD — no BaseApi extension.
+*/
+var NotificationApi = class {
+	constructor() {
+		this.endpoint = "/api/v1/notifications";
+	}
+	async list(params = {}) {
+		const query = new URLSearchParams();
+		if (params.page) query.set("page", String(params.page));
+		if (params.limit) query.set("limit", String(params.limit));
+		if (params.unreadOnly) query.set("unreadOnly", "true");
+		if (params.type) query.set("type", params.type);
+		const qs = query.toString();
+		return handleApiRequest("GET", `${this.endpoint}${qs ? `?${qs}` : ""}`);
+	}
+	async getUnreadCount() {
+		return handleApiRequest("GET", `${this.endpoint}/unread-count`);
+	}
+	async markRead(id) {
+		return handleApiRequest("PATCH", `${this.endpoint}/${id}/read`);
+	}
+	async markAllRead() {
+		return handleApiRequest("PATCH", `${this.endpoint}/read-all`);
+	}
+	/** Get the SSE stream URL (for EventSource constructor). */
+	getStreamUrl(token, organizationId) {
+		const base = getBaseUrl();
+		const params = new URLSearchParams({ token });
+		if (organizationId) params.set("orgId", organizationId);
+		return `${base}${this.endpoint}/stream?${params.toString()}`;
+	}
+};
+const notificationApi = new NotificationApi();
+
+//#endregion
+export { NotificationApi, notificationApi };

package/dist/notifications/hooks/notification.d.ts

@@ -0,0 +1,34 @@
+import { InfiniteData } from "../../node_modules/@tanstack/query-core/build/modern/hydration-C-jfQLut.js";
+import { MarkAllReadResponse, MarkReadResponse, NotificationListParams, NotificationListResponse } from "../types/index.js";
+import * as _tanstack_react_query0 from "@tanstack/react-query";
+
+//#region src/notifications/hooks/notification.d.ts
+declare const NOTIFICATION_KEYS: {
+  all: readonly ["notifications"];
+  lists: () => readonly ["notifications", "list"];
+  list: (params: NotificationListParams) => readonly ["notifications", "list", NotificationListParams];
+  unreadCount: () => readonly ["notifications", "unread-count"];
+};
+/**
+ * Infinite query for notification feed (popover + full page).
+ * Fetches pages on scroll with getNextPageParam.
+ */
+declare function useNotifications(params?: Omit<NotificationListParams, "page">): _tanstack_react_query0.UseInfiniteQueryResult<InfiniteData<NotificationListResponse, unknown>, Error>;
+/**
+ * Unread notification count for badge.
+ * Falls back to polling every 60s if SSE is not connected.
+ */
+declare function useUnreadCount(options?: {
+  refetchInterval?: number;
+}): _tanstack_react_query0.UseQueryResult<number, Error>;
+/**
+ * Mark a single notification as read.
+ * Optimistically updates the cache.
+ */
+declare function useMarkRead(): _tanstack_react_query0.UseMutationResult<MarkReadResponse, Error, string, unknown>;
+/**
+ * Mark all notifications as read.
+ */
+declare function useMarkAllRead(): _tanstack_react_query0.UseMutationResult<MarkAllReadResponse, Error, void, unknown>;
+//#endregion
+export { NOTIFICATION_KEYS, useMarkAllRead, useMarkRead, useNotifications, useUnreadCount };

package/dist/notifications/hooks/notification.js

@@ -0,0 +1,86 @@
+"use client";
+
+import { getToastHandler } from "../../core/react/mutation.factory.js";
+import { notificationApi } from "../api/notification.js";
+import { useInfiniteQuery, useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+
+//#region src/notifications/hooks/notification.ts
+/**
+* Notification React Query Hooks
+*
+* Provides hooks for listing, counting, and managing in-app notifications.
+* Uses infinite query for scrollable notification feed.
+*/
+const NOTIFICATION_KEYS = {
+	all: ["notifications"],
+	lists: () => [...NOTIFICATION_KEYS.all, "list"],
+	list: (params) => [...NOTIFICATION_KEYS.lists(), params],
+	unreadCount: () => [...NOTIFICATION_KEYS.all, "unread-count"]
+};
+/**
+* Infinite query for notification feed (popover + full page).
+* Fetches pages on scroll with getNextPageParam.
+*/
+function useNotifications(params = {}) {
+	return useInfiniteQuery({
+		queryKey: NOTIFICATION_KEYS.list(params),
+		queryFn: ({ pageParam }) => notificationApi.list({
+			...params,
+			page: pageParam
+		}),
+		initialPageParam: 1,
+		getNextPageParam: (lastPage) => {
+			const { page, totalPages } = lastPage.pagination;
+			return page < totalPages ? page + 1 : void 0;
+		},
+		staleTime: 3e4
+	});
+}
+/**
+* Unread notification count for badge.
+* Falls back to polling every 60s if SSE is not connected.
+*/
+function useUnreadCount(options = {}) {
+	return useQuery({
+		queryKey: NOTIFICATION_KEYS.unreadCount(),
+		queryFn: () => notificationApi.getUnreadCount(),
+		select: (data) => data.data.count,
+		refetchInterval: options.refetchInterval ?? 6e4,
+		staleTime: 1e4
+	});
+}
+/**
+* Mark a single notification as read.
+* Optimistically updates the cache.
+*/
+function useMarkRead() {
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: (id) => notificationApi.markRead(id),
+		onSuccess: () => {
+			queryClient.invalidateQueries({ queryKey: NOTIFICATION_KEYS.lists() });
+			queryClient.invalidateQueries({ queryKey: NOTIFICATION_KEYS.unreadCount() });
+		}
+	});
+}
+/**
+* Mark all notifications as read.
+*/
+function useMarkAllRead() {
+	const queryClient = useQueryClient();
+	const toast = getToastHandler();
+	return useMutation({
+		mutationFn: () => notificationApi.markAllRead(),
+		onSuccess: (data) => {
+			queryClient.invalidateQueries({ queryKey: NOTIFICATION_KEYS.lists() });
+			queryClient.setQueryData(NOTIFICATION_KEYS.unreadCount(), {
+				success: true,
+				data: { count: 0 }
+			});
+			if (data.data.modifiedCount > 0) toast.success?.(`Marked ${data.data.modifiedCount} notifications as read`);
+		}
+	});
+}
+
+//#endregion
+export { NOTIFICATION_KEYS, useMarkAllRead, useMarkRead, useNotifications, useUnreadCount };

package/dist/notifications/hooks/stream.d.ts

@@ -0,0 +1,22 @@
+import { InAppNotification } from "../types/index.js";
+
+//#region src/notifications/hooks/stream.d.ts
+interface UseNotificationStreamOptions {
+  /** Called when a new notification arrives */
+  onNotification?: (notification: InAppNotification) => void;
+  /** Enable/disable the stream (default: true) */
+  enabled?: boolean;
+  /** Auth token for EventSource connection */
+  token?: string | null;
+  /** Organization/branch ID for scoping */
+  organizationId?: string | null;
+}
+interface UseNotificationStreamResult {
+  /** Whether the SSE connection is active */
+  isConnected: boolean;
+  /** Last received notification */
+  lastEvent: InAppNotification | null;
+}
+declare function useNotificationStream(options?: UseNotificationStreamOptions): UseNotificationStreamResult;
+//#endregion
+export { useNotificationStream };

package/dist/notifications/hooks/stream.js

@@ -0,0 +1,80 @@
+"use client";
+
+import { notificationApi } from "../api/notification.js";
+import { NOTIFICATION_KEYS } from "./notification.js";
+import { useQueryClient } from "@tanstack/react-query";
+import { useCallback, useEffect, useRef, useState } from "react";
+
+//#region src/notifications/hooks/stream.ts
+/**
+* SSE Notification Stream Hook
+*
+* Maintains an EventSource connection for real-time notification delivery.
+* Automatically injects new notifications into React Query cache.
+* Reconnects on branch switch (organizationId change).
+*/
+function useNotificationStream(options = {}) {
+	const { onNotification, enabled = true, token, organizationId } = options;
+	const [isConnected, setIsConnected] = useState(false);
+	const [lastEvent, setLastEvent] = useState(null);
+	const eventSourceRef = useRef(null);
+	const queryClient = useQueryClient();
+	const onNotificationRef = useRef(onNotification);
+	onNotificationRef.current = onNotification;
+	const connect = useCallback(() => {
+		if (!token || !enabled) return;
+		if (eventSourceRef.current) {
+			eventSourceRef.current.close();
+			eventSourceRef.current = null;
+		}
+		const url = notificationApi.getStreamUrl(token, organizationId || void 0);
+		const es = new EventSource(url, { withCredentials: true });
+		eventSourceRef.current = es;
+		es.addEventListener("connected", () => {
+			setIsConnected(true);
+		});
+		es.addEventListener("notification", (event) => {
+			try {
+				const notification = JSON.parse(event.data);
+				setLastEvent(notification);
+				queryClient.setQueryData(NOTIFICATION_KEYS.unreadCount(), (old) => {
+					if (!old) return {
+						success: true,
+						data: { count: 1 }
+					};
+					return {
+						...old,
+						data: { count: old.data.count + 1 }
+					};
+				});
+				queryClient.invalidateQueries({ queryKey: NOTIFICATION_KEYS.lists() });
+				onNotificationRef.current?.(notification);
+			} catch {}
+		});
+		es.onerror = () => {
+			setIsConnected(false);
+		};
+	}, [
+		token,
+		enabled,
+		organizationId,
+		queryClient
+	]);
+	useEffect(() => {
+		connect();
+		return () => {
+			if (eventSourceRef.current) {
+				eventSourceRef.current.close();
+				eventSourceRef.current = null;
+				setIsConnected(false);
+			}
+		};
+	}, [connect]);
+	return {
+		isConnected,
+		lastEvent
+	};
+}
+
+//#endregion
+export { useNotificationStream };

package/dist/notifications/index.d.ts

@@ -0,0 +1,5 @@
+import { InAppNotification, MarkAllReadResponse, MarkReadResponse, NotificationData, NotificationListParams, NotificationListResponse, NotificationPagination, UnreadCountResponse } from "./types/index.js";
+import { NotificationApi, notificationApi } from "./api/notification.js";
+import { NOTIFICATION_KEYS, useMarkAllRead, useMarkRead, useNotifications, useUnreadCount } from "./hooks/notification.js";
+import { useNotificationStream } from "./hooks/stream.js";
+export { type InAppNotification, type MarkAllReadResponse, type MarkReadResponse, NOTIFICATION_KEYS, NotificationApi, type NotificationData, type NotificationListParams, type NotificationListResponse, type NotificationPagination, type UnreadCountResponse, notificationApi, useMarkAllRead, useMarkRead, useNotificationStream, useNotifications, useUnreadCount };

package/dist/notifications/index.js

@@ -0,0 +1,5 @@
+import { NotificationApi, notificationApi } from "./api/notification.js";
+import { NOTIFICATION_KEYS, useMarkAllRead, useMarkRead, useNotifications, useUnreadCount } from "./hooks/notification.js";
+import { useNotificationStream } from "./hooks/stream.js";
+
+export { NOTIFICATION_KEYS, NotificationApi, notificationApi, useMarkAllRead, useMarkRead, useNotificationStream, useNotifications, useUnreadCount };

package/dist/notifications/types/index.d.ts

@@ -0,0 +1,57 @@
+//#region src/notifications/types/index.d.ts
+interface NotificationData {
+  link?: string;
+  entityId?: string;
+  entityType?: string;
+  meta?: Record<string, unknown>;
+}
+interface InAppNotification {
+  _id: string;
+  id?: string;
+  organizationId: string;
+  userId: string;
+  type: string;
+  title: string;
+  message: string;
+  data?: NotificationData;
+  read: boolean;
+  readAt: string | null;
+  priority: 'low' | 'normal' | 'high';
+  createdAt: string;
+  updatedAt: string;
+}
+interface NotificationListParams {
+  page?: number;
+  limit?: number;
+  unreadOnly?: boolean;
+  type?: string;
+}
+interface NotificationPagination {
+  page: number;
+  limit: number;
+  total: number;
+  totalPages: number;
+}
+interface NotificationListResponse {
+  success: boolean;
+  data: InAppNotification[];
+  pagination: NotificationPagination;
+}
+interface UnreadCountResponse {
+  success: boolean;
+  data: {
+    count: number;
+  };
+}
+interface MarkReadResponse {
+  success: boolean;
+  data: InAppNotification;
+}
+interface MarkAllReadResponse {
+  success: boolean;
+  data: {
+    modifiedCount: number;
+  };
+}
+//#endregion
+export { InAppNotification, MarkAllReadResponse, MarkReadResponse, NotificationData, NotificationListParams, NotificationListResponse, NotificationPagination, UnreadCountResponse };

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

@@ -0,0 +1 @@
+import { PaymentApi, paymentApi } from "./payment.js";