@cobrastyle/adapter-brink 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Cobrastyle
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/adapter.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Brink Storefront Adapter
+ *
+ * Implements only the features Brink owns:
+ *   - cart (session-bound shopper API)
+ *   - checkout.placeOrder (management API import)
+ *   - customer.getOrders / getOrder (management API)
+ *
+ * Other features (product, category, search, customer auth) intentionally
+ * absent — route those to a different adapter (e.g. `enad`) via
+ * `features` / `methods` in storefront.config.ts.
+ *
+ * IMPORTANT INVARIANTS
+ *   - The `cartId` parameter on cart methods IS the Brink shopper session
+ *     token. We never have a "fetch cart by db id" — Brink's session token
+ *     IS the bearer credential for that session.
+ *   - The session token can rotate (e.g. on `/sessions/migrate` or
+ *     `/checkout/start`). When that happens, we return a Cart whose `id`
+ *     reflects the new token — the caller MUST update the cookie.
+ *   - Money: Brink uses minor units; the Cart contract uses major. Mappers
+ *     convert. Inputs to Brink (e.g. shipping fee in placeOrder body)
+ *     multiply major × 100.
+ */
+import type { PartialStorefrontAdapter, CustomerOrdersResult, CustomerOrder } from '@cobrastyle/shared-types';
+export declare const brinkAdapter: PartialStorefrontAdapter;
+/**
+ * Look up orders by email directly against the Brink management API.
+ * Use this from a storefront.config.ts `methods.customer.getOrders` override
+ * to inject the email from your auth adapter.
+ */
+export declare function getBrinkOrdersByEmail(email: string, page?: number, pageSize?: number): Promise<CustomerOrdersResult>;
+/**
+ * Look up orders by merchant reference (typically a B2B organisation id).
+ */
+export declare function getBrinkOrdersByMerchantRef(ref: string): Promise<CustomerOrder[]>;

package/dist/adapter.js

