@ominity/api-typescript 1.4.4 → 1.4.6

package/tests/core-operations.test.mjs

@@ -1,6 +1,7 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 import * as api from "../dist/esm/index.js";
+import { ErrorResponse } from "../dist/esm/models/errors/index.js";
 import { Subscription$inboundSchema } from "../dist/esm/models/index.js";
 
 const noRetries = { retries: { strategy: "none" } };
@@ -136,6 +137,32 @@ test("new operations encode deep filters, parse pagination, JSON bodies, and byt
   assert.deepEqual(JSON.parse(seen[3].body), { source_language: "en", target_languages: ["nl"], fields: [{ key: "title", source: "Hello" }] });
 });
 
+test("cart item creation sends only the camelCase request body", async () => {
+  let forwardedRequest;
+  const sdk = new api.Ominity({
+    serverURL: "https://example.test/api",
+    httpClient: new api.HTTPClient({
+      fetcher: async (request) => {
+        forwardedRequest = request.clone();
+        return new Response(JSON.stringify({ id: "item-1" }), {
+          status: 201,
+          headers: { "content-type": "application/hal+json" },
+        });
+      },
+    }),
+  });
+
+  await sdk.commerce.cartItems.create("cart-1", "6", 1, noRetries);
+
+  assert.ok(forwardedRequest instanceof Request);
+  assert.equal(forwardedRequest.method, "POST");
+  assert.equal(new URL(forwardedRequest.url).pathname, "/api/v1/commerce/carts/cart-1/items");
+  assert.deepEqual(JSON.parse(await forwardedRequest.text()), {
+    productId: "6",
+    quantity: 1,
+  });
+});
+
 test("Subscription parses the corrected productId field", () => {
   const parsed = Subscription$inboundSchema.parse({
     resource: "subscription", id: 1, customerId: 2, productId: 3, intervalId: 4, status: "active",
@@ -146,6 +173,89 @@ test("Subscription parses the corrected productId field", () => {
   assert.equal(parsed.productId, 3);
 });
 
+test("user action endpoints parse application/json responses and errors", async () => {
+  const responses = [
+    { status: 200, body: { success: true } },
+    { status: 200, body: { success: true } },
+    { status: 200, body: { success: true } },
+    { status: 200, body: { success: true, message: "Recovery code validated" } },
+    {
+      status: 200,
+      body: {
+        success: true,
+        message: "Password reset link send to users email.",
+        expiresAt: "2026-09-14T10:30:00Z",
+        createdAt: "2026-09-14T10:00:00Z",
+      },
+    },
+    {
+      status: 200,
+      body: {
+        success: true,
+        message: "Password reset successfully.",
+        updatedAt: "2026-09-14T10:05:00Z",
+      },
+    },
+    {
+      status: 422,
+      body: {
+        status: 422,
+        title: "Unprocessable Content",
+        detail: "The code field is required.",
+        _links: {
+          documentation: {
+            href: "https://docs.ominity.com/overview/handling-errors",
+            type: "text/html",
+          },
+        },
+      },
+    },
+  ];
+  const sdk = new api.Ominity({
+    serverURL: "https://example.test/api",
+    httpClient: new api.HTTPClient({
+      fetcher: async () => {
+        const response = responses.shift();
+        assert.ok(response, "a mocked response is available");
+        return new Response(JSON.stringify(response.body), {
+          status: response.status,
+          headers: { "content-type": "application/json" },
+        });
+      },
+    }),
+  });
+
+  assert.deepEqual(await sdk.users.mfaMethods.send({ id: 7, method: "email" }), { success: true });
+  assert.deepEqual(await sdk.users.mfaMethods.validate({ id: 7, method: "email", code: "123456" }), { success: true });
+  assert.deepEqual(await sdk.users.mfaMethods.disable({ id: 7, method: "email" }), { success: true });
+  assert.deepEqual(
+    await sdk.users.recoveryCodes.validate({ id: 7, code: "recovery-code" }),
+    { success: true, message: "Recovery code validated" },
+  );
+  assert.equal(
+    (await sdk.users.sendPasswordResetLink({
+      email: "person@example.test",
+      redirectUrl: "https://example.test/reset-password",
+    })).expiresAt,
+    "2026-09-14T10:30:00Z",
+  );
+  assert.equal(
+    (await sdk.users.resetPassword({
+      email: "person@example.test",
+      token: "reset-token",
+      password: "new-password",
+    })).updatedAt,
+    "2026-09-14T10:05:00Z",
+  );
+
+  await assert.rejects(
+    sdk.users.mfaMethods.send({ id: 7, method: "email" }),
+    (error) => error instanceof ErrorResponse
+      && error.status === 422
+      && error.detail === "The code field is required.",
+  );
+});
+
 test("existing subscription interval and VAT helpers use the registered routes", async () => {
   const seen = [];
   const sdk = new api.Ominity({
@@ -168,3 +278,33 @@ test("existing subscription interval and VAT helpers use the registered routes",
     "/api/v1/commerce/vatvalidations/BE0123456789",
   ]);
 });
+
+test("user customer membership failures preserve the API status and detail", async () => {
+  const sdk = new api.Ominity({
+    serverURL: "https://example.test/api",
+    httpClient: new api.HTTPClient({
+      fetcher: async () => new Response(JSON.stringify({
+        status: 403,
+        title: "Forbidden",
+        detail: "Could not authorize request",
+        _links: {
+          documentation: {
+            href: "https://docs.ominity.com/overview/handling-errors",
+            type: "text/html",
+          },
+        },
+      }), {
+        status: 403,
+        headers: { "content-type": "application/json" },
+      }),
+    }),
+  });
+
+  await assert.rejects(
+    sdk.users.customers.list({ id: 7 }, noRetries),
+    (error) => error instanceof ErrorResponse
+      && error.status === 403
+      && error.statusCode === 403
+      && error.detail === "Could not authorize request",
+  );
+});