@vivoa/partner-sdk 0.1.0

package/dist/cjs/domain/errors.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VivoaWebhookSignatureError = exports.VivoaProvisioningFailedError = exports.VivoaServerError = exports.VivoaRateLimitError = exports.VivoaConflictError = exports.VivoaNotFoundError = exports.VivoaForbiddenError = exports.VivoaAuthenticationError = exports.VivoaBadRequestError = exports.VivoaApiError = exports.VivoaTimeoutError = exports.VivoaNetworkError = exports.VivoaValidationError = exports.VivoaError = void 0;
+exports.messageFromBody = messageFromBody;
+exports.apiErrorFor = apiErrorFor;
+/**
+ * Typed error hierarchy. Every failed call surfaces as a `VivoaApiError`
+ * subclass keyed by HTTP status, so partners branch on `instanceof` instead of
+ * parsing strings.
+ */
+class VivoaError extends Error {
+    constructor(message, options) {
+        super(message, options);
+        this.name = new.target.name;
+    }
+}
+exports.VivoaError = VivoaError;
+/** Input rejected client-side before any request is sent. */
+class VivoaValidationError extends VivoaError {
+}
+exports.VivoaValidationError = VivoaValidationError;
+/** The request never produced an HTTP response (DNS, reset, timeout). */
+class VivoaNetworkError extends VivoaError {
+}
+exports.VivoaNetworkError = VivoaNetworkError;
+/** A long-running wait (e.g. `waitUntilSettled`) ran out of time. */
+class VivoaTimeoutError extends VivoaError {
+}
+exports.VivoaTimeoutError = VivoaTimeoutError;
+class VivoaApiError extends VivoaError {
+    status;
+    method;
+    path;
+    body;
+    constructor(params) {
+        super(`${params.method} ${params.path} → ${params.status}: ${params.message}`);
+        this.status = params.status;
+        this.method = params.method;
+        this.path = params.path;
+        this.body = params.body;
+    }
+}
+exports.VivoaApiError = VivoaApiError;
+/** 400 — invalid payload or country outside allowedRegions. */
+class VivoaBadRequestError extends VivoaApiError {
+}
+exports.VivoaBadRequestError = VivoaBadRequestError;
+/** 401 — bad signature, unknown key or clock skew > 300 s. */
+class VivoaAuthenticationError extends VivoaApiError {
+}
+exports.VivoaAuthenticationError = VivoaAuthenticationError;
+/** 403 — operator not active or quota full. */
+class VivoaForbiddenError extends VivoaApiError {
+}
+exports.VivoaForbiddenError = VivoaForbiddenError;
+/** 404 — merchant does not exist or is not in your fleet. */
+class VivoaNotFoundError extends VivoaApiError {
+}
+exports.VivoaNotFoundError = VivoaNotFoundError;
+/** 409 — handle taken, or activation on a creating/live/suspended merchant. */
+class VivoaConflictError extends VivoaApiError {
+}
+exports.VivoaConflictError = VivoaConflictError;
+/** 429 — requests-per-minute limit for the plan. */
+class VivoaRateLimitError extends VivoaApiError {
+}
+exports.VivoaRateLimitError = VivoaRateLimitError;
+/** 5xx. */
+class VivoaServerError extends VivoaApiError {
+}
+exports.VivoaServerError = VivoaServerError;
+const BY_STATUS = {
+    400: VivoaBadRequestError,
+    401: VivoaAuthenticationError,
+    403: VivoaForbiddenError,
+    404: VivoaNotFoundError,
+    409: VivoaConflictError,
+    429: VivoaRateLimitError,
+};
+/** Extracts NestJS's `{ message }` (string or validation array) from a body. */
+function messageFromBody(body, fallback) {
+    if (body && typeof body === 'object' && 'message' in body) {
+        const m = body.message;
+        if (Array.isArray(m))
+            return m.join('; ');
+        if (typeof m === 'string')
+            return m;
+    }
+    if (typeof body === 'string' && body.length > 0)
+        return body;
+    return fallback;
+}
+function apiErrorFor(params) {
+    const Ctor = BY_STATUS[params.status] ?? (params.status >= 500 ? VivoaServerError : VivoaApiError);
+    return new Ctor({ ...params, message: messageFromBody(params.body, `HTTP ${params.status}`) });
+}
+/** Provisioning ended in `failed`. `activate` again (or `provisionStore`) to retry. */
+class VivoaProvisioningFailedError extends VivoaError {
+    merchantId;
+    reason;
+    constructor(merchantId, reason, options) {
+        super(`Provisioning failed for merchant ${merchantId}: ${reason}`, options);
+        this.merchantId = merchantId;
+        this.reason = reason;
+    }
+}
+exports.VivoaProvisioningFailedError = VivoaProvisioningFailedError;
+/** A webhook body whose `X-Vivoa-Signature` does not verify. Reject it (401/400). */
+class VivoaWebhookSignatureError extends VivoaError {
+}
+exports.VivoaWebhookSignatureError = VivoaWebhookSignatureError;

