@marianmeres/ecsuite 1.3.2 → 2.1.0

package/dist/adapters/http/_http.js

@@ -0,0 +1,75 @@
+/**
+ * @module adapters/http/_http
+ *
+ * Shared primitives for the built-in HTTP adapters.
+ *
+ * Adapters throw raw HTTP errors (`Error` with `.status` and `.body`
+ * attached). `BaseDomainManager` catches and normalizes them to
+ * `DomainError` at the call site — adapters don't normalize themselves.
+ */
+export function resolveFetch(opts) {
+    return opts?.fetch ?? globalThis.fetch.bind(globalThis);
+}
+/** Trailing-slash-safe path joining. */
+export function join(base, path) {
+    if (!base)
+        return path;
+    if (base.endsWith("/"))
+        return `${base.slice(0, -1)}${path}`;
+    return `${base}${path}`;
+}
+export function authHeaders(ctx) {
+    return ctx.jwt ? { Authorization: `Bearer ${ctx.jwt}` } : {};
+}
+export function sessionHeader(ctx) {
+    return ctx.sessionId ? { "X-Session-ID": String(ctx.sessionId) } : {};
+}
+/**
+ * Wrap `fetch`, merge auth + session + content-type headers, and throw a raw
+ * HTTP error (with `.status` and `.body`) on non-OK. Returns `undefined` on
+ * 204 No Content, otherwise the parsed JSON body.
+ */
+export async function requestJson(doFetch, url, init, ctx) {
+    const hasBody = init.body !== undefined && init.body !== null;
+    const res = await doFetch(url, {
+        ...init,
+        headers: {
+            ...(hasBody ? { "Content-Type": "application/json" } : {}),
+            ...(init.headers ?? {}),
+            ...authHeaders(ctx),
+            ...sessionHeader(ctx),
+        },
+        signal: ctx.signal,
+    });
+    if (!res.ok) {
+        const text = await res.text();
+        throw Object.assign(new Error(text || res.statusText), {
+            status: res.status,
+            body: text,
+        });
+    }
+    if (res.status === 204)
+        return undefined;
+    return (await res.json());
+}
+/** Require `ctx.sessionId`; throw a client-side Error if missing. */
+export function requireSessionId(ctx, operation) {
+    if (!ctx.sessionId) {
+        throw Object.assign(new Error(`sessionId required for ${operation}`), { status: 400, body: `sessionId required for ${operation}` });
+    }
+    return String(ctx.sessionId);
+}
+/** Require `ctx.jwt`; throw a client-side Error if missing. */
+export function requireJwt(ctx, operation) {
+    if (!ctx.jwt) {
+        throw Object.assign(new Error(`jwt required for ${operation}`), { status: 401, body: `jwt required for ${operation}` });
+    }
+    return ctx.jwt;
+}
+/** Require `ctx.customerId`; throw a client-side Error if missing. */
+export function requireCustomerId(ctx, operation) {
+    if (!ctx.customerId) {
+        throw Object.assign(new Error(`customerId required for ${operation}`), { status: 400, body: `customerId required for ${operation}` });
+    }
+    return String(ctx.customerId);
+}

package/dist/adapters/http/cart.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @module adapters/http/cart
+ *
+ * Built-in {@link CartAdapter} targeting a REST surface of the shape:
+ *
+ *   GET    {baseUrl}/cart                 → { data: CartData }
+ *   POST   {baseUrl}/cart                 → { data: CartData }   body: CartItem
+ *   PUT    {baseUrl}/cart                 → { data: CartData }   body: { product_id, quantity }
+ *   DELETE {baseUrl}/cart?product_id=...  → { data: CartData }   (remove single item)
+ *   DELETE {baseUrl}/cart                 → { data: CartData }   (clear)
+ *
+ * All mutations require `X-Session-ID` on the request. The adapter reads
+ * `ctx.sessionId` and throws a client-side error if missing so failures
+ * surface before the network round-trip.
+ */
+import type { CartAdapter } from "../../types/adapter.js";
+import { type HttpAdapterOptions } from "./_http.js";
+/** Options for {@link createHttpCartAdapter}. */
+export type HttpCartAdapterOptions = HttpAdapterOptions;
+/** Build a cart adapter against the conventional `/cart` REST surface. */
+export declare function createHttpCartAdapter(opts?: HttpCartAdapterOptions): CartAdapter;

