@viu/emporix-sdk 1.0.0

package/dist/context-vKgzZ-5f.d.ts

@@ -0,0 +1,329 @@
+/** Log severity, low → high. */
+type LogLevel = "trace" | "debug" | "info" | "warn" | "error" | "silent";
+/** Numeric ordering used for fast comparison. */
+declare const LEVEL: Record<LogLevel, number>;
+/** Services that bind their own logger and are independently level-controllable. */
+type ServiceName = "customer" | "product" | "category" | "cart" | "checkout" | "payment" | "price" | "media" | "segment" | "site" | "session-context" | "customer-management" | "iam" | "orders" | "sales-orders" | "http" | "auth";
+/** Arbitrary structured fields attached to a log line. */
+interface LogFields {
+    [key: string]: unknown;
+}
+/** The logger contract consumers may implement or swap. */
+interface Logger {
+    level: LogLevel;
+    isLevelEnabled(level: LogLevel): boolean;
+    trace(msg: string, fields?: LogFields): void;
+    debug(msg: string, fields?: LogFields): void;
+    info(msg: string, fields?: LogFields): void;
+    warn(msg: string, fields?: LogFields): void;
+    error(msg: string, fields?: LogFields): void;
+    child(bindings: LogFields): Logger;
+}
+/** Object form of logger configuration. */
+interface LoggerObjectConfig {
+    level?: LogLevel;
+    services?: Partial<Record<ServiceName, LogLevel>>;
+    pretty?: boolean;
+    redact?: string[];
+}
+/** `false` → noop logger; `Logger` → user-supplied; object → built-in console logger. */
+type LoggerConfig = false | Logger | LoggerObjectConfig;
+/**
+ * Resolves the effective level per service following:
+ * env per-service > env global > config.services[svc] > config.level > "warn".
+ * Runtime `set()` mutates programmatic levels but never overrides env-set ones
+ * unless `force` is passed.
+ */
+declare class LevelResolver {
+    private readonly warn;
+    private cfgLevel;
+    private cfgServices;
+    private forcedServices;
+    private forcedGlobal;
+    private warned;
+    constructor(cfg: LoggerObjectConfig, warn?: (msg: string) => void);
+    private envFor;
+    private envGlobal;
+    /**
+     * Effective level for a service. Forced overrides (from `set(..., force)`)
+     * take precedence over env vars; otherwise env > programmatic config.
+     */
+    get(svc: ServiceName): LogLevel;
+    /** Numeric effective level for a service. */
+    numericLevel(svc: ServiceName): number;
+    /** True if `svc`'s effective level allows emitting at `at`. */
+    isAtLeast(svc: ServiceName, at: LogLevel): boolean;
+    /** Mutates programmatic level (global or one service). Env-set levels are sticky unless `force`. */
+    set(level: LogLevel, svc?: ServiceName, force?: boolean): void;
+}
+/** Deep-clones `value`, replacing redacted keys with a mask. AuthContext token is stripped. */
+declare function redact(value: unknown, extra?: string[]): unknown;
+interface Sink {
+    log: (...a: unknown[]) => void;
+    info: (...a: unknown[]) => void;
+    warn: (...a: unknown[]) => void;
+    error: (...a: unknown[]) => void;
+}
+/** Creates the built-in console logger. `opts.sink` overrides `console` (used in tests). */
+declare function createConsoleLogger(resolver: LevelResolver, bindings?: LogFields, opts?: {
+    pretty?: boolean;
+    redact?: string[];
+    sink?: Sink;
+}): Logger;
+/** Creates a logger that discards everything. */
+declare function createNoopLogger(): Logger;
+
+/** Default Emporix API host. */
+declare const DEFAULT_HOST = "https://api.emporix.io";
+/** A client-credentials credential set (service / custom). */
+interface ServiceCredentials {
+    clientId: string;
+    secret: string;
+    scope?: string;
+}
+/** Storefront credential — anonymous token needs the client id only, no secret. */
+interface StorefrontCredentials {
+    clientId: string;
+    /**
+     * Session context bound at anonymous-login time. Required for
+     * `prices.matchByContext` to resolve currency/site/country server-side.
+     * `targetLocation` is an ISO country code.
+     */
+    context?: {
+        currency?: string;
+        siteCode?: string;
+        targetLocation?: string;
+    };
+}
+/** User-supplied SDK configuration. */
+interface EmporixConfig {
+    tenant: string;
+    host?: string;
+    credentials: {
+        /**
+         * Service (client-credentials) credentials. Optional: storefront/SPA apps
+         * use only `storefront` (anonymous) + caller-supplied customer tokens and
+         * must never ship a backend secret. Required only when a `service`
+         * AuthContext is actually used — enforced lazily by the TokenProvider.
+         */
+        backend?: ServiceCredentials;
+        storefront?: StorefrontCredentials;
+        custom?: Record<string, ServiceCredentials>;
+    };
+    tokenProvider?: TokenProvider;
+    timeouts?: {
+        connectMs?: number;
+        readMs?: number;
+    };
+    retry?: {
+        maxAttempts?: number;
+    };
+    cache?: {
+        expirationBufferSeconds?: number;
+        maxLifetimeSeconds?: number;
+    };
+    logger?: LoggerConfig;
+}
+/** Fully-resolved configuration with defaults applied. */
+interface ResolvedConfig {
+    tenant: string;
+    host: string;
+    credentials: EmporixConfig["credentials"];
+    tokenProvider: TokenProvider | undefined;
+    timeouts: {
+        connectMs: number;
+        readMs: number;
+    };
+    retry: {
+        maxAttempts: number;
+    };
+    cache: {
+        expirationBufferSeconds: number;
+        maxLifetimeSeconds: number;
+    };
+    logger: LoggerConfig | undefined;
+}
+/** Validates user config and applies defaults. Throws on invalid tenant/credentials. */
+declare function validateConfig(input: EmporixConfig): ResolvedConfig;
+
+/** Which token a call should use. */
+type AuthKind = "service" | "customer" | "anonymous" | "raw";
+/** Caller-supplied, per-call auth selector. Never stored on the client. */
+type AuthContext = {
+    kind: "service";
+    credentials?: string;
+} | {
+    kind: "anonymous";
+} | {
+    kind: "customer";
+    token: string;
+} | {
+    kind: "raw";
+    token: string;
+};
+/** An obtained anonymous storefront session. */
+interface AnonymousSession {
+    accessToken: string;
+    refreshToken: string;
+    sessionId: string;
+    expiresIn: number;
+}
+/**
+ * Persistence callback for anonymous sessions. `read` is called once on the
+ * first need for an anonymous token to bootstrap a possibly-existing session;
+ * `write` is called after every successful login or refresh. `write(null)`
+ * means the SDK is invalidating the stored session.
+ */
+interface AnonymousSessionStore {
+    read(): {
+        refreshToken: string;
+        sessionId: string;
+    } | null;
+    write(session: {
+        refreshToken: string;
+        sessionId: string;
+    } | null): void;
+}
+/** Supplies SDK-managed tokens (service/custom + anonymous). May be user-injected. */
+interface TokenProvider {
+    /** Service/custom client-credentials token for the named credential set. */
+    getToken(credentialSet: string): Promise<string>;
+    /** Cached anonymous storefront session (preserves sessionId across refreshes). */
+    getAnonymousToken(): Promise<AnonymousSession>;
+    /** Refresh the anonymous session, preserving sessionId. */
+    refreshAnonymous?(): Promise<AnonymousSession>;
+    /** Invalidate a cached SDK-managed token so the next call re-auths. */
+    invalidate?(credentialSet: string): void;
+    /** Invalidate the cached anonymous session entirely (next call re-logs in). */
+    invalidateAnonymous?(): void;
+    /**
+     * Mark the anonymous access token stale but keep the refresh token, so the
+     * next {@link getAnonymousToken} refreshes (preserving sessionId) rather
+     * than starting a brand-new session.
+     */
+    expireAnonymous?(): void;
+    /**
+     * Install a persistence adapter for the anonymous session. The host (e.g.
+     * `EmporixProvider`) calls this at construction so the SDK can bootstrap
+     * an existing session and persist refreshes. Idempotent: a later call
+     * replaces the previous adapter.
+     */
+    attachAnonymousStore?(store: AnonymousSessionStore): void;
+    /**
+     * Subscribe to token-refresh events. Optional — implementations may no-op.
+     * Returns an unsubscribe function. `DefaultTokenProvider` emits for the
+     * anonymous-login / anonymous-refresh paths.
+     */
+    onRefresh?(listener: (event: {
+        kind: "anonymous" | "customer";
+        success: boolean;
+    }) => void): () => void;
+}
+/** Tiny constructors for {@link AuthContext}. */
+declare const auth: {
+    /** Service/custom credential set (default `backend`). */
+    service: (credentials?: string) => AuthContext;
+    /** Cached anonymous storefront token. */
+    anonymous: () => AuthContext;
+    /** Caller-owned customer bearer token. */
+    customer: (token: string) => AuthContext;
+    /** Exact token, no transformation (SSO / token-exchange). */
+    raw: (token: string) => AuthContext;
+};
+/** Resolves an {@link AuthContext} to a concrete bearer token. */
+declare function resolveToken(ctx: AuthContext, provider: TokenProvider): Promise<string>;
+/** SDK-owned token provider: client-credentials service tokens + anonymous session. */
+declare class DefaultTokenProvider implements TokenProvider {
+    private readonly cfg;
+    private readonly serviceCache;
+    private readonly serviceLocks;
+    private anon;
+    private anonLock;
+    private anonStore?;
+    private readonly refreshListeners;
+    constructor(cfg: ResolvedConfig);
+    onRefresh(listener: (event: {
+        kind: "anonymous" | "customer";
+        success: boolean;
+    }) => void): () => void;
+    private notifyRefresh;
+    attachAnonymousStore(store: AnonymousSessionStore): void;
+    private creds;
+    private fresh;
+    getToken(set: string): Promise<string>;
+    private requestServiceToken;
+    invalidate(set: string): void;
+    private anonFresh;
+    getAnonymousToken(): Promise<AnonymousSession>;
+    /** Refreshes the anonymous session, preserving its sessionId. */
+    refreshAnonymous(): Promise<AnonymousSession>;
+    invalidateAnonymous(): void;
+    /** Force a stale access token while keeping the refresh token + sessionId. */
+    expireAnonymous(): void;
+    private stripExpiry;
+    private fetchAnonymous;
+}
+
+/** A single HTTP request through the SDK. */
+interface RequestOptions {
+    method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+    path: string;
+    auth: AuthContext;
+    query?: Record<string, string | number | undefined>;
+    body?: unknown;
+    /** Extra request headers (merged before auth; cannot override Authorization). */
+    headers?: Record<string, string>;
+    /** Per-request abort timeout override (ms). */
+    timeoutMs?: number;
+}
+/** Construction options for {@link HttpClient}. */
+interface HttpClientOptions {
+    host: string;
+    provider: TokenProvider;
+    logger: Logger;
+    retry: {
+        maxAttempts: number;
+    };
+    timeouts: {
+        connectMs: number;
+        readMs: number;
+    };
+    /** Override the retry backoff delay (ms → Promise). Defaults to a real timer. */
+    sleep?: (ms: number) => Promise<void>;
+}
+/** Fetch wrapper: auth resolution, JSON parsing, typed error mapping, logging. */
+declare class HttpClient {
+    private readonly opts;
+    private readonly sleep;
+    constructor(opts: HttpClientOptions);
+    request<T = unknown>(o: RequestOptions): Promise<T>;
+}
+
+/** Shared dependencies every service facade receives. */
+interface ClientContext {
+    tenant: string;
+    http: HttpClient;
+    tokenProvider: TokenProvider;
+    logger: Logger;
+}
+/**
+ * A cursor-paged collection — `pageNumber`/`pageSize` indexing with a
+ * `hasNextPage` signal driven by the source page being full. Used by all
+ * paginated services and hooks across the SDK.
+ */
+interface PaginatedItems<T> {
+    items: T[];
+    pageNumber: number;
+    pageSize: number;
+    hasNextPage: boolean;
+}
+/**
+ * Async-iterates every item across pages of a `PaginatedItems<T>` source.
+ * Stops when the source reports `hasNextPage: false`.
+ *
+ * @param fetchPage - given a 1-based page number, returns the page.
+ * @param start - first page to fetch (default `1`).
+ */
+declare function iterateAll<T>(fetchPage: (pageNumber: number) => Promise<PaginatedItems<T>>, start?: number): AsyncIterable<T>;
+
+export { type AnonymousSession as A, type ClientContext as C, DEFAULT_HOST as D, type EmporixConfig as E, HttpClient as H, LEVEL as L, type PaginatedItems as P, type RequestOptions as R, type ServiceCredentials as S, type TokenProvider as T, type AnonymousSessionStore as a, type AuthContext as b, type AuthKind as c, DefaultTokenProvider as d, type HttpClientOptions as e, LevelResolver as f, type LogFields as g, type LogLevel as h, type Logger as i, type LoggerConfig as j, type LoggerObjectConfig as k, type ResolvedConfig as l, type ServiceName as m, type StorefrontCredentials as n, auth as o, createConsoleLogger as p, createNoopLogger as q, iterateAll as r, redact as s, resolveToken as t, validateConfig as v };