package/dist/cjs/domain/merchant.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Merchant vocabulary — mirrors `engine/partner-api/domain/merchant-views.ts`
+ * on the platform. A partner speaks in merchants, never in stores/deployments.
+ * Pure: no I/O, no Node APIs.
+ */
+export declare const MERCHANT_RUNTIME_STATUSES: readonly ["not_activated", "creating", "live", "suspended", "failed", "unknown"];
+/** Where a merchant's runtime is, from the partner's point of view. */
+export type MerchantRuntimeStatus = (typeof MERCHANT_RUNTIME_STATUSES)[number];
+/** A merchant as returned by `POST /merchants` and `GET /merchants`. */
+export interface Merchant {
+    id: string;
+    name: string;
+    /** Assigned by the platform from `name` — never chosen by the caller. */
+    handle: string;
+    /** Commercial status (active | suspended | …). */
+    status: string;
+    runtime: MerchantRuntimeStatus;
+    countries: string[];
+    plan: string;
+    domain: string | null;
+    ownerEmail: string | null;
+    /** Your own reference for this merchant, if you gave one at creation. */
+    externalId: string | null;
+    /** ISO-8601. */
+    createdAt: string;
+}
+/** Snapshot returned by `GET /merchants/:id/status` and `activate`. */
+export interface MerchantStatus {
+    storeId: string;
+    handle: string;
+    status: string;
+    deployStatus: MerchantRuntimeStatus;
+    domain: string | null;
+    apiBaseUrl: string | null;
+}
+export interface CreateMerchantInput {
+    /** Email of the store owner (receives their own merchant account). */
+    email: string;
+    name: string;
+    /** ISO-3166 codes; must be a subset of the operator's allowedRegions. */
+    countries: string[];
+    industry?: string;
+    /**
+     * Your own reference for this merchant (customer id, order id…). Optional
+     * here, but it is the idempotency key of `merchants.create()`: replaying the
+     * same value returns the merchant you already created instead of a second
+     * one. `provisionStore()` requires it for exactly that reason. Unique per
+     * operator, max 120 chars.
+     */
+    externalId?: string;
+}
+export interface ListMerchantsQuery {
+    page?: number;
+    /** Max 100. */
+    limit?: number;
+    /** Matches name or handle. */
+    search?: string;
+    /** Exact match on your own reference, passed at creation. */
+    externalId?: string;
+}
+export interface Page<T> {
+    data: T[];
+    meta: {
+        total: number;
+        page: number;
+        limit: number;
+    };
+}
+/** Max length the platform accepts for `CreateMerchantInput.externalId`. */
+export declare const MAX_EXTERNAL_ID_LENGTH = 120;
+/** Runtime states where the platform accepts `activate` (first run or retry). */
+export declare function canActivate(runtime: MerchantRuntimeStatus): boolean;
+/** States that will not change without a new action from the partner. */
+export declare function isSettled(runtime: MerchantRuntimeStatus): boolean;

package/dist/cjs/domain/merchant.js