package/dist/adapters/http/cart.js

@@ -0,0 +1,52 @@
+/**
+ * @module adapters/http/cart
+ *
+ * Built-in {@link CartAdapter} targeting a REST surface of the shape:
+ *
+ *   GET    {baseUrl}/cart                 → { data: CartData }
+ *   POST   {baseUrl}/cart                 → { data: CartData }   body: CartItem
+ *   PUT    {baseUrl}/cart                 → { data: CartData }   body: { product_id, quantity }
+ *   DELETE {baseUrl}/cart?product_id=...  → { data: CartData }   (remove single item)
+ *   DELETE {baseUrl}/cart                 → { data: CartData }   (clear)
+ *
+ * All mutations require `X-Session-ID` on the request. The adapter reads
+ * `ctx.sessionId` and throws a client-side error if missing so failures
+ * surface before the network round-trip.
+ */
+import { join, requestJson, requireSessionId, resolveFetch, } from "./_http.js";
+/** Build a cart adapter against the conventional `/cart` REST surface. */
+export function createHttpCartAdapter(opts = {}) {
+    const base = opts.baseUrl ?? "/api/session";
+    const doFetch = resolveFetch(opts);
+    const url = () => join(base, "/cart");
+    return {
+        async fetch(ctx) {
+            const r = await requestJson(doFetch, url(), { method: "GET" }, ctx);
+            return r.data;
+        },
+        async addItem(item, ctx) {
+            requireSessionId(ctx, "cart.addItem");
+            const r = await requestJson(doFetch, url(), { method: "POST", body: JSON.stringify(item) }, ctx);
+            return r.data;
+        },
+        async updateItem(productId, quantity, ctx) {
+            requireSessionId(ctx, "cart.updateItem");
+            const r = await requestJson(doFetch, url(), {
+                method: "PUT",
+                body: JSON.stringify({ product_id: productId, quantity }),
+            }, ctx);
+            return r.data;
+        },
+        async removeItem(productId, ctx) {
+            requireSessionId(ctx, "cart.removeItem");
+            const qs = new URLSearchParams({ product_id: String(productId) });
+            const r = await requestJson(doFetch, `${url()}?${qs}`, { method: "DELETE" }, ctx);
+            return r.data;
+        },
+        async clear(ctx) {
+            requireSessionId(ctx, "cart.clear");
+            const r = await requestJson(doFetch, url(), { method: "DELETE" }, ctx);
+            return r.data;
+        },
+    };
+}

package/dist/adapters/http/customer.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @module adapters/http/customer
+ *
+ * Built-in {@link CustomerAdapter} targeting the owner-scoped customer
+ * REST surface:
+ *
+ *   GET {baseUrl}/me/col/customer/:customerId  → { model_id, data: CustomerData }
+ *   PUT {baseUrl}/me/col/customer/:customerId  → { model_id, data: CustomerData }
+ *
+ * Both calls require `Authorization: Bearer <jwt>` + a `customerId` on the
+ * context (typically resolved from the login subject claim).
+ *
+ * `fetchBySession` is intentionally not implemented — there is no clean
+ * session-scoped read endpoint on the target REST surface; consumers who
+ * need session-based bootstrapping should hydrate from the JWT instead.
+ */
+import type { CustomerAdapter } from "../../types/adapter.js";
+import { type HttpAdapterOptions } from "./_http.js";
+/** Options for {@link createHttpCustomerAdapter}. */
+export type HttpCustomerAdapterOptions = HttpAdapterOptions;
+/** Build a customer adapter against the conventional owner-scoped REST surface. */
+export declare function createHttpCustomerAdapter(opts?: HttpCustomerAdapterOptions): CustomerAdapter;

