@minipim/sdk 0.2.0 → 0.3.0

package/dist/index.d.ts

@@ -1,17 +1,132 @@
+import { Client } from 'openapi-fetch';
+import { paths } from './openapi.js';
+export { components, operations } from './openapi.js';
+export { AttributeValueRecord, AttributesPayload, Measurement, Money, ResolveOptions, asMeasurement, asMoney, flattenAttributes, formatMoney, getAttribute } from './attributes.js';
+
 /**
- * @minipim/sdk — typed TypeScript client for the MiniPim API.
+ * Thin wrapper around `openapi-fetch` that pre-binds the tenancy header and
+ * (optionally) an API key. Returns the standard openapi-fetch client, so all
+ * its features (request interceptors, raw response access, etc.) work as
+ * documented at https://openapi-ts.dev/openapi-fetch/.
+ */
+
+interface CreateMinipimClientOptions {
+    /**
+     * Base URL of the MiniPim API, e.g. `https://api.minipim.com`. Required.
+     * Trailing slashes are normalized.
+     */
+    baseUrl: string;
+    /**
+     * Tenant the client speaks for. Required — every authenticated endpoint
+     * needs `x-organization-id`. API keys identify the principal, not the
+     * tenant.
+     */
+    organizationId: string;
+    /**
+     * Bearer API key (e.g. `pim_abc123…`). Issue one in the admin under
+     * /api-keys. If you're running in dev with `PIM_AUTH=header`, omit this
+     * and set `userId` instead.
+     */
+    apiKey?: string;
+    /**
+     * Dev-only header (`x-pim-user-id`). Only set when the deployment is in
+     * `header` auth mode. Ignored in `jwt` / `clerk` deployments.
+     */
+    userId?: string;
+    /**
+     * Extra headers merged onto every request — useful for tracing IDs,
+     * feature flags, etc. Don't put auth here; use `apiKey`/`userId` so the
+     * names stay consistent.
+     */
+    headers?: Record<string, string>;
+    /**
+     * Override `fetch` — pass a polyfill in Node <18 or a wrapped fetch that
+     * adds timeouts, retries, telemetry. Defaults to the global `fetch`.
+     */
+    fetch?: typeof fetch;
+}
+type MinipimClient = Client<paths>;
+/**
+ * Create a typed MiniPim client.
+ *
+ * @example
+ * ```ts
+ * import { createMinipimClient } from '@minipim/sdk';
+ *
+ * const pim = createMinipimClient({
+ *   baseUrl: 'https://api.minipim.com',
+ *   organizationId: '00000000-0000-0000-0000-000000000001',
+ *   apiKey: process.env.MINIPIM_API_KEY!,
+ * });
+ *
+ * const { data, error } = await pim.GET('/v1/products', {
+ *   params: { query: { limit: 50, categoryId: '…' } },
+ * });
+ * if (error) throw new Error(error.error.message);
+ * console.log(data.hasMore, data.data.length);
+ * ```
+ */
+declare function createMinipimClient(opts: CreateMinipimClientOptions): MinipimClient;
+
+/**
+ * Generic pagination helper. Every MiniPim list endpoint returns
+ * `{ data, limit, offset, hasMore }`; this walks the pages so consumers
+ * don't hand-roll the `hasMore` loop. Yields one item at a time.
  *
- * Edge-safe: this entry point imports no `node:` modules. The Node webhook
- * verifier lives at `@minipim/sdk/webhook` (imports node:crypto); the Edge
- * verifier at `@minipim/sdk/webhook-edge`. Keeping them off the root means
- * `createMinipimClient` can be imported in Edge runtimes without pulling
- * node:crypto into the bundle.
+ * Typed loosely on purpose — openapi-fetch's per-path generics don't
+ * compose into a single reusable signature without a lot of conditional-
+ * type machinery, and the envelope shape is uniform across list endpoints.
+ * The item type is yours to specify via the generic.
+ */
+
+interface PaginateOptions {
+    /** Query params (filters, sort, withTotal, etc). `limit`/`offset` are managed for you. */
+    query?: Record<string, unknown>;
+    /** Page size. Default 200 (the API max). */
+    pageSize?: number;
+}
+/**
+ * Async-iterate every item across all pages of a MiniPim list endpoint.
+ *
+ * @example
+ * ```ts
+ * import { paginate } from '@minipim/sdk';
+ * for await (const product of paginate<Product>(pim, '/v1/products', {
+ *   query: { status: 'active' },
+ * })) {
+ *   await ingest(product);
+ * }
+ * ```
+ */
+declare function paginate<T = unknown>(client: MinipimClient, path: string, opts?: PaginateOptions): AsyncGenerator<T, void, unknown>;
+/** Collect every page into an array. Convenience around {@link paginate}. */
+declare function collectAll<T = unknown>(client: MinipimClient, path: string, opts?: PaginateOptions): Promise<T[]>;
+
+/**
+ * Error envelope + type guard. Every MiniPim 4xx/5xx returns
+ * `{ error: { code, message, details? } }`. openapi-fetch types `res.error`
+ * as a union across a path's declared error responses, which is awkward to
+ * narrow to `.error.message`. This guard collapses that to a single shape.
+ */
+interface MinipimError {
+    error: {
+        code: string;
+        message: string;
+        details?: unknown;
+    };
+}
+/** True when `value` is a MiniPim `{ error: { code, message } }` envelope. */
+declare function isMinipimError(value: unknown): value is MinipimError;
+/**
+ * Pull a human-readable message out of an openapi-fetch `error` value,
+ * whatever its declared union shape. Falls back to `fallback`.
  *
- * See packages/sdk/README.md for examples.
+ * @example
+ * ```ts
+ * const { data, error } = await pim.GET('/v1/products');
+ * if (error) throw new Error(getErrorMessage(error, 'request failed'));
+ * ```
  */
