@poweredbysous/storefront-all-sdk 0.1.0

package/README.md

@@ -0,0 +1,55 @@
+# @poweredbysous/storefront-all-sdk
+
+Type-safe TypeScript SDK for all Storefront Backend endpoints (`/api/v1`) generated from OpenAPI.
+
+## Install
+
+```bash
+npm install @poweredbysous/storefront-all-sdk
+```
+
+```bash
+pnpm add @poweredbysous/storefront-all-sdk
+```
+
+```bash
+yarn add @poweredbysous/storefront-all-sdk
+```
+
+## Usage
+
+```ts
+import { createAllClient } from "@poweredbysous/storefront-all-sdk";
+
+const client = createAllClient({
+  baseUrl: "https://api.example.com",
+  vendorId: "BRASSERIE_VD_01",
+  language: "nl",
+});
+
+const response = await client.GET("/api/v1/products/");
+```
+
+`language` sets the `Accept-Language` request header and, by default, appends
+`?lang=<language>` to `GET`/`HEAD`/`OPTIONS` requests when `lang` is missing.
+Disable query injection with `appendLanguageQuery: false`.
+
+## Error Handling
+
+`sdkErrorFromResponse(response)` returns `SDKError` with:
+
+- `status` HTTP status code
+- `code` machine-readable API error code (when present)
+- `retryable` retry hint based on status/code
+- `requestId` correlation ID from `request_id` (when present)
+
+## Development
+
+```bash
+npm ci
+npm run generate
+npm run test
+npm run build
+```
+
+Generated types live in `src/generated/schema.ts`.

package/dist/index.cjs

@@ -0,0 +1,198 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  SDKError: () => SDKError,
+  buildDefaultHeaders: () => buildDefaultHeaders,
+  createAllClient: () => createAllClient,
+  sdkErrorFromResponse: () => sdkErrorFromResponse
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/client.ts
+var import_openapi_fetch = __toESM(require("openapi-fetch"), 1);
+var SAFE_LANGUAGE_METHODS = /* @__PURE__ */ new Set(["GET", "HEAD", "OPTIONS"]);
+function buildDefaultHeaders(options) {
+  const headers = new Headers(options.headers);
+  headers.set("X-Vendor-ID", options.vendorId);
+  if (options.token) {
+    headers.set("Authorization", `Bearer ${options.token}`);
+  }
+  if (options.language) {
+    headers.set("Accept-Language", options.language);
+  }
+  return headers;
+}
+function createAllClient(options) {
+  const runtimeFetch = options.fetch ?? fetch;
+  const authFetch = (input, init) => {
+    const requestInput = applyLanguageQueryParam(input, init, options);
+    const headers = buildDefaultHeaders(options);
+    const requestHeaders = new Headers(
+      isRequestInstance(requestInput) ? requestInput.headers : void 0
+    );
+    const initHeaders = new Headers(init?.headers);
+    initHeaders.forEach((value, key) => {
+      requestHeaders.set(key, value);
+    });
+    requestHeaders.forEach((value, key) => {
+      headers.set(key, value);
+    });
+    return runtimeFetch(requestInput, {
+      ...init,
+      headers
+    });
+  };
+  return (0, import_openapi_fetch.default)({
+    baseUrl: options.baseUrl,
+    fetch: authFetch
+  });
+}
+function applyLanguageQueryParam(input, init, options) {
+  if (!options.language || options.appendLanguageQuery === false) {
+    return input;
+  }
+  const method = resolveMethod(input, init);
+  if (!SAFE_LANGUAGE_METHODS.has(method)) {
+    return input;
+  }
+  const resolvedUrl = resolveUrl(input, options.baseUrl);
+  if (resolvedUrl === null || resolvedUrl.searchParams.has("lang")) {
+    return input;
+  }
+  resolvedUrl.searchParams.set("lang", options.language);
+  if (isRequestInstance(input)) {
+    return new Request(resolvedUrl.toString(), input);
+  }
+  return resolvedUrl.toString();
+}
+function resolveMethod(input, init) {
+  if (init?.method) {
+    return init.method.toUpperCase();
+  }
+  if (isRequestInstance(input)) {
+    return input.method.toUpperCase();
+  }
+  return "GET";
+}
+function resolveUrl(input, baseUrl) {
+  try {
+    if (typeof input === "string") {
+      return new URL(input, baseUrl);
+    }
+    if (input instanceof URL) {
+      return new URL(input.toString(), baseUrl);
+    }
+    if (isRequestInstance(input)) {
+      return new URL(input.url, baseUrl);
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function isRequestInstance(input) {
+  return typeof Request !== "undefined" && input instanceof Request;
+}
+
+// src/generated/retryability.ts
+var RETRYABLE_ERROR_CODES = /* @__PURE__ */ new Set([
+  "KEYCLOAK_ERROR",
+  "MERCHANT_AT_CAPACITY",
+  "OTP_RATE_LIMIT_EXCEEDED",
+  "RATE_LIMITED",
+  "REFUND_PROCESSING_FAILED",
+  "SUBSCRIPTION_STRIPE_ERROR"
+]);
+var RETRYABLE_HTTP_STATUSES = /* @__PURE__ */ new Set([429, 502]);
+
+// src/errors.ts
+var SDKError = class extends Error {
+  status;
+  code;
+  requestId;
+  retryable;
+  body;
+  constructor(message, status, options) {
+    super(message);
+    this.name = "SDKError";
+    this.status = status;
+    this.code = options?.code;
+    this.requestId = options?.requestId;
+    this.retryable = options?.retryable ?? false;
+    this.body = options?.body;
+  }
+};
+async function sdkErrorFromResponse(response) {
+  let body;
+  try {
+    body = await response.clone().json();
+  } catch {
+    body = await response.clone().text();
+  }
+  const payload = toObject(body);
+  const code = readString(payload, "error", "code");
+  const requestId = readString(payload, "request_id");
+  const retryable = isRetryable(response.status, code);
+  const message = code ? `Storefront API request failed with ${response.status} (${code})` : `Storefront API request failed with ${response.status}`;
+  return new SDKError(message, response.status, {
+    code,
+    requestId,
+    retryable,
+    body
+  });
+}
+function isRetryable(status, code) {
+  if (code && RETRYABLE_ERROR_CODES.has(code)) {
+    return true;
+  }
+  return RETRYABLE_HTTP_STATUSES.has(status);
+}
+function toObject(value) {
+  return value !== null && typeof value === "object" ? value : null;
+}
+function readString(value, ...keys) {
+  let current = value;
+  for (const key of keys) {
+    if (current === null || typeof current !== "object") {
+      return void 0;
+    }
+    current = current[key];
+  }
+  return typeof current === "string" ? current : void 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SDKError,
+  buildDefaultHeaders,
+  createAllClient,
+  sdkErrorFromResponse
+});