@caldik/client 0.0.8 → 0.0.9

package/README.md

@@ -22,3 +22,31 @@ const caldik = new CaldikClient({
   apiKey: process.env.CALDIK_PRIVATE_API_KEY,
 })
 ```
+
+## Cart and discounts
+
+
+```ts
+const cart = caldik.cart.add({
+  productId: "PRODUCT_...",
+  productVariantId: "PRODUCT_VARIANT_...",
+  quantity: 1,
+})
+
+caldik.cart.updateQuantity(cart.items[0].id, 3)
+caldik.cart.remove(cart.items[0].id)
+```
+
+```ts
+await caldik.cart.applyDiscount("SAVE10")
+
+const result = await caldik.cart.checkout({
+  paymentMethod: "stripe",
+  successUrl: "https://shop.example/success",
+  cancelUrl: "https://shop.example/cart",
+})
+```
+
+Use `caldik.discounts.check({ code, items })` when a cart should be managed by
+the application instead of the SDK.
+

package/dist/index.d.mts

@@ -148,6 +148,7 @@ interface CreateOrderInput {
   email?: string;
   paymentMethod: CheckoutPaymentProviderId;
   items: CommerceItem[];
+  discountCode?: string;
   successUrl?: string;
   cancelUrl?: string;
 }
@@ -158,7 +159,13 @@ interface StorefrontOrder {
   customerId: string | null;
   paymentStatus: string;
   fulfillmentStatus: string;
+  subtotal: string;
   amount: string;
+  discount: {
+    code: string;
+    percentage: string;
+    amount: string;
+  } | null;
   currency: string;
 }
 interface CheckoutPayment {
@@ -202,18 +209,6 @@ interface SubscriptionResponse {
     checkoutSessionId: string;
   };
 }
-interface StoreWebhookEventDefinition {
-  name: StoreWebhookEventName;
-  resource: string;
-  action: string;
-  description: string;
-}
-interface StoreWebhookEventsResponse {
-  success: boolean;
-  apiVersion: "v1";
-  catalogVersion: string;
-  events: StoreWebhookEventDefinition[];
-}
 interface StoreWebhookEvent<TObject extends Record<string, unknown> = Record<string, unknown>> {
   id: string;
   type: StoreWebhookEventName;
@@ -257,6 +252,7 @@ declare class CaldikHttpClient {
   private readonly apiUrl;
   private readonly storeId?;
   constructor(options?: HttpClientOptions);
+  storeContextId(): string | null;
   private baseUrl;
   private request;
   get<T>(path: string, params?: Record<string, string | number>, options?: RequestOptions): Promise<T>;
@@ -316,12 +312,66 @@ declare class SubscriptionsApi {
   create(input: CreateSubscriptionInput): Promise<SubscriptionResponse>;
 }
 //#endregion
-//#region src/webhooks.d.ts
-declare class WebhooksApi {
+//#region src/discounts.d.ts
+interface CheckDiscountInput {
+  code: string;
+  items: CommerceItem[];
+}
+interface AppliedDiscount {
+  code: string;
+  percentage: string;
+}
+interface DiscountQuoteResponse {
+  success: boolean;
+  discount: AppliedDiscount;
+  subtotal: string;
+  discountAmount: string;
+  total: string;
+  currency: string;
+}
+declare class DiscountsApi {
+  private client;
+  constructor(client: CaldikHttpClient);
+  check(input: CheckDiscountInput): Promise<DiscountQuoteResponse>;
+}
+//#endregion
+//#region src/cart.d.ts
+interface CartItem {
+  id: string;
+  productId: string;
+  productVariantId?: string;
+  quantity: number;
+}
+interface CartDiscount {
+  code: string;
+  percentage: string;
+  subtotal: string;
+  discountAmount: string;
+  total: string;
+  currency: string;
+}
+interface CartSnapshot {
+  items: CartItem[];
+  discount: CartDiscount | null;
+}
+type CartCheckoutInput = Omit<CreateOrderInput, "items" | "discountCode">;
+declare class CartApi {
   private client;
+  private memory;
   constructor(client: CaldikHttpClient);
-  /** Lists the canonical events accepted by store webhook subscriptions. */
-  events(): Promise<StoreWebhookEventsResponse>;
+  private storageKey;
+  private read;
+  private write;
+  get(): CartSnapshot;
+  add(item: ProductCommerceItem): CartSnapshot;
+  updateQuantity(itemId: string, nextQuantity: number): CartSnapshot;
+  remove(itemId: string): CartSnapshot;
+  clear(): CartSnapshot;
+  private commerceItems;
+  checkDiscount(code: string): Promise<DiscountQuoteResponse>;
+  applyDiscount(code: string): Promise<CartSnapshot>;
+  removeDiscount(): CartSnapshot;
+  checkout(input: CartCheckoutInput): Promise<OrderResponse>;
 }
 //#endregion
 //#region src/index.d.ts
@@ -340,8 +390,9 @@ declare class CaldikClient {
   readonly checkout: CheckoutApi;
   readonly customer: CustomerApi;
   readonly subscriptions: SubscriptionsApi;
-  readonly webhooks: WebhooksApi;
+  readonly discounts: DiscountsApi;
+  readonly cart: CartApi;
   constructor(options?: CaldikClientOptions);
 }
 //#endregion
-export { CaldikClient, CaldikClientOptions, CategoriesResponse, Category, CategoryDetails, CategoryMetadata, CategoryProduct, CategoryResponse, CheckoutPayment, CheckoutPaymentProviderId, CommerceItem, CreateOrderInput, CreateSubscriptionInput, CustomerLoginResponse, CustomerLoginVerifyResponse, ManualCommerceItem, OrderResponse, PaymentProviderId, Product, ProductCommerceItem, ProductCustomField, ProductCustomFieldInputType, ProductCustomFieldOption, ProductMetadata, ProductResponse, ProductTag, ProductVariant, ProductsResponse, Review, ReviewsResponse, Store, StoreResponse, StoreWebhookEvent, StoreWebhookEventDefinition, StoreWebhookEventName, StoreWebhookEventsResponse, StorefrontMetadata, StorefrontOrder, SubscriptionPaymentProviderId, SubscriptionResponse, checkoutPaymentProviderIds, paymentProviderIds, storeWebhookEventNames, subscriptionPaymentProviderIds };
+export { AppliedDiscount, CaldikClient, CaldikClientOptions, CartApi, CartCheckoutInput, CartDiscount, CartItem, CartSnapshot, CategoriesResponse, Category, CategoryDetails, CategoryMetadata, CategoryProduct, CategoryResponse, CheckDiscountInput, CheckoutPayment, CheckoutPaymentProviderId, CommerceItem, CreateOrderInput, CreateSubscriptionInput, CustomerLoginResponse, CustomerLoginVerifyResponse, DiscountQuoteResponse, DiscountsApi, ManualCommerceItem, OrderResponse, PaymentProviderId, Product, ProductCommerceItem, ProductCustomField, ProductCustomFieldInputType, ProductCustomFieldOption, ProductMetadata, ProductResponse, ProductTag, ProductVariant, ProductsResponse, Review, ReviewsResponse, Store, StoreResponse, StoreWebhookEvent, StoreWebhookEventName, StorefrontMetadata, StorefrontOrder, SubscriptionPaymentProviderId, SubscriptionResponse, checkoutPaymentProviderIds, paymentProviderIds, storeWebhookEventNames, subscriptionPaymentProviderIds };

package/dist/index.mjs

@@ -8,7 +8,6 @@ function firstValue(...values) {
 function importMetaEnvironment() {
 	return import.meta.env;
 }
-/** Public context exposed by Next/Vinext, Vite, or Astro during `caldik dev`. */
 function browserBuildStoreId() {
 	const environment = importMetaEnvironment();
 	return firstValue(typeof process === "undefined" ? void 0 : process.env.NEXT_PUBLIC_CALDIK_STORE_ID, environment?.VITE_CALDIK_STORE_ID, environment?.PUBLIC_CALDIK_STORE_ID);
@@ -58,6 +57,9 @@ var CaldikHttpClient = class {
 		if (isBrowserRuntime() && this.apiKey) throw new Error("Caldik private API keys cannot be used in browser code");
 		this.storeId = configuredStoreId || (isBrowserRuntime() ? browserRuntimeStoreId() || void 0 : void 0);
 	}
+	storeContextId() {
+		return this.storeId || boundRuntimeStoreId();
+	}
 	baseUrl() {
 		if (isBrowserRuntime()) {
 			const storeId = this.storeId;
@@ -191,15 +193,176 @@ var SubscriptionsApi = class {
 	}
 };
 //#endregion
-//#region src/webhooks.ts
-var WebhooksApi = class {
+//#region src/discounts.ts
+var DiscountsApi = class {
 	client;
 	constructor(client) {
 		this.client = client;
 	}
-	/** Lists the canonical events accepted by store webhook subscriptions. */
-	events() {
-		return this.client.get("/webhooks/events");
+	check(input) {
+		return this.client.post("/discounts/check", input, { access: "public" });
+	}
+};
+//#endregion
+//#region src/cart.ts
+const CART_VERSION = 1;
+const MAX_QUANTITY = 999999;
+function cartItemId(item) {
+	return item.productVariantId ? `${item.productId}:${item.productVariantId}` : item.productId;
+}
+function quantity(value, allowZero = false) {
+	const normalized = value ?? 1;
+	const minimum = allowZero ? 0 : 1;
+	if (!Number.isInteger(normalized) || normalized < minimum || normalized > MAX_QUANTITY) throw new Error(`Cart quantity must be an integer between ${minimum} and ${MAX_QUANTITY}`);
+	return normalized;
+}
+function cloneSnapshot(state) {
+	return {
+		items: state.items.map((item) => ({ ...item })),
+		discount: state.discount ? { ...state.discount } : null
+	};
+}
+function isCartItem(value) {
+	if (!value || typeof value !== "object") return false;
+	const item = value;
+	return typeof item.id === "string" && typeof item.productId === "string" && (item.productVariantId === void 0 || typeof item.productVariantId === "string") && typeof item.quantity === "number" && Number.isInteger(item.quantity) && item.quantity > 0 && item.quantity <= MAX_QUANTITY;
+}
+function isCartDiscount(value) {
+	if (!value || typeof value !== "object") return false;
+	const discount = value;
+	return typeof discount.code === "string" && typeof discount.percentage === "string" && typeof discount.subtotal === "string" && typeof discount.discountAmount === "string" && typeof discount.total === "string" && typeof discount.currency === "string";
+}
+var CartApi = class {
+	client;
+	memory = {
+		version: CART_VERSION,
+		items: [],
+		discount: null
+	};
+	constructor(client) {
+		this.client = client;
+	}
+	storageKey() {
+		const storeId = this.client.storeContextId();
+		return storeId ? `caldik:cart:${storeId}` : null;
+	}
+	read() {
+		const key = this.storageKey();
+		if (key && typeof localStorage !== "undefined") try {
+			const value = localStorage.getItem(key);
+			if (value) {
+				const parsed = JSON.parse(value);
+				if (parsed.version === CART_VERSION && Array.isArray(parsed.items) && parsed.items.every(isCartItem)) this.memory = {
+					version: CART_VERSION,
+					items: parsed.items,
+					discount: isCartDiscount(parsed.discount) ? parsed.discount : null
+				};
+			}
+		} catch {}
+		return this.memory;
+	}
+	write(state) {
+		this.memory = {
+			version: CART_VERSION,
+			...cloneSnapshot(state)
+		};
+		const key = this.storageKey();
+		if (key && typeof localStorage !== "undefined") try {
+			localStorage.setItem(key, JSON.stringify(this.memory));
+		} catch {}
+		return this.get();
+	}
+	get() {
+		return cloneSnapshot(this.read());
+	}
+	add(item) {
+		const productId = item.productId.trim();
+		const productVariantId = item.productVariantId?.trim() || "";
+		if (!productId) throw new Error("Cart productId is required");
+		const state = this.get();
+		const id = cartItemId({
+			productId,
+			productVariantId
+		});
+		const existing = state.items.find((entry) => entry.id === id);
+		const addedQuantity = quantity(item.quantity);
+		if (existing) existing.quantity = quantity(existing.quantity + addedQuantity);
+		else state.items.push({
+			id,
+			productId,
+			...productVariantId ? { productVariantId } : {},
+			quantity: addedQuantity
+		});
+		state.discount = null;
+		return this.write(state);
+	}
+	updateQuantity(itemId, nextQuantity) {
+		const state = this.get();
+		const normalized = quantity(nextQuantity, true);
+		const index = state.items.findIndex((item) => item.id === itemId);
+		if (index === -1) throw new Error("Cart item not found");
+		if (normalized === 0) state.items.splice(index, 1);
+		else state.items[index].quantity = normalized;
+		state.discount = null;
+		return this.write(state);
+	}
+	remove(itemId) {
+		const state = this.get();
+		const items = state.items.filter((item) => item.id !== itemId);
+		if (items.length === state.items.length) throw new Error("Cart item not found");
+		return this.write({
+			items,
+			discount: null
+		});
+	}
+	clear() {
+		return this.write({
+			items: [],
+			discount: null
+		});
+	}
+	commerceItems() {
+		return this.get().items.map(({ productId, productVariantId, quantity }) => ({
+			productId,
+			...productVariantId ? { productVariantId } : {},
+			quantity
+		}));
+	}
+	async checkDiscount(code) {
+		const items = this.commerceItems();
+		if (items.length === 0) throw new Error("Cannot check a discount on an empty cart");
+		return this.client.post("/discounts/check", {
+			code,
+			items
+		}, { access: "public" });
+	}
+	async applyDiscount(code) {
+		const quote = await this.checkDiscount(code);
+		const state = this.get();
+		state.discount = {
+			...quote.discount,
+			subtotal: quote.subtotal,
+			discountAmount: quote.discountAmount,
+			total: quote.total,
+			currency: quote.currency
+		};
+		return this.write(state);
+	}
+	removeDiscount() {
+		const state = this.get();
+		state.discount = null;
+		return this.write(state);
+	}
+	async checkout(input) {
+		const state = this.get();
+		if (state.items.length === 0) throw new Error("Cannot checkout an empty cart");
+		const response = await this.client.post("/checkouts", {
+			...input,
+			items: this.commerceItems(),
+			...state.discount ? { discountCode: state.discount.code } : {}
+		}, { access: "public" });
+		this.clear();
+		return response;
 	}
 };
 //#endregion
@@ -254,7 +417,8 @@ var CaldikClient = class {
 	checkout;
 	customer;
 	subscriptions;
-	webhooks;
+	discounts;
+	cart;
 	constructor(options = {}) {
 		const client = new CaldikHttpClient({
 			apiKey: options.apiKey,
@@ -268,8 +432,9 @@ var CaldikClient = class {
 		this.checkout = new CheckoutApi(client);
 		this.customer = new CustomerApi(client);
 		this.subscriptions = new SubscriptionsApi(client);
-		this.webhooks = new WebhooksApi(client);
+		this.discounts = new DiscountsApi(client);
+		this.cart = new CartApi(client);
 	}
 };
 //#endregion
-export { CaldikClient, checkoutPaymentProviderIds, paymentProviderIds, storeWebhookEventNames, subscriptionPaymentProviderIds };
+export { CaldikClient, CartApi, DiscountsApi, checkoutPaymentProviderIds, paymentProviderIds, storeWebhookEventNames, subscriptionPaymentProviderIds };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@caldik/client",
-  "version": "0.0.8",
+  "version": "0.0.9",
   "type": "module",
   "main": "./dist/index.mjs",
   "types": "./dist/index.d.mts",