@blokjs/api-call 2.0.1 → 2.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@blokjs/api-call",
-	"version": "2.0.1",
+	"version": "2.2.0",
 	"files": ["dist"],
 	"description": "Node module for making API calls",
 	"type": "module",
@@ -26,8 +26,8 @@
 		"vitest": "^4.0.18"
 	},
 	"dependencies": {
-		"@blokjs/runner": "^2.0.1",
-		"@blokjs/shared": "^2.0.1",
+		"@blokjs/runner": "^2.1.0",
+		"@blokjs/shared": "^2.1.0",
 		"lodash": "^4.17.21",
 		"zod": "^3.24.2"
 	},

package/dist/test/index.test.d.ts

@@ -1,7 +0,0 @@
-/**
- * API Call Node Tests - Updated for Function-First Implementation
- *
- * Tests migrated from class-based to function-first pattern.
- * All existing behavior is preserved.
- */
-export {};

package/dist/test/index.test.js

@@ -1,110 +0,0 @@
-/**
- * API Call Node Tests - Updated for Function-First Implementation
- *
- * Tests migrated from class-based to function-first pattern.
- * All existing behavior is preserved.
- */
-import { describe, expect, it, vi } from "vitest";
-import ApiCallNode from "../index.js";
-import { runApiCall } from "../util.js";
-// Mock the util function
-vi.mock("../util", () => ({
-    runApiCall: vi.fn(),
-}));
-describe("ApiCall Node - Function-First", () => {
-    const mockContext = {
-        id: "test-id",
-        workflow_name: "test-workflow",
-        workflow_path: "/test",
-        request: {
-            method: "POST",
-            body: { default: "data" },
-            headers: {},
-            params: {},
-            query: {},
-        },
-        response: {
-            data: {},
-            success: true,
-            error: null,
-        },
-        error: {
-            message: [],
-        },
-        vars: {},
-        config: {
-            "api-call": {}, // Node configuration
-        },
-        logger: {
-            log: vi.fn(),
-            info: vi.fn(),
-            error: vi.fn(),
-            warn: vi.fn(),
-            debug: vi.fn(),
-        },
-        env: {},
-        eventLogger: null,
-        _PRIVATE_: null,
-    };
-    const validInputs = {
-        method: "GET",
-        url: "https://api.example.com",
-        headers: { Authorization: "Bearer token" },
-        responseType: "json",
-        body: { key: "value" },
-    };
-    it("should successfully make an API call and return response", async () => {
-        const mockResult = { success: true, data: { message: "API Response" } };
-        // Mock the API call
-        vi.mocked(runApiCall).mockResolvedValue(mockResult);
-        // Execute the node using handle()
-        const result = (await ApiCallNode.handle(mockContext, validInputs));
-        // Check the result structure
-        expect(result.success).toBe(true);
-        expect(result.data).toEqual(mockResult);
-        expect(result.error).toBeNull();
-    });
-    it("should use ctx.response.data as the body if inputs.body is empty", async () => {
-        mockContext.response.data = { fallback: "data" };
-        const inputsWithoutBody = { ...validInputs, body: {} };
-        const mockResult = { success: true, data: { fallback: "data" } };
-        vi.mocked(runApiCall).mockResolvedValue(mockResult);
-        const result = (await ApiCallNode.handle(mockContext, inputsWithoutBody));
-        expect(result.success).toBe(true);
-        expect(result.data).toEqual(mockResult);
-        expect(result.error).toBeNull();
-    });
-    it("should return an error if the API call fails", async () => {
-        const mockError = new Error("API request failed");
-        vi.mocked(runApiCall).mockRejectedValue(mockError);
-        const result = (await ApiCallNode.handle(mockContext, validInputs));
-        expect(result.success).toBe(false);
-        expect(result.error).toBeDefined();
-        expect(result.error.message).toBe("API request failed");
-        expect(result.error.context.code).toBe(500); // Runtime error = 500
-    });
-    it("should validate input with Zod and reject invalid URLs", async () => {
-        const invalidInputs = {
-            ...validInputs,
-            url: "not-a-valid-url",
-        };
-        const result = (await ApiCallNode.handle(mockContext, invalidInputs));
-        expect(result.success).toBe(false);
-        expect(result.error).toBeDefined();
-        expect(result.error.context.code).toBe(400); // Validation error = 400
-    });
-    it("should use default values for optional fields", async () => {
-        const minimalInputs = {
-            url: "https://api.example.com",
-        };
-        const mockResult = { success: true };
-        vi.mocked(runApiCall).mockResolvedValue(mockResult);
-        const result = (await ApiCallNode.handle(mockContext, minimalInputs));
-        expect(result.success).toBe(true);
-        // Verify runApiCall was called with defaults
-        expect(vi.mocked(runApiCall)).toHaveBeenCalledWith("https://api.example.com", "GET", // default
-        {}, // default headers
-        mockContext.response.data, // default body from context
-        "json");
-    });
-});

