@reactionary/commercetools 0.10.44 → 0.10.46

package/factories/order-search/order-search.factory.js

@@ -13,7 +13,7 @@ class CommercetoolsOrderSearchFactory {
       pageNumber: (Math.ceil(data.offset / data.limit) || 0) + 1,
       pageSize: data.limit,
       totalCount: data.total || 0,
-      totalPages: Math.ceil((data.total || 0) / data.limit || 0) + 1,
+      totalPages: data.limit > 0 ? Math.ceil((data.total || 0) / data.limit) : 0,
       items: data.results.map((order) => this.parseOrderSearchItem(context, order))
     };
     return this.orderSearchResultSchema.parse(result);

package/factories/product-search/product-search.factory.js

@@ -38,7 +38,7 @@ class CommercetoolsProductSearchFactory {
       pageNumber: (Math.ceil(data.offset / data.limit) || 0) + 1,
       pageSize: data.limit,
       totalCount: data.total || 0,
-      totalPages: Math.ceil((data.total || 0) / data.limit || 0) + 1,
+      totalPages: data.limit > 0 ? Math.ceil((data.total || 0) / data.limit) : 0,
       items,
       facets
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reactionary/commercetools",
-  "version": "0.10.44",
+  "version": "0.10.46",
   "type": "module",
   "main": "./index.js",
   "types": "./src/index.d.ts",
@@ -9,7 +9,7 @@
     "url": "git+https://github.com/Solteq/reactionary.git"
   },
   "dependencies": {
-    "@reactionary/core": "0.10.44",
+    "@reactionary/core": "0.10.46",
     "zod": "4.1.9",
     "@commercetools/ts-client": "^4.9.1",
     "@commercetools/platform-sdk": "^8.25.0",

package/src/test/fixture-fetch.d.ts

@@ -0,0 +1,14 @@
+import type { CommercetoolsConfiguration } from '../schema/configuration.schema.js';
+/**
+ * Record/replay of Commercetools HTTP traffic, so specs can run offline.
+ *
+ * By default, specs replay the interactions stored under __fixtures__/<suite>/<test>.json
+ * against a fake configuration. Run with CT_RECORD=1 to execute against the live project
+ * configured in the repository's .test.env and (re-)record the fixtures instead.
+ */
+export declare const isRecording: boolean;
+/**
+ * Registers record/replay hooks for the surrounding describe block and returns
+ * the configuration that specs should construct their clients with.
+ */
+export declare function useCommercetoolsFixtures(suite: string): CommercetoolsConfiguration;

package/test/fixture-fetch.js

@@ -0,0 +1,125 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { config as loadEnv } from "dotenv";
+import { afterEach, beforeEach, vi } from "vitest";
+import { getCommercetoolsTestConfiguration } from "./test-utils.js";
+const isRecording = process.env["CT_RECORD"] === "1";
+const FIXTURES = new URL("./__fixtures__/", import.meta.url);
+const TEST_ENV = new URL("../../../../.test.env", import.meta.url);
+const REDACTED_KEYS = /* @__PURE__ */ new Set(["access_token", "refresh_token", "client_id", "clientId"]);
+const realFetch = globalThis.fetch;
+function getFixtureConfiguration() {
+  if (isRecording) {
+    loadEnv({ path: TEST_ENV.pathname, quiet: true });
+    return getCommercetoolsTestConfiguration();
+  }
+  return {
+    ...getCommercetoolsTestConfiguration(),
+    apiUrl: "https://api.commercetools.test",
+    authUrl: "https://auth.commercetools.test",
+    clientId: "test-client-id",
+    clientSecret: "test-client-secret",
+    projectKey: "test-project",
+    scopes: []
+  };
+}
+function slugify(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+function sanitize(value, projectKey) {
+  if (Array.isArray(value)) {
+    return value.map((entry) => sanitize(entry, projectKey));
+  }
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, entry]) => {
+        if (typeof entry === "string" && REDACTED_KEYS.has(key)) {
+          return [key, `redacted-${key}`];
+        }
+        if (typeof entry === "string" && key === "scope") {
+          return [key, entry.replaceAll(`:${projectKey}`, ":{projectKey}")];
+        }
+        return [key, sanitize(entry, projectKey)];
+      })
+    );
+  }
+  return value;
+}
+function describeRequest(input, init) {
+  const url = input instanceof Request ? input.url : input.toString();
+  const method = (init?.method ?? (input instanceof Request ? input.method : "GET")).toUpperCase();
+  return { url, method };
+}
+function useCommercetoolsFixtures(suite) {
+  const config = getFixtureConfiguration();
+  const projectSegment = new RegExp(`/${config.projectKey}(?=/|\\?|$)`, "g");
+  const normalizeUrl = (url) => url.replace(config.authUrl, "{authUrl}").replace(config.apiUrl, "{apiUrl}").replace(projectSegment, "/{projectKey}");
+  let cassettePath;
+  let interactions = [];
+  let consumed = /* @__PURE__ */ new Set();
+  const recordingFetch = async (input, init) => {
+    const { url, method } = describeRequest(input, init);
+    const response = await realFetch(input, init);
+    const contentType = response.headers.get("content-type");
+    const text = await response.clone().text();
+    const isJson = contentType?.includes("json") ?? false;
+    interactions.push({
+      method,
+      url: normalizeUrl(url),
+      status: response.status,
+      contentType,
+      body: isJson && text ? sanitize(JSON.parse(text), config.projectKey) : text
+    });
+    return response;
+  };
+  const replayingFetch = async (input, init) => {
+    const { url, method } = describeRequest(input, init);
+    const normalized = normalizeUrl(url);
+    const index = interactions.findIndex(
+      (interaction2, i) => !consumed.has(i) && interaction2.method === method && interaction2.url === normalized
+    );
+    if (index === -1) {
+      throw new Error(
+        `No recorded Commercetools interaction for ${method} ${normalized} in ${cassettePath.pathname}. Re-record the fixtures with CT_RECORD=1.`
+      );
+    }
+    consumed.add(index);
+    const interaction = interactions[index];
+    const body = typeof interaction.body === "string" ? interaction.body : JSON.stringify(interaction.body);
+    return new Response(body || null, {
+      status: interaction.status,
+      headers: interaction.contentType ? { "content-type": interaction.contentType } : {}
+    });
+  };
+  beforeEach((context) => {
+    cassettePath = new URL(`${suite}/${slugify(context.task.name)}.json`, FIXTURES);
+    consumed = /* @__PURE__ */ new Set();
+    if (isRecording) {
+      interactions = [];
+    } else {
+      const cassette = existsSync(cassettePath) ? JSON.parse(readFileSync(cassettePath, "utf8")) : { interactions: [] };
+      interactions = cassette.interactions;
+    }
+    vi.stubGlobal("fetch", isRecording ? recordingFetch : replayingFetch);
+  });
+  afterEach(() => {
+    vi.unstubAllGlobals();
+    if (isRecording) {
+      if (interactions.length > 0) {
+        mkdirSync(new URL(".", cassettePath), { recursive: true });
+        writeFileSync(cassettePath, JSON.stringify({ interactions }, null, 2) + "\n");
+      }
+      return;
+    }
+    const unused = interactions.filter((_, i) => !consumed.has(i));
+    if (unused.length > 0) {
+      throw new Error(
+        `Recorded Commercetools interactions were not requested: ` + unused.map((interaction) => `${interaction.method} ${interaction.url}`).join(", ")
+      );
+    }
+  });
+  return config;
+}
+export {
+  isRecording,
+  useCommercetoolsFixtures
+};