package/dist/customer-groups.cjs

@@ -0,0 +1,25 @@
+'use strict';
+
+// src/services/customer-groups.ts
+var CustomerGroupsService = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  ctx;
+  base() {
+    return `/iam/${this.ctx.tenant}/groups`;
+  }
+  /** Lists customer groups belonging to one legal entity. */
+  async listForCompany(legalEntityId, auth) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: this.base(),
+      query: { "b2b.legalEntityId": legalEntityId },
+      auth
+    });
+  }
+};
+
+exports.CustomerGroupsService = CustomerGroupsService;
+//# sourceMappingURL=customer-groups.cjs.map
+//# sourceMappingURL=customer-groups.cjs.map

package/dist/customer-groups.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/services/customer-groups.ts"],"names":[],"mappings":";;;AAWO,IAAM,wBAAN,MAA4B;AAAA,EACjC,YAA6B,GAAA,EAAoB;AAApB,IAAA,IAAA,CAAA,GAAA,GAAA,GAAA;AAAA,EAAqB;AAAA,EAArB,GAAA;AAAA,EAErB,IAAA,GAAe;AACrB,IAAA,OAAO,CAAA,KAAA,EAAQ,IAAA,CAAK,GAAA,CAAI,MAAM,CAAA,OAAA,CAAA;AAAA,EAChC;AAAA;AAAA,EAGA,MAAM,cAAA,CAAe,aAAA,EAAuB,IAAA,EAAwC;AAClF,IAAA,OAAO,IAAA,CAAK,GAAA,CAAI,IAAA,CAAK,OAAA,CAAoB;AAAA,MACvC,MAAA,EAAQ,KAAA;AAAA,MACR,IAAA,EAAM,KAAK,IAAA,EAAK;AAAA,MAChB,KAAA,EAAO,EAAE,mBAAA,EAAqB,aAAA,EAAc;AAAA,MAC5C;AAAA,KACD,CAAA;AAAA,EACH;AACF","file":"customer-groups.cjs","sourcesContent":["import type { ClientContext } from \"../core/context\";\nimport type { AuthContext } from \"../core/auth\";\nimport type { IamGroup } from \"../generated/iam\";\n\n/**\n * Read-only access to IAM customer groups for a legal entity.\n *\n * Member-management endpoints (`addMember`/`removeMember`) are deferred —\n * the exact IAM path/body shape isn't in the SDK input set yet. They will\n * land in a small follow-up plan once the API reference is confirmed.\n */\nexport class CustomerGroupsService {\n  constructor(private readonly ctx: ClientContext) {}\n\n  private base(): string {\n    return `/iam/${this.ctx.tenant}/groups`;\n  }\n\n  /** Lists customer groups belonging to one legal entity. */\n  async listForCompany(legalEntityId: string, auth: AuthContext): Promise<IamGroup[]> {\n    return this.ctx.http.request<IamGroup[]>({\n      method: \"GET\",\n      path: this.base(),\n      query: { \"b2b.legalEntityId\": legalEntityId },\n      auth,\n    });\n  }\n}\n"]}