@@ -0,0 +1,299 @@
+import { getConfig, getCartStateStore } from './config';
+import { shopperFetch } from './client/shopper';
+import { managementFetch } from './client/management';
+import { BrinkFetchError } from './client/errors';
+import { mapShopperCart } from './mappers/cart';
+import { mapBrinkOrder } from './mappers/order';
+import { buildBrinkOrderBody } from './mappers/place-order';
+// ─── Helpers ────────────────────────────────────────────────────────────────
+async function readSession(token) {
+    return shopperFetch({
+        endpoint: '/shopper/sessions',
+        method: 'GET',
+        token,
+    });
+}
+async function startSession() {
+    const cfg = getConfig();
+    const body = {
+        storeGroupId: cfg.defaultStoreGroupId,
+        countryCode: cfg.defaultCountryCode,
+        languageCode: cfg.defaultLanguageCode,
+    };
+    return shopperFetch({
+        endpoint: '/shopper/sessions/start',
+        method: 'POST',
+        body,
+    });
+}
+async function buildCart(session, cartIdHint) {
+    // Brink rotates the token on some endpoints, so we always trust the one
+    // returned in the response — but if the session was just refreshed
+    // through GET /shopper/sessions (where there is no token in the body),
+    // the caller-provided token is still valid.
+    const cartId = session.token || cartIdHint || '';
+    const store = getCartStateStore();
+    const side = await store.get(cartId);
+    return mapShopperCart(session.cart, side, cartId);
+}
+async function patchSide(cartId, patch) {
+    const store = getCartStateStore();
+    const current = (await store.get(cartId)) ?? {};
+    await store.set(cartId, { ...current, ...patch });
+}
+function generateImportId() {
+    // RFC 4122 v4 if available, otherwise a sortable random id.
+    if (typeof globalThis.crypto !== 'undefined' &&
+        typeof globalThis.crypto.randomUUID === 'function') {
+        return globalThis.crypto.randomUUID();
+    }
+    return `imp_${Date.now()}_${Math.random().toString(36).slice(2, 12)}`;
+}
+// ─── Adapter ────────────────────────────────────────────────────────────────
+export const brinkAdapter = {
+    cart: {
+        create: async () => {
+            const session = await startSession();
+            return buildCart(session);
+        },
+        get: async (cartId) => {
+            try {
+                const session = await readSession(cartId);
+                return buildCart(session, cartId);
+            }
+            catch (err) {
+                // 401/403/404 all mean "this token is no longer a valid session".
+                // Return null so the storefront can clear the cookie and start fresh.
+                if (err instanceof BrinkFetchError &&
+                    (err.statusCode === 401 ||
+                        err.statusCode === 403 ||
+                        err.statusCode === 404)) {
+                    return null;
+                }
+                throw err;
+            }
+        },
+        addItem: async (cartId, input) => {
+            // Brink only accepts productVariantId. We accept either an explicit
+            // variant id (preferred) or fall back to the sku field if the caller
+            // is treating the SKU as the variant id.
+            const productVariantId = input.productVariantId ?? input.sku;
+            if (!productVariantId) {
+                throw new Error('Brink addItem requires productVariantId (pass via AddToCartInput.productVariantId, or use the sku field as the variant id).');
+            }
+            const body = {
+                productVariantId,
+                quantity: input.quantity,
+                options: input.selectedOptions
+                    ? Object.fromEntries(input.selectedOptions.map((v, i) => [`option_${i}`, v]))
+                    : undefined,
+            };
+            const session = await shopperFetch({
+                endpoint: '/shopper/sessions/items',
+                method: 'POST',
+                token: cartId,
+                body,
+            });
+            return buildCart(session, cartId);
+        },
+        updateItem: async (cartId, input) => {
+            const session = await shopperFetch({
+                endpoint: `/shopper/sessions/items/${encodeURIComponent(input.itemUid)}`,
+                method: 'PUT',
+                token: cartId,
+                body: { quantity: input.quantity },
+            });
+            return buildCart(session, cartId);
+        },
+        removeItem: async (cartId, itemUid) => {
+            const session = await shopperFetch({
+                endpoint: `/shopper/sessions/items/${encodeURIComponent(itemUid)}`,
+                method: 'DELETE',
+                token: cartId,
+            });
+            return buildCart(session, cartId);
+        },
+        applyCoupon: async (cartId, input) => {
+            const session = await shopperFetch({
+                endpoint: '/shopper/sessions/discount-codes',
+                method: 'POST',
+                token: cartId,
+                body: { discountCode: input.couponCode },
+            });
+            return buildCart(session, cartId);
+        },
+        removeCoupon: async (cartId, couponCode) => {
+            const session = await shopperFetch({
+                endpoint: `/shopper/sessions/discount-codes/${encodeURIComponent(couponCode)}`,
+                method: 'DELETE',
+                token: cartId,
+            });
+            return buildCart(session, cartId);
+        },
+        setEmail: async (cartId, email) => {
+            await patchSide(cartId, { email });
+            const session = await readSession(cartId);
+            return buildCart(session, cartId);
+        },
+    },
+    checkout: {
+        setShippingAddress: async (cartId, input) => {
+            const address = {
+                ...input.address,
+                country: input.address.countryCode,
+            };
+            await patchSide(cartId, { shippingAddress: address });
+            const session = await readSession(cartId);
+            return buildCart(session, cartId);
+        },
+        setBillingAddress: async (cartId, input) => {
+            const address = {
+                ...input.address,
+                country: input.address.countryCode,
+            };
+            await patchSide(cartId, { billingAddress: address });
+            const session = await readSession(cartId);
+            return buildCart(session, cartId);
+        },
+        setShippingMethod: async (cartId, input) => {
+            // Pull the chosen option from the brink session (canonical source) so
+            // we capture price/title from Brink rather than trusting the caller.
+            const session = await readSession(cartId);
+            const option = session.cart.shippingOptions?.find((o) => o.id === input.methodCode || o.id === input.carrierCode);
+            if (!option) {
+                throw new Error(`Shipping method "${input.methodCode}" not available on this cart`);
+            }
+            await patchSide(cartId, {
+                shippingMethod: {
+                    carrierCode: option.id,
+                    carrierTitle: option.displayName || option.name,
+                    methodCode: option.id,
+                    methodTitle: option.displayName || option.name,
+                    amount: (option.salePriceAmount || option.basePriceAmount) / 100,
+                    currency: session.cart.currencyCode,
+                },
+            });
+            return buildCart(session, cartId);
+        },
+        setPaymentMethod: async (cartId, input) => {
+            await patchSide(cartId, {
+                paymentMethod: { code: input.code, title: input.code },
+            });
+            const session = await readSession(cartId);
+            return buildCart(session, cartId);
+        },
+        placeOrder: async (cartId) => {
+            const store = getCartStateStore();
+            try {
+                const [session, side] = await Promise.all([
+                    readSession(cartId),
+                    store.get(cartId),
+                ]);
+                if (!side?.shippingAddress || !side?.billingAddress) {
+                    return {
+                        success: false,
+                        error: 'Cannot place order: shipping/billing address not set. Call setShippingAddress + setBillingAddress first.',
+                    };
+                }
+                const body = buildBrinkOrderBody({
+                    session,
+                    side,
+                    importId: generateImportId(),
+                    date: new Date().toISOString(),
+                });
+                const result = await managementFetch({
+                    endpoint: '/order/imports/orders',
+                    method: 'POST',
+                    body,
+                });
+                await store.clear(cartId);
+                return {
+                    success: true,
+                    orderId: result.orderId,
+                    orderNumber: result.orderReference,
+                };
+            }
+            catch (err) {
+                return {
+                    success: false,
+                    error: err instanceof Error ? err.message : 'Failed to place order',
+                };
+            }
+        },
+    },
+    customer: {
+        // Stub the auth surface — Brink doesn't own customer auth. Route auth
+        // to enad (or magento2) via storefront.config.ts. These are present
+        // because TypeScript requires CustomerAdapter to declare them, but they
+        // throw if accidentally invoked (which won't happen if routing is set
+        // up correctly).
+        login: async () => {
+            throw new Error('Brink does not implement customer.login — route customer auth to a different adapter.');
+        },
+        register: async () => {
+            throw new Error('Brink does not implement customer.register — route customer auth to a different adapter.');
+        },
+        logout: async () => { },
+        get: async () => null,
+        update: async () => {
+            throw new Error('Brink does not implement customer.update — route customer auth to a different adapter.');
+        },
+        changePassword: async () => false,
+        getOrders: async (_token, page = 1, pageSize = 10) => {
+            // Brink lookup is by email or merchant-ref. The caller passes a
+            // session token (auth-adapter token), so we need the email — which
+            // is on the customer record. The recommended wiring is a method-level
+            // override in storefront.config.ts that resolves the email first
+            // (see README). As a fallback we error out cleanly.
+            throw new Error('Brink getOrders requires a customer email. Override customer.getOrders in storefront.config.ts to resolve the email from your auth adapter, then call brinkAdapter via the override (see README).');
+        },
+        getOrder: async (_token, orderId) => {
+            try {
+                const order = await managementFetch({
+                    endpoint: `/order/orders/${encodeURIComponent(orderId)}`,
+                    method: 'GET',
+                });
+                return mapBrinkOrder(order);
+            }
+            catch (err) {
+                if (err instanceof BrinkFetchError &&
+                    (err.statusCode === 404 || err.statusCode === 403)) {
+                    return null;
+                }
+                throw err;
+            }
+        },
+    },
+};
+// ─── Standalone helpers exposed for storefront overrides ────────────────────
+/**
+ * Look up orders by email directly against the Brink management API.
+ * Use this from a storefront.config.ts `methods.customer.getOrders` override
+ * to inject the email from your auth adapter.
+ */
+export async function getBrinkOrdersByEmail(email, page = 1, pageSize = 10) {
+    const result = await managementFetch({
+        endpoint: `/order/orders/email/${encodeURIComponent(email)}`,
+        method: 'GET',
+    });
+    const items = (result.orderSummaries ?? []).map(mapBrinkOrder);
+    return {
+        items: items.slice((page - 1) * pageSize, page * pageSize),
+        totalCount: items.length,
+        pageInfo: {
+            currentPage: page,
+            pageSize,
+            totalPages: Math.max(1, Math.ceil(items.length / pageSize)),
+        },
+    };
+}
+/**
+ * Look up orders by merchant reference (typically a B2B organisation id).
+ */
+export async function getBrinkOrdersByMerchantRef(ref) {
+    const result = await managementFetch({
+        endpoint: `/order/orders/merchant-ref1/${encodeURIComponent(ref)}`,
+        method: 'GET',
+    });
+    return (result.orderSummaries ?? []).map(mapBrinkOrder);
+}

