@poweredbysous/storefront-all-sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,158 @@
+// src/client.ts
+import createClient from "openapi-fetch";
+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 createClient({
+    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;
+}
+export {
+  SDKError,
+  buildDefaultHeaders,
+  createAllClient,
+  sdkErrorFromResponse
+};

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@poweredbysous/storefront-all-sdk",
+  "version": "0.1.0",
+  "description": "Type-safe TypeScript SDK for all SOUS Storefront Backend endpoints",
+  "license": "UNLICENSED",
+  "private": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=20",
+    "npm": ">=10"
+  },
+  "scripts": {
+    "generate": "uv run python ../../scripts/generate_sdk_retryability.py --schema ../../openapi/openapi.v1.json --output src/generated/retryability.ts && openapi-typescript ../../openapi/openapi.v1.json -o src/generated/schema.ts",
+    "build": "tsup src/index.ts --format esm,cjs --dts --clean",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "lint": "tsc --noEmit",
+    "prepack": "npm run generate && npm run build"
+  },
+  "dependencies": {
+    "openapi-fetch": "^0.14.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.13.5",
+    "openapi-typescript": "^7.6.1",
+    "tsup": "^8.3.5",
+    "typescript": "^5.8.2",
+    "vitest": "^3.2.4"
+  }
+}