package/dist/adapters/http/customer.js

@@ -0,0 +1,35 @@
+/**
+ * @module adapters/http/customer
+ *
+ * Built-in {@link CustomerAdapter} targeting the owner-scoped customer
+ * REST surface:
+ *
+ *   GET {baseUrl}/me/col/customer/:customerId  → { model_id, data: CustomerData }
+ *   PUT {baseUrl}/me/col/customer/:customerId  → { model_id, data: CustomerData }
+ *
+ * Both calls require `Authorization: Bearer <jwt>` + a `customerId` on the
+ * context (typically resolved from the login subject claim).
+ *
+ * `fetchBySession` is intentionally not implemented — there is no clean
+ * session-scoped read endpoint on the target REST surface; consumers who
+ * need session-based bootstrapping should hydrate from the JWT instead.
+ */
+import { join, requestJson, requireCustomerId, resolveFetch, } from "./_http.js";
+/** Build a customer adapter against the conventional owner-scoped REST surface. */
+export function createHttpCustomerAdapter(opts = {}) {
+    const base = opts.baseUrl ?? "/api/customer";
+    const doFetch = resolveFetch(opts);
+    const url = (customerId) => join(base, `/me/col/customer/${encodeURIComponent(customerId)}`);
+    return {
+        async fetch(ctx) {
+            const customerId = requireCustomerId(ctx, "customer.fetch");
+            const r = await requestJson(doFetch, url(customerId), { method: "GET" }, ctx);
+            return r.data;
+        },
+        async update(data, ctx) {
+            const customerId = requireCustomerId(ctx, "customer.update");
+            const r = await requestJson(doFetch, url(customerId), { method: "PUT", body: JSON.stringify(data) }, ctx);
+            return r.data;
+        },
+    };
+}

package/dist/adapters/http/mod.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @module adapters/http
+ *
+ * Built-in HTTP adapters targeting a conventional REST surface.
+ *
+ * Each factory takes `{ baseUrl?, fetch? }` and returns an adapter that
+ * conforms to the matching interface from `../../types/adapter.ts`.
+ * Adapters throw raw HTTP errors (`Error` with `.status` + `.body`);
+ * domain managers normalize them to `DomainError`.
+ *
+ * Authentication is carried on the context passed to each call:
+ *   - `ctx.sessionId` → emitted as `X-Session-ID`
+ *   - `ctx.jwt`       → emitted as `Authorization: Bearer <jwt>`
+ */
+export { type HttpAdapterOptions, } from "./_http.js";
+export { createHttpCartAdapter, type HttpCartAdapterOptions } from "./cart.js";
+export { createHttpWishlistAdapter, type HttpWishlistAdapterOptions, } from "./wishlist.js";
+export { createHttpOrderAdapter, type HttpOrderAdapterOptions } from "./order.js";
+export { createHttpCustomerAdapter, type HttpCustomerAdapterOptions, } from "./customer.js";
+export { createHttpPaymentAdapter, type HttpPaymentAdapterOptions, } from "./payment.js";
+export { createHttpProductAdapter, type HttpProductAdapterOptions, } from "./product.js";

package/dist/adapters/http/mod.js