package/dist/client/errors.d.ts

@@ -0,0 +1,8 @@
+import type { BrinkErrorBody } from '../types';
+export declare class BrinkFetchError extends Error {
+    readonly statusCode: number;
+    readonly requestId?: string;
+    readonly errors?: string[];
+    readonly body?: BrinkErrorBody;
+    constructor(message: string, statusCode: number, body?: BrinkErrorBody);
+}

package/dist/client/errors.js

@@ -0,0 +1,14 @@
+export class BrinkFetchError extends Error {
+    statusCode;
+    requestId;
+    errors;
+    body;
+    constructor(message, statusCode, body) {
+        super(message);
+        this.name = 'BrinkFetchError';
+        this.statusCode = statusCode;
+        this.body = body;
+        this.requestId = body?.requestId;
+        this.errors = body?.errors;
+    }
+}

package/dist/client/management.d.ts

@@ -0,0 +1,7 @@
+interface ManagementFetchOpts {
+    endpoint: string;
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+    body?: unknown;
+}
+export declare function managementFetch<T>(opts: ManagementFetchOpts, attempt?: number): Promise<T>;
+export {};

package/dist/client/management.js

@@ -0,0 +1,35 @@
+/**
+ * Management API client. Authenticates with an OAuth2 access token + a
+ * static `x-api-key` header. On 401/403 the token is invalidated and the
+ * request is retried once with a fresh token.
+ */
+import { getConfig } from '../config';
+import { BrinkFetchError } from './errors';
+import { getOrRefresh, invalidate } from './oauth';
+export async function managementFetch(opts, attempt = 0) {
+    const cfg = getConfig();
+    const token = await getOrRefresh(attempt > 0);
+    const headers = {
+        'Content-Type': 'application/json',
+        Authorization: token,
+        'x-api-key': cfg.managementApiKey ?? 'BrinkCommerceDefaultApiKey',
+    };
+    const res = await fetch(`${cfg.managementApiUrl}${opts.endpoint}`, {
+        method: opts.method,
+        headers,
+        body: opts.body !== undefined ? JSON.stringify(opts.body) : undefined,
+        cache: 'no-store',
+    });
+    if (res.status === 204)
+        return {};
+    if ((res.status === 401 || res.status === 403) && attempt === 0) {
+        invalidate();
+        return managementFetch(opts, attempt + 1);
+    }
+    const json = (await res.json().catch(() => ({})));
+    if (!res.ok) {
+        const err = json;
+        throw new BrinkFetchError(err.error || err.message || `Brink management API error (${res.status})`, res.status, err);
+    }
+    return json;
+}