@@ -0,0 +1,28 @@
+"use strict";
+/**
+ * Merchant vocabulary — mirrors `engine/partner-api/domain/merchant-views.ts`
+ * on the platform. A partner speaks in merchants, never in stores/deployments.
+ * Pure: no I/O, no Node APIs.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_EXTERNAL_ID_LENGTH = exports.MERCHANT_RUNTIME_STATUSES = void 0;
+exports.canActivate = canActivate;
+exports.isSettled = isSettled;
+exports.MERCHANT_RUNTIME_STATUSES = [
+    'not_activated', // created, `activate` never called
+    'creating', // provisioning in flight
+    'live', // serving traffic
+    'suspended', // stopped by the operator / ops
+    'failed', // last provisioning attempt failed — `activate` again to retry
+    'unknown', // torn down / unexpected state
+];
+/** Max length the platform accepts for `CreateMerchantInput.externalId`. */
+exports.MAX_EXTERNAL_ID_LENGTH = 120;
+/** Runtime states where the platform accepts `activate` (first run or retry). */
+function canActivate(runtime) {
+    return runtime === 'not_activated' || runtime === 'failed';
+}
+/** States that will not change without a new action from the partner. */
+function isSettled(runtime) {
+    return runtime !== 'creating';
+}

package/dist/cjs/domain/operator.d.ts

@@ -0,0 +1,32 @@
+export type OperatorStatus = 'active' | 'pending' | 'suspended';
+/** `GET /me` — the partner's own profile and quota usage. */
+export interface OperatorProfile {
+    id: string;
+    name: string;
+    status: OperatorStatus;
+    plan: string;
+    storesUsed: number;
+    maxStores: number;
+    allowedRegions: string[];
+    rateLimitPerMin: number;
+}
+export interface RotatedApiSecret {
+    apiSecret: string;
+}
+export interface FleetAnalytics {
+    operatorId: string;
+    stores: {
+        total: number;
+        active: number;
+        suspended: number;
+        byStatus: Record<string, number>;
+    };
+    revenue: {
+        grossVolume: number;
+        currency: string;
+        pendingAmount: number;
+        completedPayments: number;
+        avgTicket: number;
+    };
+}
+export declare function remainingQuota(profile: OperatorProfile): number;

package/dist/cjs/domain/operator.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.remainingQuota = remainingQuota;
+function remainingQuota(profile) {
+    return Math.max(0, profile.maxStores - profile.storesUsed);
+}

package/dist/cjs/domain/signature.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Canonical request payload signed with the operator's apiSecret. Must match
+ * the platform verifier (`shared/crypto/management-hmac.ts`, v2 strict):
+ *
+ *   `${timestamp}.${METHOD}.${pathWithoutQuery}.${sha256hex(rawBody)}`
+ */
+export declare function canonicalRequestPayload(params: {
+    timestamp: string;
+    method: string;
+    path: string;
+    bodySha256Hex: string;
+}): string;
+export declare const PARTNER_HEADERS: {
+    readonly key: "x-partner-key";
+    readonly timestamp: "x-partner-timestamp";
+    readonly signature: "x-partner-signature";
+};
+export declare const WEBHOOK_SIGNATURE_HEADER = "x-vivoa-signature";
+export declare const WEBHOOK_EVENT_HEADER = "x-vivoa-event";
+/** Server accepts ±300 s of clock skew. */
+export declare const MAX_CLOCK_SKEW_SECONDS = 300;

package/dist/cjs/domain/signature.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_CLOCK_SKEW_SECONDS = exports.WEBHOOK_EVENT_HEADER = exports.WEBHOOK_SIGNATURE_HEADER = exports.PARTNER_HEADERS = void 0;
+exports.canonicalRequestPayload = canonicalRequestPayload;
+/**
+ * Canonical request payload signed with the operator's apiSecret. Must match
+ * the platform verifier (`shared/crypto/management-hmac.ts`, v2 strict):
+ *
+ *   `${timestamp}.${METHOD}.${pathWithoutQuery}.${sha256hex(rawBody)}`
+ */
+function canonicalRequestPayload(params) {
+    const path = params.path.split('?')[0];
+    return `${params.timestamp}.${params.method.toUpperCase()}.${path}.${params.bodySha256Hex}`;
+}
+exports.PARTNER_HEADERS = {
+    key: 'x-partner-key',
+    timestamp: 'x-partner-timestamp',
+    signature: 'x-partner-signature',
+};
+exports.WEBHOOK_SIGNATURE_HEADER = 'x-vivoa-signature';
+exports.WEBHOOK_EVENT_HEADER = 'x-vivoa-event';
+/** Server accepts ±300 s of clock skew. */
+exports.MAX_CLOCK_SKEW_SECONDS = 300;