@@ -0,0 +1,20 @@
+/**
+ * @module adapters/http
+ *
+ * Built-in HTTP adapters targeting a conventional REST surface.
+ *
+ * Each factory takes `{ baseUrl?, fetch? }` and returns an adapter that
+ * conforms to the matching interface from `../../types/adapter.ts`.
+ * Adapters throw raw HTTP errors (`Error` with `.status` + `.body`);
+ * domain managers normalize them to `DomainError`.
+ *
+ * Authentication is carried on the context passed to each call:
+ *   - `ctx.sessionId` → emitted as `X-Session-ID`
+ *   - `ctx.jwt`       → emitted as `Authorization: Bearer <jwt>`
+ */
+export { createHttpCartAdapter } from "./cart.js";
+export { createHttpWishlistAdapter, } from "./wishlist.js";
+export { createHttpOrderAdapter } from "./order.js";
+export { createHttpCustomerAdapter, } from "./customer.js";
+export { createHttpPaymentAdapter, } from "./payment.js";
+export { createHttpProductAdapter, } from "./product.js";

package/dist/adapters/http/order.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @module adapters/http/order
+ *
+ * Built-in {@link OrderAdapter} targeting a REST surface of the shape:
+ *
+ *   GET  {baseUrl}/col/order         → { data: [{ model_id, data }, ...] }
+ *   GET  {baseUrl}/col/order/:id     → { model_id, data: OrderData }
+ *   POST {baseUrl}/checkout/start    → { order_id, order: OrderData, ... }
+ *
+ * `create()` only starts checkout — it calls `POST /checkout/start` and
+ * returns the freshly-created pending order. The multi-step completion
+ * flow (addresses → delivery → payment → complete) is not wrapped by this
+ * adapter; callers drive it via their own HTTP calls until ecsuite grows
+ * dedicated verbs.
+ *
+ * Read endpoints require `Authorization: Bearer <jwt>`; checkout/start
+ * additionally requires `X-Session-ID`.
+ */
+import type { OrderAdapter } from "../../types/adapter.js";
+import { type HttpAdapterOptions } from "./_http.js";
+/** Options for {@link createHttpOrderAdapter}. */
+export type HttpOrderAdapterOptions = HttpAdapterOptions;
+/** Build an order adapter against the conventional `/api/order` REST surface. */
+export declare function createHttpOrderAdapter(opts?: HttpOrderAdapterOptions): OrderAdapter;

package/dist/adapters/http/order.js

@@ -0,0 +1,43 @@
+/**
+ * @module adapters/http/order
+ *
+ * Built-in {@link OrderAdapter} targeting a REST surface of the shape:
+ *
+ *   GET  {baseUrl}/col/order         → { data: [{ model_id, data }, ...] }
+ *   GET  {baseUrl}/col/order/:id     → { model_id, data: OrderData }
+ *   POST {baseUrl}/checkout/start    → { order_id, order: OrderData, ... }
+ *
+ * `create()` only starts checkout — it calls `POST /checkout/start` and
+ * returns the freshly-created pending order. The multi-step completion
+ * flow (addresses → delivery → payment → complete) is not wrapped by this
+ * adapter; callers drive it via their own HTTP calls until ecsuite grows
+ * dedicated verbs.
+ *
+ * Read endpoints require `Authorization: Bearer <jwt>`; checkout/start
+ * additionally requires `X-Session-ID`.
+ */
+import { join, requestJson, requireSessionId, resolveFetch, } from "./_http.js";
+/** Build an order adapter against the conventional `/api/order` REST surface. */
+export function createHttpOrderAdapter(opts = {}) {
+    const base = opts.baseUrl ?? "/api/order";
+    const doFetch = resolveFetch(opts);
+    return {
+        async fetchAll(ctx) {
+            const r = await requestJson(doFetch, join(base, "/col/order"), { method: "GET" }, ctx);
+            return r.data ?? [];
+        },
+        async fetchOne(orderId, ctx) {
+            return await requestJson(doFetch, join(base, `/col/order/${encodeURIComponent(String(orderId))}`), { method: "GET" }, ctx);
+        },
+        async create(order, ctx) {
+            requireSessionId(ctx, "order.create");
+            const body = {
+                email: order.customer_email,
+            };
+            if (ctx.customerId)
+                body.customer_id = ctx.customerId;
+            const r = await requestJson(doFetch, join(base, "/checkout/start"), { method: "POST", body: JSON.stringify(body) }, ctx);
+            return { model_id: r.order_id, data: r.order };
+        },
+    };
+}