package/dist/client/oauth.d.ts

@@ -0,0 +1,2 @@
+export declare function getOrRefresh(forceRefresh?: boolean): Promise<string>;
+export declare function invalidate(): void;

package/dist/client/oauth.js

@@ -0,0 +1,61 @@
+/**
+ * OAuth2 client_credentials token cache for the Brink management API.
+ *
+ * SCOPE: in-process module-level cache. Each serverless instance refreshes
+ * once on cold start. For multi-instance high-throughput production, swap
+ * this for a shared cache (Vercel Edge Config / KV / Redis). The replacement
+ * point is `getOrRefresh()` — keep the same signature.
+ */
+import { getConfig } from '../config';
+import { BrinkFetchError } from './errors';
+let cached = null;
+let inflight = null;
+const SAFETY_WINDOW_MS = 60_000;
+export async function getOrRefresh(forceRefresh = false) {
+    const now = Date.now();
+    if (!forceRefresh &&
+        cached &&
+        cached.expiresAt - SAFETY_WINDOW_MS > now) {
+        return cached.accessToken;
+    }
+    // Coalesce concurrent refresh attempts onto a single network call.
+    if (inflight)
+        return inflight;
+    inflight = (async () => {
+        try {
+            const token = await fetchToken();
+            cached = {
+                accessToken: token.access_token,
+                expiresAt: Date.now() + token.expires_in * 1000,
+            };
+            return token.access_token;
+        }
+        finally {
+            inflight = null;
+        }
+    })();
+    return inflight;
+}
+export function invalidate() {
+    cached = null;
+}
+async function fetchToken() {
+    const cfg = getConfig();
+    const body = new URLSearchParams({
+        client_id: cfg.managementClientId,
+        client_secret: cfg.managementClientSecret,
+        grant_type: 'client_credentials',
+        scope: cfg.managementScope,
+    });
+    const res = await fetch(`${cfg.oauthUrl}/oauth2/token`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+        body: body.toString(),
+        cache: 'no-store',
+    });
+    if (!res.ok) {
+        const text = await res.text().catch(() => '');
+        throw new BrinkFetchError(`OAuth2 token request failed: ${text || res.statusText}`, res.status);
+    }
+    return (await res.json());
+}

package/dist/client/shopper.d.ts

@@ -0,0 +1,8 @@
+interface ShopperFetchOpts {
+    endpoint: string;
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+    token?: string;
+    body?: unknown;
+}
+export declare function shopperFetch<T>(opts: ShopperFetchOpts): Promise<T>;
+export {};

package/dist/client/shopper.js

@@ -0,0 +1,31 @@
+/**
+ * Shopper API client. All requests authenticate with the session token,
+ * which our adapter treats as the cart id. The token is rotated by Brink on
+ * `/sessions/migrate` and `/checkout/start` — the response contains a fresh
+ * `token` field which the caller is responsible for persisting back into
+ * the cart cookie.
+ */
+import { getConfig } from '../config';
+import { BrinkFetchError } from './errors';
+export async function shopperFetch(opts) {
+    const cfg = getConfig();
+    const headers = {
+        'Content-Type': 'application/json',
+    };
+    if (opts.token)
+        headers.Authorization = opts.token;
+    const res = await fetch(`${cfg.shopperApiUrl}${opts.endpoint}`, {
+        method: opts.method,
+        headers,
+        body: opts.body !== undefined ? JSON.stringify(opts.body) : undefined,
+        cache: 'no-store',
+    });
+    if (res.status === 204)
+        return {};
+    const json = (await res.json().catch(() => ({})));
+    if (!res.ok) {
+        const err = json;
+        throw new BrinkFetchError(err.error || err.message || `Brink shopper API error (${res.status})`, res.status, err);
+    }
+    return json;
+}