package/dist/cjs/domain/webhook.d.ts

@@ -0,0 +1,48 @@
+export declare const MERCHANT_EVENT_TYPES: readonly ["merchant.created", "merchant.live", "merchant.failed", "merchant.suspended", "merchant.reactivated"];
+export type MerchantEventType = (typeof MERCHANT_EVENT_TYPES)[number];
+export type WebhookEventType = MerchantEventType | 'platform.test';
+export interface WebhookConfig {
+    configured: boolean;
+    url: string | null;
+    /** [] = all merchant events. */
+    events: string[];
+    active: boolean;
+    updatedAt: string | null;
+}
+export interface SetWebhookInput {
+    url: string;
+    /** Omit or [] to receive every merchant event. */
+    events?: MerchantEventType[];
+}
+export interface SetWebhookResult {
+    webhook: WebhookConfig;
+    /** Only on first creation. Store it — it is never readable again. */
+    signingSecret: string | null;
+}
+export interface WebhookDelivery {
+    id: string;
+    event: string;
+    statusCode: number | null;
+    success: boolean;
+    error: string | null;
+    durationMs: number | null;
+    attempt: number;
+    createdAt: string;
+}
+export interface MerchantEventData {
+    merchantId: string;
+    handle: string;
+    operatorId: string;
+    occurredAt: string;
+    /** Present on `merchant.failed`. */
+    reason?: string;
+    /** Present on `merchant.created` when the create call gave one. */
+    externalId?: string | null;
+    [key: string]: unknown;
+}
+/** Body POSTed to the partner's endpoint. */
+export interface WebhookEvent<T extends WebhookEventType = WebhookEventType> {
+    event: T;
+    data: T extends MerchantEventType ? MerchantEventData : Record<string, unknown>;
+    sentAt: string;
+}

package/dist/cjs/domain/webhook.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MERCHANT_EVENT_TYPES = void 0;
+exports.MERCHANT_EVENT_TYPES = [
+    'merchant.created',
+    'merchant.live',
+    'merchant.failed',
+    'merchant.suspended',
+    'merchant.reactivated',
+];

package/dist/cjs/index.d.ts

@@ -0,0 +1,25 @@
+import { VivoaPartnerClient, type PartnerClientDeps } from './application/partner-client.ts';
+import { type VerifyWebhookParams } from './webhooks/verify-webhook.ts';
+import type { WebhookEvent } from './domain/webhook.ts';
+export declare const DEFAULT_BASE_URL = "https://api.vivoa.app";
+export type CreatePartnerClientOptions = Omit<PartnerClientDeps, 'baseUrl' | 'transport' | 'crypto' | 'clock'> & Partial<Pick<PartnerClientDeps, 'baseUrl' | 'transport' | 'crypto' | 'clock'>>;
+/**
+ * Composition root with production adapters (global fetch, node:crypto, wall
+ * clock). Any of them can be overridden — e.g. `transport: new FakeVivoa()`.
+ */
+export declare function createPartnerClient(options: CreatePartnerClientOptions): VivoaPartnerClient;
+/** Standalone webhook verification (no client needed in your webhook handler). */
+export declare function verifyWebhook(params: VerifyWebhookParams): Promise<WebhookEvent>;
+export { VivoaPartnerClient, SDK_VERSION } from './application/partner-client.ts';
+export type { PartnerClientDeps } from './application/partner-client.ts';
+export type { ProvisionStoreOptions, ProvisionStoreResult, ProvisionProgress, ProvisionPhase, } from './application/use-cases/provision-store.ts';
+export type { VerifyWebhookParams } from './webhooks/verify-webhook.ts';
+export * from './domain/errors.ts';
+export * from './domain/merchant.ts';
+export * from './domain/operator.ts';
+export * from './domain/webhook.ts';
+export { canonicalRequestPayload, PARTNER_HEADERS, WEBHOOK_SIGNATURE_HEADER, WEBHOOK_EVENT_HEADER } from './domain/signature.ts';
+export * from './ports/index.ts';
+export { FetchTransport } from './adapters/fetch-transport.ts';
+export { nodeCrypto } from './adapters/node-crypto.ts';
+export { systemClock } from './adapters/system-clock.ts';