package/dist/test/util.test.d.ts

@@ -1,5 +0,0 @@
-/**
- * Tests for runApiCall's HTTP-error handling — it must NOT discard the upstream
- * status, body, or Retry-After header on a >=400 response.
- */
-export {};

package/dist/test/util.test.js

@@ -1,80 +0,0 @@
-/**
- * Tests for runApiCall's HTTP-error handling — it must NOT discard the upstream
- * status, body, or Retry-After header on a >=400 response.
- */
-import { GlobalError } from "@blokjs/shared";
-import { afterEach, describe, expect, it, vi } from "vitest";
-import { runApiCall } from "../util.js";
-function mockFetchResponse(opts) {
-    const headers = new Headers(opts.headers ?? {});
-    return {
-        status: opts.status,
-        statusText: opts.statusText ?? "",
-        ok: opts.status < 400,
-        headers,
-        json: async () => opts.json,
-        text: async () => opts.body ?? "",
-    };
-}
-describe("runApiCall — HTTP error handling", () => {
-    afterEach(() => {
-        vi.restoreAllMocks();
-    });
-    it("throws a GlobalError carrying the upstream status code on >=400 (not a generic 500)", async () => {
-        vi.stubGlobal("fetch", vi.fn(async () => mockFetchResponse({
-            status: 429,
-            statusText: "Too Many Requests",
-            headers: { "content-type": "application/json", "retry-after": "30" },
-            json: { error: "rate_limited" },
-        })));
-        const err = await runApiCall("https://api.example.com/x", "GET", {}, {}, "json").catch((e) => e);
-        expect(err).toBeInstanceOf(GlobalError);
-        const ge = err;
-        expect(ge.context.code).toBe(429);
-        expect(ge.context.name).toBe("ApiCallError");
-        expect(ge.context.json).toMatchObject({
-            status: 429,
-            statusText: "Too Many Requests",
-            retryAfter: "30",
-            retryAfterSeconds: 30,
-            body: { error: "rate_limited" },
-        });
-    });
-    it("captures a text body and an HTTP-date Retry-After", async () => {
-        const future = new Date(Date.now() + 60_000).toUTCString();
-        vi.stubGlobal("fetch", vi.fn(async () => mockFetchResponse({
-            status: 503,
-            statusText: "Service Unavailable",
-            headers: { "content-type": "text/plain", "retry-after": future },
-            body: "down for maintenance",
-        })));
-        const err = (await runApiCall("https://api.example.com/y", "GET", {}, {}, "json").catch((e) => e));
-        expect(err.context.code).toBe(503);
-        const json = err.context.json;
-        expect(json.body).toBe("down for maintenance");
-        expect(typeof json.retryAfterSeconds).toBe("number");
-        expect(json.retryAfterSeconds).toBeGreaterThan(50);
-    });
-    it("omits retry fields when no Retry-After header is present", async () => {
-        vi.stubGlobal("fetch", vi.fn(async () => mockFetchResponse({
-            status: 404,
-            statusText: "Not Found",
-            headers: { "content-type": "application/json" },
-            json: { message: "missing" },
-        })));
-        const err = (await runApiCall("https://api.example.com/z", "GET", {}, {}, "json").catch((e) => e));
-        expect(err.context.code).toBe(404);
-        const json = err.context.json;
-        expect(json).not.toHaveProperty("retryAfter");
-        expect(json.body).toMatchObject({ message: "missing" });
-    });
-    it("returns the parsed JSON body on a 2xx response", async () => {
-        vi.stubGlobal("fetch", vi.fn(async () => mockFetchResponse({
-            status: 200,
-            headers: { "content-type": "application/json" },
-            json: { ok: true },
-        })));
-        const result = await runApiCall("https://api.example.com/ok", "GET", {}, {}, "json");
-        expect(result).toEqual({ ok: true });
-    });
-});