package/dist/config.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Brink adapter configuration.
+ *
+ * Brink exposes two distinct API surfaces with different auth:
+ *   - **Shopper API** (`shopperApiUrl`) — session-bound cart/checkout.
+ *     Authenticated with the session token, which IS the cart id.
+ *   - **Management API** (`managementApiUrl`) — order import, lookup,
+ *     history. Authenticated with an OAuth2 client_credentials access token
+ *     plus a static `x-api-key`.
+ *
+ * The OAuth2 token is minted from `oauthUrl` using `managementClientId` /
+ * `managementClientSecret` / `managementScope`.
+ */
+export interface BrinkConfig {
+    /** Base URL for shopper API (sessions/items/etc.). e.g. https://api.brinkcommerce.com */
+    shopperApiUrl: string;
+    /** Base URL for management API (orders/imports). */
+    managementApiUrl: string;
+    /** OAuth2 token endpoint host. */
+    oauthUrl: string;
+    /** OAuth2 client_credentials inputs. */
+    managementClientId: string;
+    managementClientSecret: string;
+    managementScope: string;
+    /** Static x-api-key header for the management API. */
+    managementApiKey?: string;
+    /** Defaults used when starting a fresh shopper session. */
+    defaultStoreGroupId: string;
+    defaultCountryCode: string;
+    defaultLanguageCode: string;
+    defaultCurrencyCode: string;
+    /**
+     * Pluggable side-channel store for cart-level state that Brink does not
+     * persist on its session (shipping/billing address, selected shipping &
+     * payment methods). Indexed by Brink session token (= our cart id).
+     *
+     * Must be provided in serverless environments. Defaults to an in-memory
+     * Map which only works for single-process dev.
+     */
+    cartStateStore?: CartStateStore;
+}
+export interface CartSideState {
+    shippingAddress?: import('@cobrastyle/shared-types').ShippingAddress;
+    billingAddress?: import('@cobrastyle/shared-types').BillingAddress;
+    shippingMethod?: import('@cobrastyle/shared-types').SelectedShippingMethod;
+    paymentMethod?: import('@cobrastyle/shared-types').SelectedPaymentMethod;
+    email?: string;
+}
+export interface CartStateStore {
+    get(cartId: string): Promise<CartSideState | null>;
+    set(cartId: string, state: CartSideState): Promise<void>;
+    clear(cartId: string): Promise<void>;
+}
+export declare function setConfig(next: BrinkConfig): void;
+export declare function getConfig(): BrinkConfig;
+export declare function getCartStateStore(): CartStateStore;

package/dist/config.js

@@ -0,0 +1,37 @@
+let config = null;
+export function setConfig(next) {
+    config = next;
+}
+export function getConfig() {
+    if (!config) {
+        throw new Error('Brink adapter not configured. Call setConfig() with shopper/management URLs and OAuth2 credentials.');
+    }
+    return config;
+}
+// In-memory fallback. Single-process only — fine for `pnpm dev`, breaks the
+// moment you deploy to multiple instances. The app's adapter loader
+// should always pass a cookie-backed store.
+class InMemoryCartStateStore {
+    store = new Map();
+    async get(cartId) {
+        return this.store.get(cartId) ?? null;
+    }
+    async set(cartId, state) {
+        this.store.set(cartId, state);
+    }
+    async clear(cartId) {
+        this.store.delete(cartId);
+    }
+}
+let inMemoryWarned = false;
+export function getCartStateStore() {
+    const cfg = getConfig();
+    if (cfg.cartStateStore)
+        return cfg.cartStateStore;
+    if (!inMemoryWarned) {
+        inMemoryWarned = true;
+        console.warn('[Brink] Using in-memory cart state store. Provide config.cartStateStore for serverless.');
+    }
+    return defaultStore;
+}
+const defaultStore = new InMemoryCartStateStore();

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { brinkAdapter, brinkAdapter as default, getBrinkOrdersByEmail, getBrinkOrdersByMerchantRef, } from './adapter';
+export { setConfig, getConfig } from './config';
+export type { BrinkConfig, CartStateStore, CartSideState } from './config';
+export { BrinkFetchError } from './client/errors';
+export * as mappers from './mappers/cart';

package/dist/index.js

@@ -0,0 +1,4 @@
+export { brinkAdapter, brinkAdapter as default, getBrinkOrdersByEmail, getBrinkOrdersByMerchantRef, } from './adapter';
+export { setConfig, getConfig } from './config';
+export { BrinkFetchError } from './client/errors';
+export * as mappers from './mappers/cart';

package/dist/mappers/cart.d.ts

@@ -0,0 +1,13 @@
+/**
+ * ShopperCart → Cart. Brink amounts are minor units (e.g. 12345 = 123.45 SEK);
+ * the Cart contract is in major units, so all money is divided by 100 here.
+ *
+ * Side state (addresses, selected methods) is not part of the brink session
+ * and must be merged in by the adapter from the configured cart state store.
+ */
+import type { Cart } from '@cobrastyle/shared-types';
+import type { ShopperCart } from '../types';
+import type { CartSideState } from '../config';
+declare const minor: (n: number | undefined | null) => number;
+export declare function mapShopperCart(shopper: ShopperCart, side: CartSideState | null, cartId: string): Cart;
+export { minor };

package/dist/mappers/cart.js