package/dist/cjs/index.js

@@ -0,0 +1,61 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.systemClock = exports.nodeCrypto = exports.FetchTransport = exports.WEBHOOK_EVENT_HEADER = exports.WEBHOOK_SIGNATURE_HEADER = exports.PARTNER_HEADERS = exports.canonicalRequestPayload = exports.SDK_VERSION = exports.VivoaPartnerClient = exports.DEFAULT_BASE_URL = void 0;
+exports.createPartnerClient = createPartnerClient;
+exports.verifyWebhook = verifyWebhook;
+const partner_client_ts_1 = require("./application/partner-client.js");
+const fetch_transport_ts_1 = require("./adapters/fetch-transport.js");
+const node_crypto_ts_1 = require("./adapters/node-crypto.js");
+const system_clock_ts_1 = require("./adapters/system-clock.js");
+const verify_webhook_ts_1 = require("./webhooks/verify-webhook.js");
+exports.DEFAULT_BASE_URL = 'https://api.vivoa.app';
+/**
+ * Composition root with production adapters (global fetch, node:crypto, wall
+ * clock). Any of them can be overridden — e.g. `transport: new FakeVivoa()`.
+ */
+function createPartnerClient(options) {
+    return new partner_client_ts_1.VivoaPartnerClient({
+        ...options,
+        baseUrl: options.baseUrl ?? exports.DEFAULT_BASE_URL,
+        transport: options.transport ?? new fetch_transport_ts_1.FetchTransport(),
+        crypto: options.crypto ?? node_crypto_ts_1.nodeCrypto,
+        clock: options.clock ?? system_clock_ts_1.systemClock,
+    });
+}
+/** Standalone webhook verification (no client needed in your webhook handler). */
+function verifyWebhook(params) {
+    return (0, verify_webhook_ts_1.verifyWebhook)(node_crypto_ts_1.nodeCrypto, params);
+}
+var partner_client_ts_2 = require("./application/partner-client.js");
+Object.defineProperty(exports, "VivoaPartnerClient", { enumerable: true, get: function () { return partner_client_ts_2.VivoaPartnerClient; } });
+Object.defineProperty(exports, "SDK_VERSION", { enumerable: true, get: function () { return partner_client_ts_2.SDK_VERSION; } });
+__exportStar(require("./domain/errors.js"), exports);
+__exportStar(require("./domain/merchant.js"), exports);
+__exportStar(require("./domain/operator.js"), exports);
+__exportStar(require("./domain/webhook.js"), exports);
+var signature_ts_1 = require("./domain/signature.js");
+Object.defineProperty(exports, "canonicalRequestPayload", { enumerable: true, get: function () { return signature_ts_1.canonicalRequestPayload; } });
+Object.defineProperty(exports, "PARTNER_HEADERS", { enumerable: true, get: function () { return signature_ts_1.PARTNER_HEADERS; } });
+Object.defineProperty(exports, "WEBHOOK_SIGNATURE_HEADER", { enumerable: true, get: function () { return signature_ts_1.WEBHOOK_SIGNATURE_HEADER; } });
+Object.defineProperty(exports, "WEBHOOK_EVENT_HEADER", { enumerable: true, get: function () { return signature_ts_1.WEBHOOK_EVENT_HEADER; } });
+__exportStar(require("./ports/index.js"), exports);
+var fetch_transport_ts_2 = require("./adapters/fetch-transport.js");
+Object.defineProperty(exports, "FetchTransport", { enumerable: true, get: function () { return fetch_transport_ts_2.FetchTransport; } });
+var node_crypto_ts_2 = require("./adapters/node-crypto.js");
+Object.defineProperty(exports, "nodeCrypto", { enumerable: true, get: function () { return node_crypto_ts_2.nodeCrypto; } });
+var system_clock_ts_2 = require("./adapters/system-clock.js");
+Object.defineProperty(exports, "systemClock", { enumerable: true, get: function () { return system_clock_ts_2.systemClock; } });

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/dist/cjs/ports/clock.port.d.ts