-export { createMinipimClient, type CreateMinipimClientOptions, type MinipimClient, } from './client.js';
-export { paginate, collectAll, type PaginateOptions, } from './paginate.js';
-export { isMinipimError, getErrorMessage, type MinipimError, } from './errors.js';
-export { getAttribute, flattenAttributes, asMoney, asMeasurement, formatMoney, type AttributeValueRecord, type AttributesPayload, type Money, type Measurement, type ResolveOptions, } from './attributes.js';
-export type { paths, components, operations } from './openapi.js';
-//# sourceMappingURL=index.d.ts.map
+declare function getErrorMessage(error: unknown, fallback?: string): string;
+
+export { type CreateMinipimClientOptions, type MinipimClient, type MinipimError, type PaginateOptions, collectAll, createMinipimClient, getErrorMessage, isMinipimError, paginate, paths };

package/dist/index.js

@@ -1,16 +1,117 @@
-/**
- * @minipim/sdk — typed TypeScript client for the MiniPim API.
- *
- * Edge-safe: this entry point imports no `node:` modules. The Node webhook
- * verifier lives at `@minipim/sdk/webhook` (imports node:crypto); the Edge
- * verifier at `@minipim/sdk/webhook-edge`. Keeping them off the root means
- * `createMinipimClient` can be imported in Edge runtimes without pulling
- * node:crypto into the bundle.
- *
- * See packages/sdk/README.md for examples.
- */
-export { createMinipimClient, } from './client.js';
-export { paginate, collectAll, } from './paginate.js';
-export { isMinipimError, getErrorMessage, } from './errors.js';
-export { getAttribute, flattenAttributes, asMoney, asMeasurement, formatMoney, } from './attributes.js';
-//# sourceMappingURL=index.js.map
+// src/client.ts
+import createClient from "openapi-fetch";
+function createMinipimClient(opts) {
+  const headers = {
+    "x-organization-id": opts.organizationId,
+    ...opts.headers ?? {}
+  };
+  if (opts.apiKey) headers["Authorization"] = `Bearer ${opts.apiKey}`;
+  if (opts.userId) headers["x-pim-user-id"] = opts.userId;
+  return createClient({
+    baseUrl: opts.baseUrl.replace(/\/$/, ""),
+    fetch: opts.fetch,
+    headers
+  });
+}
+
+// src/paginate.ts
+async function* paginate(client, path, opts = {}) {
+  const pageSize = opts.pageSize ?? 200;
+  let offset = 0;
+  for (; ; ) {
+    const get = client.GET;
+    const { data, error, response } = await get(path, {
+      params: { query: { ...opts.query ?? {}, limit: pageSize, offset } }
+    });
+    if (error || !data) {
+      throw new Error(
+        `paginate ${path} failed at offset ${offset} (HTTP ${response?.status})`
+      );
+    }
+    if (Array.isArray(data)) {
+      for (const item of data) yield item;
+      return;
+    }
+    if (!Array.isArray(data.data)) {
+      throw new Error(
+        `paginate ${path}: response is neither a list envelope nor an array \u2014 this endpoint may not be paginatable`
+      );
+    }
+    for (const item of data.data) yield item;
+    const more = data.hasMore ?? data.data.length === pageSize;
+    if (!more || data.data.length === 0) return;
+    offset += pageSize;
+  }
+}
+async function collectAll(client, path, opts = {}) {
+  const out = [];
+  for await (const item of paginate(client, path, opts)) out.push(item);
+  return out;
+}
+
+// src/errors.ts
+function isMinipimError(value) {
+  if (!value || typeof value !== "object") return false;
+  const e = value.error;
+  return !!e && typeof e === "object" && typeof e.code === "string" && typeof e.message === "string";
+}
+function getErrorMessage(error, fallback = "request failed") {
+  return isMinipimError(error) ? error.error.message : fallback;
+}
+
+// src/attributes.ts
+function getAttribute(attributes, code, opts = {}) {
+  const records = attributes[code];
+  if (!records || records.length === 0) return void 0;
+  const locale = opts.locale ?? null;
+  const channel = opts.channel ?? null;
+  const layers = [
+    [locale, channel],
+    [locale, null],
+    [null, channel],
+    [null, null]
+  ];
+  for (const [l, c] of layers) {
+    const hit = records.find((r) => r.locale === l && r.channel === c);
+    if (hit) return hit.value;
+  }
+  return void 0;
+}
+function flattenAttributes(attributes, opts = {}) {
+  const out = {};
+  for (const code of Object.keys(attributes)) {
+    const v = getAttribute(attributes, code, opts);
+    if (v !== void 0) out[code] = v;
+  }
+  return out;
+}
+function asMoney(value) {
+  if (value && typeof value === "object" && typeof value.amount_cents === "number" && typeof value.currency === "string") {
+    return value;
+  }
+  return null;
+}
+function asMeasurement(value) {
+  if (value && typeof value === "object" && typeof value.amount === "number" && typeof value.unit === "string") {
+    return value;
+  }
+  return null;
+}
+function formatMoney(money, locale = "en-US") {
+  return new Intl.NumberFormat(locale, {
+    style: "currency",
+    currency: money.currency
+  }).format(money.amount_cents / 100);
+}
+export {
+  asMeasurement,
+  asMoney,
+  collectAll,
+  createMinipimClient,
+  flattenAttributes,
+  formatMoney,
+  getAttribute,
+  getErrorMessage,
+  isMinipimError,
+  paginate
+};

package/dist/openapi.cjs

@@ -0,0 +1,18 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/openapi.ts
+var openapi_exports = {};
+module.exports = __toCommonJS(openapi_exports);