@@ -0,0 +1,86 @@
+const minor = (n) => typeof n === 'number' ? n / 100 : 0;
+export function mapShopperCart(shopper, side, cartId) {
+    const currency = shopper.currencyCode || 'SEK';
+    const items = shopper.items.map((i) => mapItem(i, currency));
+    const appliedCoupons = shopper.discountCodes.map((c) => ({
+        code: c.code,
+    }));
+    const availableShippingMethods = (shopper.shippingOptions ?? []).map((o) => mapShippingOption(o, currency));
+    return {
+        id: cartId,
+        items,
+        totals: mapTotals(shopper, items, currency),
+        appliedCoupons,
+        shippingAddresses: side?.shippingAddress ? [side.shippingAddress] : [],
+        billingAddress: side?.billingAddress,
+        selectedShippingMethod: side?.shippingMethod,
+        selectedPaymentMethod: side?.paymentMethod,
+        availableShippingMethods,
+        availablePaymentMethods: [],
+        email: side?.email,
+    };
+}
+function mapItem(item, currency) {
+    const unit = minor(item.salePriceAmount || item.basePriceAmount);
+    const rowTotal = minor(item.totalPriceAmount - item.totalTaxAmount);
+    const rowTotalIncludingTax = minor(item.totalPriceAmount);
+    return {
+        id: item.id,
+        uid: item.id,
+        product: {
+            id: item.productParentId,
+            sku: item.productVariantId,
+            name: item.displayName || item.name,
+            urlKey: item.slug,
+            thumbnail: {
+                url: item.imageUrl,
+                label: item.displayName || item.name,
+            },
+        },
+        quantity: item.quantity,
+        prices: {
+            price: unit,
+            rowTotal,
+            rowTotalIncludingTax,
+            currency,
+        },
+        configurableOptions: item.options
+            ? Object.entries(item.options).map(([k, v]) => ({
+                optionLabel: k,
+                valueLabel: v,
+            }))
+            : undefined,
+    };
+}
+function mapTotals(shopper, items, currency) {
+    const subtotal = items.reduce((s, i) => s + i.prices.rowTotal, 0);
+    const subtotalIncludingTax = items.reduce((s, i) => s + i.prices.rowTotalIncludingTax, 0);
+    return {
+        subtotal,
+        subtotalIncludingTax,
+        grandTotal: minor(shopper.totals.grandTotal),
+        discounts: shopper.totals.discountTotal > 0
+            ? [{ amount: minor(shopper.totals.discountTotal), label: 'Discount' }]
+            : [],
+        taxes: [
+            {
+                amount: minor(shopper.totals.taxTotal),
+                label: 'VAT',
+                rate: 0,
+            },
+        ],
+        shipping: minor(shopper.totals.shippingTotal),
+        currency,
+    };
+}
+function mapShippingOption(o, currency) {
+    return {
+        carrierCode: o.id,
+        carrierTitle: o.displayName || o.name,
+        methodCode: o.id,
+        methodTitle: o.displayName || o.name,
+        amount: minor(o.salePriceAmount || o.basePriceAmount),
+        currency,
+    };
+}
+export { minor };

package/dist/mappers/order.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Map Brink management-API Order → CustomerOrder for the storefront's
+ * "my orders" UI. Money fields divided by 100 (minor → major units).
+ */
+import type { CustomerOrder } from '@cobrastyle/shared-types';
+import type { BrinkOrder } from '../types';
+export declare function mapBrinkOrder(order: BrinkOrder): CustomerOrder;

package/dist/mappers/order.js

@@ -0,0 +1,35 @@
+import { minor } from './cart';
+export function mapBrinkOrder(order) {
+    const items = order.orderLines.map((l) => ({
+        id: l.id,
+        productName: l.displayName || l.name,
+        sku: l.productVariantId,
+        quantity: l.quantity,
+        price: minor(l.salePriceAmount || l.basePriceAmount),
+        thumbnail: l.imageUrl,
+    }));
+    const shippingAddress = {
+        firstname: order.shippingAddress.givenName,
+        lastname: order.shippingAddress.familyName,
+        street: [
+            order.shippingAddress.streetAddress,
+            order.shippingAddress.streetAddress2,
+        ].filter(Boolean),
+        city: order.shippingAddress.city,
+        region: order.shippingAddress.stateOrProvince,
+        postcode: order.shippingAddress.postalCode,
+        country: order.shippingAddress.country,
+        countryCode: order.shippingAddress.country,
+        telephone: order.shippingAddress.telephoneNumber,
+    };
+    return {
+        id: order.id,
+        orderNumber: order.reference,
+        createdAt: order.date,
+        status: order.status?.orderStates?.[0] ?? 'unknown',
+        total: minor(order.totals.grandTotal),
+        currency: order.currencyCode,
+        items,
+        shippingAddress,
+    };
+}

package/dist/mappers/place-order.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Build a Brink management-API CreateBrinkOrder body from a shopper session
+ * + accumulated side state (addresses, methods, email).
+ *
+ * NOTE: this is a B2B-flavoured "direct import" path. It uses
+ * `BrinkZeroPayment` because no payment provider is wired up yet; the order
+ * lands in Brink as a finished, pre-paid record. Wire a real payment
+ * provider (Walley/Klarna/Adyen/etc.) before going live to consumers.
+ */
+import type { CartSideState } from '../config';
+import type { ShopperSessionResponse, CreateBrinkOrderBody } from '../types';
+export interface BuildOrderInputs {
+    session: ShopperSessionResponse;
+    side: CartSideState;
+    importId: string;
+    /** ISO 8601 date string. Defaults to now() at the caller. */
+    date: string;
+    channelType?: string;
+}
+export declare function buildBrinkOrderBody(input: BuildOrderInputs): CreateBrinkOrderBody;

package/dist/mappers/place-order.js