package/dist/adapters/http/payment.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @module adapters/http/payment
+ *
+ * Built-in {@link PaymentAdapter} targeting a REST surface of the shape:
+ *
+ *   GET  {baseUrl}/by-order/:orderId    → { data: [{ model_id, data: PaymentData }, ...] }
+ *   GET  {baseUrl}/col/payment/:id      → { model_id, data: PaymentData }
+ *   POST {baseUrl}/initiate             → { payment_id, redirect_url }
+ *
+ * All calls require `X-Session-ID`; read endpoints additionally take a JWT
+ * if present.
+ *
+ * `initiate` targets a domain-scoped entry point that shares a service seam
+ * with the order-checkout payment step. The server derives `amount` and
+ * `currency` from the order record (not from the client) and only accepts
+ * an initiation once the order has passed checkout validation (addresses +
+ * delivery set). Callers must supply `provider`, `return_url`, and
+ * `cancel_url` through `PaymentInitConfig` — `return_url` is typed on the
+ * canonical config; `cancel_url` is read off the open index signature.
+ *
+ * `capture()` is intentionally not wired — the target REST surface does not
+ * expose a client-facing capture endpoint (capture is driven server-side by
+ * provider webhooks + the checkout/complete flow). The returned adapter
+ * omits `capture`, so `PaymentManager.capture()` surfaces a NOT_IMPLEMENTED
+ * error as designed.
+ */
+import type { PaymentAdapter } from "../../types/adapter.js";
+import { type HttpAdapterOptions } from "./_http.js";
+/** Options for {@link createHttpPaymentAdapter}. */
+export type HttpPaymentAdapterOptions = HttpAdapterOptions;
+/** Build a payment adapter against the conventional `/api/payment` REST surface. */
+export declare function createHttpPaymentAdapter(opts?: HttpPaymentAdapterOptions): PaymentAdapter;

package/dist/adapters/http/payment.js