@@ -0,0 +1,5 @@
+/** Driven port: time. Tests inject a manual clock to make polling instant. */
+export interface Clock {
+    nowMs(): number;
+    sleep(ms: number): Promise<void>;
+}

package/dist/cjs/ports/clock.port.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/ports/crypto.port.d.ts

@@ -0,0 +1,7 @@
+/** Driven port: the three primitives the SDK needs. Node, WebCrypto or HSM. */
+export interface CryptoProvider {
+    sha256Hex(data: string): string | Promise<string>;
+    hmacSha256Hex(secret: string, data: string): string | Promise<string>;
+    /** Constant-time comparison of two hex strings. */
+    timingSafeEqualHex(a: string, b: string): boolean | Promise<boolean>;
+}

package/dist/cjs/ports/crypto.port.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/ports/http-transport.port.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Driven port: moves one already-signed request over the wire. The SDK core
+ * never touches `fetch` — swap in undici, axios, a recording proxy, or the
+ * in-memory fake Vivoa (`@vivoa/partner-sdk/testing`) without changing a line
+ * of application code.
+ */
+export interface HttpRequest {
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE';
+    /** Absolute URL. */
+    url: string;
+    headers: Record<string, string>;
+    /** Exact bytes that were signed; undefined for bodyless requests. */
+    body?: string;
+    /** Per-request timeout in ms. */
+    timeoutMs: number;
+}
+export interface HttpResponse {
+    status: number;
+    headers: Record<string, string>;
+    /** Raw text; the core parses JSON. */
+    body: string;
+}
+export interface HttpTransport {
+    send(request: HttpRequest): Promise<HttpResponse>;
+}

package/dist/cjs/ports/http-transport.port.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/ports/index.d.ts

@@ -0,0 +1,5 @@
+export type { HttpTransport, HttpRequest, HttpResponse } from './http-transport.port.ts';
+export type { CryptoProvider } from './crypto.port.ts';
+export type { Clock } from './clock.port.ts';
+export type { SdkLogger } from './logger.port.ts';
+export { silentLogger } from './logger.port.ts';

package/dist/cjs/ports/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.silentLogger = void 0;
+var logger_port_ts_1 = require("./logger.port.js");
+Object.defineProperty(exports, "silentLogger", { enumerable: true, get: function () { return logger_port_ts_1.silentLogger; } });

package/dist/cjs/ports/logger.port.d.ts

@@ -0,0 +1,6 @@
+/** Optional observability hook. Never receives secrets or signatures. */
+export interface SdkLogger {
+    debug(message: string, meta?: Record<string, unknown>): void;
+    warn(message: string, meta?: Record<string, unknown>): void;
+}
+export declare const silentLogger: SdkLogger;

package/dist/cjs/ports/logger.port.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.silentLogger = void 0;
+exports.silentLogger = {
+    debug: () => { },
+    warn: () => { },
+};

package/dist/cjs/testing.d.ts

@@ -0,0 +1,12 @@
+/**
+ * `@vivoa/partner-sdk/testing` — test your integration without touching the
+ * platform: plug `FakeVivoa` in as the transport and a `ManualClock` so polling
+ * and backoff run instantly.
+ *
+ *   const clock = new ManualClock();
+ *   const vivoa = new FakeVivoa({ clock, operators: [{ apiKey: 'k', apiSecret: 's' }] });
+ *   const client = createPartnerClient({ apiKey: 'k', apiSecret: 's', transport: vivoa, clock });
+ */
+export { FakeVivoa } from './adapters/in-memory/fake-vivoa.ts';
+export type { FakeVivoaOptions, FakeOperatorSeed, FakeActivationMode, FakeWebhookDispatch, } from './adapters/in-memory/fake-vivoa.ts';
+export { ManualClock } from './adapters/manual-clock.ts';