package/dist/customer-groups.d.cts

@@ -0,0 +1,36 @@
+import { C as ClientContext, b as AuthContext } from './context-vKgzZ-5f.cjs';
+
+/**
+ * Hand-written mirror of the minimal IAM Service group shape needed for
+ * B2B foundation reads. The Emporix IAM API exposes groups keyed by
+ * `b2b.legalEntityId`. Membership-mutation endpoints exist on the server
+ * but their exact path/body shape is not in the current SDK input set —
+ * `customer-groups.ts` ships read-only here; mutations follow in a small
+ * follow-up plan once the API reference is confirmed.
+ */
+interface IamGroupB2B {
+    legalEntityId?: string;
+}
+interface IamGroup {
+    id: string;
+    name?: Record<string, string>;
+    role?: string;
+    b2b?: IamGroupB2B;
+}
+
+/**
+ * Read-only access to IAM customer groups for a legal entity.
+ *
+ * Member-management endpoints (`addMember`/`removeMember`) are deferred —
+ * the exact IAM path/body shape isn't in the SDK input set yet. They will
+ * land in a small follow-up plan once the API reference is confirmed.
+ */
+declare class CustomerGroupsService {
+    private readonly ctx;
+    constructor(ctx: ClientContext);
+    private base;
+    /** Lists customer groups belonging to one legal entity. */
+    listForCompany(legalEntityId: string, auth: AuthContext): Promise<IamGroup[]>;
+}
+
+export { CustomerGroupsService, type IamGroup, type IamGroupB2B };