@@ -0,0 +1,77 @@
+/**
+ * @module adapters/http/payment
+ *
+ * Built-in {@link PaymentAdapter} targeting a REST surface of the shape:
+ *
+ *   GET  {baseUrl}/by-order/:orderId    → { data: [{ model_id, data: PaymentData }, ...] }
+ *   GET  {baseUrl}/col/payment/:id      → { model_id, data: PaymentData }
+ *   POST {baseUrl}/initiate             → { payment_id, redirect_url }
+ *
+ * All calls require `X-Session-ID`; read endpoints additionally take a JWT
+ * if present.
+ *
+ * `initiate` targets a domain-scoped entry point that shares a service seam
+ * with the order-checkout payment step. The server derives `amount` and
+ * `currency` from the order record (not from the client) and only accepts
+ * an initiation once the order has passed checkout validation (addresses +
+ * delivery set). Callers must supply `provider`, `return_url`, and
+ * `cancel_url` through `PaymentInitConfig` — `return_url` is typed on the
+ * canonical config; `cancel_url` is read off the open index signature.
+ *
+ * `capture()` is intentionally not wired — the target REST surface does not
+ * expose a client-facing capture endpoint (capture is driven server-side by
+ * provider webhooks + the checkout/complete flow). The returned adapter
+ * omits `capture`, so `PaymentManager.capture()` surfaces a NOT_IMPLEMENTED
+ * error as designed.
+ */
+import { join, requestJson, requireSessionId, resolveFetch, } from "./_http.js";
+function unwrapPayment(envelope) {
+    const e = envelope;
+    if (e && typeof e === "object" && e.data && "provider" in e.data) {
+        return e.data;
+    }
+    return envelope;
+}
+/** Build a payment adapter against the conventional `/api/payment` REST surface. */
+export function createHttpPaymentAdapter(opts = {}) {
+    const base = opts.baseUrl ?? "/api/payment";
+    const doFetch = resolveFetch(opts);
+    return {
+        async fetchForOrder(orderId, ctx) {
+            requireSessionId(ctx, "payment.fetchForOrder");
+            const r = await requestJson(doFetch, join(base, `/by-order/${encodeURIComponent(String(orderId))}`), { method: "GET" }, ctx);
+            return (r.data ?? []).map(unwrapPayment);
+        },
+        async fetchOne(paymentId, ctx) {
+            const r = await requestJson(doFetch, join(base, `/col/payment/${encodeURIComponent(String(paymentId))}`), { method: "GET" }, ctx);
+            return unwrapPayment(r);
+        },
+        async initiate(orderId, config, ctx) {
+            requireSessionId(ctx, "payment.initiate");
+            const returnUrl = config.return_url;
+            const cancelUrl = config.cancel_url;
+            if (typeof returnUrl !== "string" || !returnUrl) {
+                throw Object.assign(new Error("return_url required for payment.initiate"), {
+                    status: 400,
+                    body: "return_url required for payment.initiate",
+                });
+            }
+            if (typeof cancelUrl !== "string" || !cancelUrl) {
+                throw Object.assign(new Error("cancel_url required for payment.initiate"), {
+                    status: 400,
+                    body: "cancel_url required for payment.initiate",
+                });
+            }
+            const r = await requestJson(doFetch, join(base, "/initiate"), {
+                method: "POST",
+                body: JSON.stringify({
+                    order_id: orderId,
+                    provider: config.provider,
+                    return_url: returnUrl,
+                    cancel_url: cancelUrl,
+                }),
+            }, ctx);
+            return { id: r.payment_id, redirect_url: r.redirect_url };
+        },
+    };
+}

package/dist/adapters/http/product.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @module adapters/http/product
+ *
+ * Built-in {@link ProductAdapter} targeting a generic collection REST surface:
+ *
+ *   GET {baseUrl}/col/product/:id → { model_id, data: ProductData, ... }
+ *
+ * The `{ model_id, data }` model envelope is unwrapped; the adapter returns
+ * bare `ProductData` / `ProductData[]` to conform to the interface.
+ *
+ * There is no batch endpoint — `fetchMany` issues parallel GETs.
+ */
+import type { ProductAdapter } from "../../types/adapter.js";
+import { type HttpAdapterOptions } from "./_http.js";
+/** Options for {@link createHttpProductAdapter}. */
+export type HttpProductAdapterOptions = HttpAdapterOptions;
+/** Build a product adapter against the conventional `/col/product` REST surface. */
+export declare function createHttpProductAdapter(opts?: HttpProductAdapterOptions): ProductAdapter;

package/dist/adapters/http/product.js

@@ -0,0 +1,30 @@
+/**
+ * @module adapters/http/product
+ *
+ * Built-in {@link ProductAdapter} targeting a generic collection REST surface:
+ *
+ *   GET {baseUrl}/col/product/:id → { model_id, data: ProductData, ... }
+ *
+ * The `{ model_id, data }` model envelope is unwrapped; the adapter returns
+ * bare `ProductData` / `ProductData[]` to conform to the interface.
+ *
+ * There is no batch endpoint — `fetchMany` issues parallel GETs.
+ */
+import { join, requestJson, resolveFetch, } from "./_http.js";
+/** Build a product adapter against the conventional `/col/product` REST surface. */
+export function createHttpProductAdapter(opts = {}) {
+    const base = opts.baseUrl ?? "/api/product";
+    const doFetch = resolveFetch(opts);
+    async function fetchOne(productId, ctx) {
+        const r = await requestJson(doFetch, join(base, `/col/product/${encodeURIComponent(String(productId))}`), { method: "GET" }, ctx);
+        return r.data;
+    }
+    return {
+        fetchOne,
+        async fetchMany(productIds, ctx) {
+            if (productIds.length === 0)
+                return [];
+            return Promise.all(productIds.map((id) => fetchOne(id, ctx)));
+        },
+    };
+}