package/dist/cjs/testing.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ManualClock = exports.FakeVivoa = void 0;
+/**
+ * `@vivoa/partner-sdk/testing` — test your integration without touching the
+ * platform: plug `FakeVivoa` in as the transport and a `ManualClock` so polling
+ * and backoff run instantly.
+ *
+ *   const clock = new ManualClock();
+ *   const vivoa = new FakeVivoa({ clock, operators: [{ apiKey: 'k', apiSecret: 's' }] });
+ *   const client = createPartnerClient({ apiKey: 'k', apiSecret: 's', transport: vivoa, clock });
+ */
+var fake_vivoa_ts_1 = require("./adapters/in-memory/fake-vivoa.js");
+Object.defineProperty(exports, "FakeVivoa", { enumerable: true, get: function () { return fake_vivoa_ts_1.FakeVivoa; } });
+var manual_clock_ts_1 = require("./adapters/manual-clock.js");
+Object.defineProperty(exports, "ManualClock", { enumerable: true, get: function () { return manual_clock_ts_1.ManualClock; } });

package/dist/cjs/webhooks/verify-webhook.d.ts

@@ -0,0 +1,21 @@
+import type { CryptoProvider } from '../ports/crypto.port.ts';
+import type { WebhookEvent } from '../domain/webhook.ts';
+export interface VerifyWebhookParams {
+    /** The body EXACTLY as received — before any JSON parsing. */
+    rawBody: string | Uint8Array;
+    /** Value of the `X-Vivoa-Signature` header (`sha256=<hex>`). */
+    signatureHeader: string | null | undefined;
+    /** Signing secret returned by `webhooks.set()` / `webhooks.rotateSecret()`. */
+    signingSecret: string;
+    /**
+     * Reject events whose `sentAt` is older than this (replay window). Default
+     * 5 min; `0` disables the check.
+     */
+    toleranceMs?: number;
+    nowMs?: number;
+}
+/**
+ * Verifies and parses a Vivoa webhook. Throws `VivoaWebhookSignatureError` on
+ * any mismatch — respond 400/401 and do not process the event.
+ */
+export declare function verifyWebhook(crypto: CryptoProvider, params: VerifyWebhookParams): Promise<WebhookEvent>;

package/dist/cjs/webhooks/verify-webhook.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyWebhook = verifyWebhook;
+const errors_ts_1 = require("../domain/errors.js");
+const DEFAULT_TOLERANCE_MS = 5 * 60_000;
+/**
+ * Verifies and parses a Vivoa webhook. Throws `VivoaWebhookSignatureError` on
+ * any mismatch — respond 400/401 and do not process the event.
+ */
+async function verifyWebhook(crypto, params) {
+    const raw = typeof params.rawBody === 'string' ? params.rawBody : new TextDecoder().decode(params.rawBody);
+    const header = params.signatureHeader?.trim();
+    if (!header?.startsWith('sha256=')) {
+        throw new errors_ts_1.VivoaWebhookSignatureError('Missing or malformed X-Vivoa-Signature header');
+    }
+    const expected = await crypto.hmacSha256Hex(params.signingSecret, raw);
+    if (!(await crypto.timingSafeEqualHex(expected, header.slice('sha256='.length)))) {
+        throw new errors_ts_1.VivoaWebhookSignatureError('Invalid webhook signature');
+    }
+    let event;
+    try {
+        event = JSON.parse(raw);
+    }
+    catch {
+        throw new errors_ts_1.VivoaWebhookSignatureError('Signed body is not valid JSON');
+    }
+    const tolerance = params.toleranceMs ?? DEFAULT_TOLERANCE_MS;
+    if (tolerance > 0) {
+        const sentAt = Date.parse(event.sentAt);
+        const now = params.nowMs ?? Date.now();
+        if (!Number.isFinite(sentAt) || Math.abs(now - sentAt) > tolerance) {
+            throw new errors_ts_1.VivoaWebhookSignatureError('Webhook sentAt outside the tolerance window (possible replay)');
+        }
+    }
+    return event;
+}

package/dist/esm/adapters/fetch-transport.d.ts

@@ -0,0 +1,7 @@
+import type { HttpRequest, HttpResponse, HttpTransport } from '../ports/http-transport.port.ts';
+/** Default transport: the runtime's global `fetch` (Node ≥ 18, Deno, Bun, edge). */
+export declare class FetchTransport implements HttpTransport {
+    private readonly fetchImpl;
+    constructor(fetchImpl?: typeof fetch);
+    send(request: HttpRequest): Promise<HttpResponse>;
+}