@@ -0,0 +1,97 @@
+export function buildBrinkOrderBody(input) {
+    const { session, side, importId, date } = input;
+    const cart = session.cart;
+    if (!side.shippingAddress) {
+        throw new Error('Cannot place order: shipping address not set');
+    }
+    if (!side.billingAddress) {
+        throw new Error('Cannot place order: billing address not set');
+    }
+    return {
+        importId,
+        date,
+        countryCode: cart.countryCode,
+        languageCode: cart.languageCode,
+        currencyCode: cart.currencyCode,
+        storeGroupId: cart.storeGroupId,
+        payment: {
+            providerId: 'brink-zero',
+            providerName: 'BrinkZeroPayment',
+            reference: importId,
+            method: 'zero',
+        },
+        isTaxIncludedInPrice: cart.isTaxIncludedInPrice,
+        channelType: input.channelType ?? 'WEB',
+        isTaxExemptionEligible: false,
+        isTaxExempt: false,
+        taxationCountry: cart.countryCode,
+        shippingAddress: mapAddress(side.shippingAddress, side.email),
+        billingAddress: mapAddress(side.billingAddress, side.email),
+        shipping: mapShipping(side.shippingMethod),
+        shippingFees: side.shippingMethod
+            ? [
+                {
+                    id: side.shippingMethod.methodCode,
+                    name: side.shippingMethod.methodTitle,
+                    taxGroupId: 'default',
+                    // 25% VAT in basis points (2500 = 25.00%) — adjust per market.
+                    taxPercentage: 2500,
+                    taxPercentageDecimals: 2,
+                    basePriceAmount: Math.round(side.shippingMethod.amount * 100),
+                    salePriceAmount: Math.round(side.shippingMethod.amount * 100),
+                    discountAmount: 0,
+                    taxAmount: 0,
+                },
+            ]
+            : undefined,
+        orderLines: cart.items.map(mapOrderLine),
+    };
+}
+function mapAddress(addr, email) {
+    return {
+        country: addr.countryCode || addr.country,
+        telephoneNumber: addr.telephone,
+        stateOrProvince: addr.region ?? '',
+        streetAddress: addr.street[0] ?? '',
+        streetAddress2: addr.street[1] ?? '',
+        city: addr.city,
+        givenName: addr.firstname,
+        familyName: addr.lastname,
+        postalCode: addr.postcode,
+        email: email ?? '',
+    };
+}
+function mapShipping(method) {
+    if (!method) {
+        return {
+            providerId: 'manual',
+            providerName: 'Manual',
+            reference: 'manual',
+        };
+    }
+    return {
+        providerId: method.carrierCode,
+        providerName: method.carrierTitle,
+        reference: method.methodCode,
+    };
+}
+function mapOrderLine(item) {
+    return {
+        id: item.id,
+        productVariantId: item.productVariantId,
+        productParentId: item.productParentId,
+        name: item.displayName || item.name,
+        taxPercentage: item.taxPercentage,
+        taxPercentageDecimals: item.taxPercentageDecimals,
+        taxGroupId: item.taxGroupId,
+        quantity: item.quantity,
+        imageUrl: item.imageUrl,
+        basePriceAmount: item.basePriceAmount,
+        salePriceAmount: item.salePriceAmount,
+        totalDiscountAmount: item.totalDiscountAmount,
+        totalPriceAmount: item.totalPriceAmount,
+        totalTaxAmount: item.totalTaxAmount,
+        options: item.options,
+        customAttributes: item.customAttributes,
+    };
+}

package/dist/types.d.ts