package/dist/adapters/http/wishlist.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @module adapters/http/wishlist
+ *
+ * Built-in {@link WishlistAdapter} targeting a REST surface of the shape:
+ *
+ *   GET    {baseUrl}/wishlist                 → { data: WishlistData }
+ *   POST   {baseUrl}/wishlist                 → { data: WishlistData, added?: boolean }
+ *   DELETE {baseUrl}/wishlist?product_id=...  → { data: WishlistData }
+ *   DELETE {baseUrl}/wishlist                 → { data: WishlistData } (clear)
+ *
+ * Mutations require `X-Session-ID`. Add/toggle is idempotent on the server
+ * side — adding a product already present is a no-op for the wishlist state.
+ */
+import type { WishlistAdapter } from "../../types/adapter.js";
+import { type HttpAdapterOptions } from "./_http.js";
+/** Options for {@link createHttpWishlistAdapter}. */
+export type HttpWishlistAdapterOptions = HttpAdapterOptions;
+/** Build a wishlist adapter against the conventional `/wishlist` REST surface. */
+export declare function createHttpWishlistAdapter(opts?: HttpWishlistAdapterOptions): WishlistAdapter;

package/dist/adapters/http/wishlist.js

@@ -0,0 +1,42 @@
+/**
+ * @module adapters/http/wishlist
+ *
+ * Built-in {@link WishlistAdapter} targeting a REST surface of the shape:
+ *
+ *   GET    {baseUrl}/wishlist                 → { data: WishlistData }
+ *   POST   {baseUrl}/wishlist                 → { data: WishlistData, added?: boolean }
+ *   DELETE {baseUrl}/wishlist?product_id=...  → { data: WishlistData }
+ *   DELETE {baseUrl}/wishlist                 → { data: WishlistData } (clear)
+ *
+ * Mutations require `X-Session-ID`. Add/toggle is idempotent on the server
+ * side — adding a product already present is a no-op for the wishlist state.
+ */
+import { join, requestJson, requireSessionId, resolveFetch, } from "./_http.js";
+/** Build a wishlist adapter against the conventional `/wishlist` REST surface. */
+export function createHttpWishlistAdapter(opts = {}) {
+    const base = opts.baseUrl ?? "/api/session";
+    const doFetch = resolveFetch(opts);
+    const url = () => join(base, "/wishlist");
+    return {
+        async fetch(ctx) {
+            const r = await requestJson(doFetch, url(), { method: "GET" }, ctx);
+            return r.data;
+        },
+        async addItem(productId, ctx) {
+            requireSessionId(ctx, "wishlist.addItem");
+            const r = await requestJson(doFetch, url(), { method: "POST", body: JSON.stringify({ product_id: productId }) }, ctx);
+            return r.data;
+        },
+        async removeItem(productId, ctx) {
+            requireSessionId(ctx, "wishlist.removeItem");
+            const qs = new URLSearchParams({ product_id: String(productId) });
+            const r = await requestJson(doFetch, `${url()}?${qs}`, { method: "DELETE" }, ctx);
+            return r.data;
+        },
+        async clear(ctx) {
+            requireSessionId(ctx, "wishlist.clear");
+            const r = await requestJson(doFetch, url(), { method: "DELETE" }, ctx);
+            return r.data;
+        },
+    };
+}

package/dist/adapters/mock/cart.d.ts

@@ -2,6 +2,7 @@
  * Mock cart adapter for testing.
  */
 import type { CartData } from "@marianmeres/collection-types";