package/dist/customer-groups.d.ts

@@ -0,0 +1,36 @@
+import { C as ClientContext, b as AuthContext } from './context-vKgzZ-5f.js';
+
+/**
+ * Hand-written mirror of the minimal IAM Service group shape needed for
+ * B2B foundation reads. The Emporix IAM API exposes groups keyed by
+ * `b2b.legalEntityId`. Membership-mutation endpoints exist on the server
+ * but their exact path/body shape is not in the current SDK input set —
+ * `customer-groups.ts` ships read-only here; mutations follow in a small
+ * follow-up plan once the API reference is confirmed.
+ */
+interface IamGroupB2B {
+    legalEntityId?: string;
+}
+interface IamGroup {
+    id: string;
+    name?: Record<string, string>;
+    role?: string;
+    b2b?: IamGroupB2B;
+}
+
+/**
+ * Read-only access to IAM customer groups for a legal entity.
+ *
+ * Member-management endpoints (`addMember`/`removeMember`) are deferred —
+ * the exact IAM path/body shape isn't in the SDK input set yet. They will
+ * land in a small follow-up plan once the API reference is confirmed.
+ */
+declare class CustomerGroupsService {
+    private readonly ctx;
+    constructor(ctx: ClientContext);
+    private base;
+    /** Lists customer groups belonging to one legal entity. */
+    listForCompany(legalEntityId: string, auth: AuthContext): Promise<IamGroup[]>;
+}
+
+export { CustomerGroupsService, type IamGroup, type IamGroupB2B };

package/dist/customer-groups.js

@@ -0,0 +1,3 @@
+export { CustomerGroupsService } from './chunk-SKX7KCMH.js';
+//# sourceMappingURL=customer-groups.js.map
+//# sourceMappingURL=customer-groups.js.map

package/dist/customer-groups.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"customer-groups.js"}