@@ -0,0 +1,212 @@
+/**
+ * Brink wire types — copied from @enadhq/commerce/dist/brink/types so this
+ * package has zero runtime dependency on the SDK. If Brink updates the API
+ * shape, regenerate from upstream `dist/brink/types/{api,session,order}.d.ts`.
+ *
+ * All money fields are in **minor units** (öre/cents). Multiply by 100 going
+ * out, divide by 100 coming in.
+ */
+export interface ShopperCartItem {
+    id: string;
+    productVariantId: string;
+    productParentId: string;
+    quantity: number;
+    name: string;
+    displayName: string;
+    description: string;
+    taxGroupId: string;
+    basePriceAmount: number;
+    salePriceAmount: number;
+    discountAmount: number;
+    totalPriceAmount: number;
+    totalDiscountAmount: number;
+    taxPercentage: number;
+    taxPercentageDecimals: number;
+    totalTaxAmount: number;
+    imageUrl: string;
+    slug: string;
+    options?: Record<string, string>;
+    customAttributes?: Record<string, string>;
+}
+export interface ShopperCartTotals {
+    subTotal: number;
+    taxTotal: number;
+    grandTotal: number;
+    discountTotal: number;
+    shippingTotal: number;
+}
+export interface ShopperShippingOption {
+    id: string;
+    name: string;
+    displayName: string;
+    taxGroupId: string;
+    taxPercentage: number;
+    taxPercentageDecimals: number;
+    basePriceAmount: number;
+    salePriceAmount: number;
+    discountAmount: number;
+    taxAmount: number;
+}
+export interface ShopperDiscountCode {
+    code: string;
+    applyLast: boolean;
+    isExclusive: boolean;
+}
+export interface ShopperCart {
+    id: string;
+    storeGroupId: string;
+    countryCode: string;
+    currencyCode: string;
+    languageCode: string;
+    isTaxIncludedInPrice: boolean;
+    discountAmount: number;
+    discountCodes: ShopperDiscountCode[];
+    items: ShopperCartItem[];
+    shippingOptions?: ShopperShippingOption[];
+    totals: ShopperCartTotals;
+}
+export interface ShopperSessionResponse {
+    token: string;
+    cart: ShopperCart;
+    locked: boolean;
+    attributes?: Record<string, Record<string, string>>;
+}
+export interface RequestSessionStart {
+    storeGroupId: string;
+    countryCode: string;
+    languageCode: string;
+}
+export interface RequestAddItem {
+    productVariantId: string;
+    quantity: number;
+    options?: Record<string, string>;
+}
+export interface OAuth2TokenResponse {
+    access_token: string;
+    expires_in: number;
+    token_type: 'Bearer';
+}
+export interface CreateBrinkOrderBody {
+    importId: string;
+    date: string;
+    countryCode: string;
+    languageCode: string;
+    currencyCode: string;
+    storeGroupId: string;
+    payment: {
+        providerId: string;
+        providerName: string;
+        reference: string;
+        method: string;
+    };
+    isTaxIncludedInPrice: boolean;
+    channelType: string;
+    isTaxExemptionEligible?: boolean;
+    isTaxExempt?: boolean;
+    taxationCountry: string;
+    shippingAddress: BrinkOrderAddressInput;
+    billingAddress: BrinkOrderAddressInput;
+    shipping: {
+        providerId: string;
+        providerName: string;
+        reference: string;
+    };
+    shippingFees?: BrinkShippingFeeInput[];
+    orderLines: BrinkOrderLineInput[];
+    attributes?: {
+        merchantReference1?: string;
+        merchantReference2?: string;
+        company?: {
+            registrationNumber?: string;
+            taxId?: string;
+            name?: string;
+            reference?: string;
+        };
+    };
+}
+export interface BrinkOrderAddressInput {
+    country: string;
+    telephoneNumber: string;
+    stateOrProvince: string;
+    streetAddress: string;
+    streetAddress2: string;
+    city: string;
+    givenName: string;
+    familyName: string;
+    postalCode: string;
+    email: string;
+}
+export interface BrinkShippingFeeInput {
+    id: string;
+    name: string;
+    taxGroupId: string;
+    taxPercentage: number;
+    taxPercentageDecimals: number;
+    basePriceAmount: number;
+    salePriceAmount: number;
+    discountAmount: number;
+    taxAmount: number;
+}
+export interface BrinkOrderLineInput {
+    id: string;
+    productVariantId: string;
+    productParentId?: string;
+    name: string;
+    taxPercentage: number;
+    taxPercentageDecimals: number;
+    taxGroupId: string;
+    quantity: number;
+    imageUrl: string;
+    basePriceAmount: number;
+    salePriceAmount: number;
+    totalDiscountAmount: number;
+    totalPriceAmount: number;
+    totalTaxAmount: number;
+    options?: Record<string, string>;
+    customAttributes?: Record<string, string>;
+}
+export interface CreateBrinkOrderResponse {
+    finished: string;
+    orderId: string;
+    orderReference: string;
+}
+export interface BrinkOrder {
+    id: string;
+    reference: string;
+    date: string;
+    countryCode: string;
+    currencyCode: string;
+    languageCode: string;
+    storeGroupId: string;
+    channelType: string;
+    isTaxIncludedInPrice: boolean;
+    orderLines: ShopperCartItem[];
+    shippingAddress: BrinkOrderAddressInput & {
+        pcc?: string;
+    };
+    billingAddress: BrinkOrderAddressInput & {
+        pcc?: string;
+    };
+    totals: {
+        subTotal: number;
+        taxTotal: number;
+        discountTotal: number;
+        shippingTotal: number;
+        giftCardTotal?: number;
+        grandTotal: number;
+    };
+    status?: {
+        orderStates: string[];
+    };
+}
+export interface BrinkOrders {
+    orderSummaries: BrinkOrder[];
+}
+export interface BrinkErrorBody {
+    error?: string;
+    message?: string;
+    statusCode?: number;
+    requestId?: string;
+    errors?: string[];
+    productVariantIDs?: string[];
+}

package/dist/types.js

@@ -0,0 +1,9 @@
+/**
+ * Brink wire types — copied from @enadhq/commerce/dist/brink/types so this
+ * package has zero runtime dependency on the SDK. If Brink updates the API
+ * shape, regenerate from upstream `dist/brink/types/{api,session,order}.d.ts`.
+ *
+ * All money fields are in **minor units** (öre/cents). Multiply by 100 going
+ * out, divide by 100 coming in.
+ */
+export {};

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@cobrastyle/adapter-brink",
+  "version": "1.0.1",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@cobrastyle/shared-types": "1.0.1"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.3.0"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/eComero/cobrastyle-express-next.git",
+    "directory": "packages/adapters/brink"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc --project tsconfig.build.json",
+    "type-check": "tsc --noEmit"
+  }
+}