+import { HTTP_ERROR } from "@marianmeres/http-utils";
 import type { CartAdapter } from "../../types/adapter.js";
 /** Mock cart adapter options */
 export interface MockCartAdapterOptions {
@@ -11,8 +12,9 @@ export interface MockCartAdapterOptions {
     delay?: number;
     /** Force errors for testing */
     forceError?: {
-        operation?: "fetch" | "addItem" | "updateItem" | "removeItem" | "clear" | "sync";
-        code?: string;
+        operation?: "fetch" | "addItem" | "updateItem" | "removeItem" | "clear";
+        /** HTTP error class name from `HTTP_ERROR` (default: "BadRequest") */
+        code?: keyof typeof HTTP_ERROR;
         message?: string;
     };
 }

package/dist/adapters/mock/cart.js

@@ -11,7 +11,9 @@ export function createMockCartAdapter(options = {}) {
     const wait = () => new Promise((r) => setTimeout(r, delay));
     const maybeThrow = (operation) => {
         if (options.forceError?.operation === operation) {
-            throw new HTTP_ERROR.BadRequest(options.forceError.message ?? `Mock error for ${operation}`);
+            const code = options.forceError.code ?? "BadRequest";
+            const Ctor = HTTP_ERROR[code] ?? HTTP_ERROR.BadRequest;
+            throw new Ctor(options.forceError.message ?? `Mock error for ${operation}`);
         }
     };
     return {
@@ -58,11 +60,5 @@ export function createMockCartAdapter(options = {}) {
             cart = { items: [] };
             return structuredClone(cart);
         },
-        async sync(newCart, _ctx) {
-            await wait();
-            maybeThrow("sync");
-            cart = structuredClone(newCart);
-            return structuredClone(cart);
-        },
     };
 }

package/dist/adapters/mock/customer.d.ts

@@ -2,6 +2,7 @@
  * Mock customer adapter for testing.
  */
 import type { CustomerData } from "@marianmeres/collection-types";
+import { HTTP_ERROR } from "@marianmeres/http-utils";
 import type { CustomerAdapter } from "../../types/adapter.js";
 /** Mock customer adapter options */
 export interface MockCustomerAdapterOptions {
@@ -14,7 +15,8 @@ export interface MockCustomerAdapterOptions {
     /** Force errors for testing */
     forceError?: {
         operation?: "fetch" | "fetchBySession" | "update";
-        code?: string;
+        /** HTTP error class name from `HTTP_ERROR` (default: "BadRequest") */
+        code?: keyof typeof HTTP_ERROR;
         message?: string;
     };
 }

package/dist/adapters/mock/customer.js

@@ -14,8 +14,9 @@ export function createMockCustomerAdapter(options = {}) {
     const wait = () => new Promise((r) => setTimeout(r, delay));
     const maybeThrow = (operation) => {
         if (options.forceError?.operation === operation) {
-            throw new HTTP_ERROR.BadRequest(options.forceError.message ??
-                `Mock error for ${operation}`);
+            const code = options.forceError.code ?? "BadRequest";
+            const Ctor = HTTP_ERROR[code] ?? HTTP_ERROR.BadRequest;
+            throw new Ctor(options.forceError.message ?? `Mock error for ${operation}`);
         }
     };
     const hasFetchBySession = "guestData" in options ||

package/dist/adapters/mock/order.d.ts

@@ -2,6 +2,7 @@
  * Mock order adapter for testing.
  */
 import type { OrderData } from "@marianmeres/collection-types";
+import { HTTP_ERROR } from "@marianmeres/http-utils";
 import type { OrderAdapter } from "../../types/adapter.js";
 /** Mock order adapter options */
 export interface MockOrderAdapterOptions {
@@ -12,7 +13,8 @@ export interface MockOrderAdapterOptions {
     /** Force errors for testing */
     forceError?: {
         operation?: "fetchAll" | "fetchOne" | "create";
-        code?: string;
+        /** HTTP error class name from `HTTP_ERROR` (default: "BadRequest") */
+        code?: keyof typeof HTTP_ERROR;
         message?: string;
     };
 }