@inductiv/node-red-openai-api 1.103.0 → 6.22.0

package/test/openai-node-auth-routing.test.js

@@ -0,0 +1,203 @@
+"use strict";
+
+const assert = require("node:assert/strict");
+const EventEmitter = require("node:events");
+const test = require("node:test");
+
+const OpenaiApi = require("../lib.js");
+const nodeModule = require("../node.js");
+
+function createEvaluateNodeProperty() {
+  return (value, type, node, msg, callback) => {
+    let resolvedValue = value;
+
+    if (type === "env" || type === "msg" || type === "flow" || type === "global") {
+      resolvedValue = `resolved:${type}:${value}`;
+    }
+
+    if (typeof callback === "function") {
+      callback(null, resolvedValue);
+      return undefined;
+    }
+
+    return resolvedValue;
+  };
+}
+
+function createNodeHarness() {
+  const registeredTypes = {};
+  const configNodes = new Map();
+
+  const RED = {
+    nodes: {
+      createNode: (node, config) => {
+        const emitter = new EventEmitter();
+        node.on = emitter.on.bind(emitter);
+        node.emit = emitter.emit.bind(emitter);
+
+        node.sentMessages = [];
+        node.errorMessages = [];
+        node.send = (msg) => {
+          node.sentMessages.push(msg);
+        };
+        node.error = (error, msg) => {
+          node.errorMessages.push({ error, msg });
+        };
+        node.status = () => { };
+        node.context = () => ({
+          flow: { get: () => undefined },
+          global: { get: () => undefined },
+        });
+
+        node.credentials = config.credentials || {};
+        node.id = config.id;
+      },
+      registerType: (name, ctor) => {
+        registeredTypes[name] = ctor;
+      },
+      getNode: (id) => configNodes.get(id),
+    },
+    util: {
+      evaluateNodeProperty: createEvaluateNodeProperty(),
+      getMessageProperty: (msg, path) => {
+        if (path === "payload") {
+          return msg.payload;
+        }
+
+        return path.split(".").reduce((value, key) => {
+          if (value === undefined || value === null) {
+            return undefined;
+          }
+          return value[key];
+        }, msg);
+      },
+    },
+  };
+
+  nodeModule(RED);
+
+  return {
+    OpenaiApiNode: registeredTypes["OpenAI API"],
+    ServiceHostNode: registeredTypes["Service Host"],
+    configNodes,
+  };
+}
+
+async function runAuthRoutingCase(serviceConfig) {
+  const harness = createNodeHarness();
+  assert.ok(harness.OpenaiApiNode, "OpenAI API node should register");
+  assert.ok(harness.ServiceHostNode, "Service Host node should register");
+
+  const serviceNode = new harness.ServiceHostNode({
+    id: "service-1",
+    apiBase: "https://api.example.com/v1",
+    apiBaseType: "str",
+    secureApiKeyHeaderOrQueryName: "Authorization",
+    secureApiKeyHeaderOrQueryNameType: "str",
+    organizationId: "OPENAI_ORG_ID",
+    organizationIdType: "env",
+    secureApiKeyIsQuery: false,
+    secureApiKeyValueType: "cred",
+    credentials: {
+      secureApiKeyValue: "sk-test",
+    },
+    ...serviceConfig,
+  });
+  harness.configNodes.set("service-1", serviceNode);
+
+  const apiNode = new harness.OpenaiApiNode({
+    id: "openai-1",
+    service: "service-1",
+    method: "createModelResponse",
+    property: "payload",
+    propertyType: "msg",
+  });
+
+  apiNode.emit("input", { payload: { model: "gpt-5-nano" } });
+
+  // Allow Promise-based input handler to resolve and send.
+  await new Promise((resolve) => setImmediate(resolve));
+  await new Promise((resolve) => setImmediate(resolve));
+
+  assert.equal(apiNode.errorMessages.length, 0);
+  assert.equal(apiNode.sentMessages.length, 1);
+}
+
+test("applies custom auth header to OpenAI client params", async () => {
+  const originalCreateModelResponse = OpenaiApi.prototype.createModelResponse;
+  const capturedClientParams = [];
+
+  OpenaiApi.prototype.createModelResponse = async function () {
+    capturedClientParams.push({ ...this.clientParams });
+    return { ok: true };
+  };
+
+  try {
+    await runAuthRoutingCase({
+      secureApiKeyHeaderOrQueryName: "X-API-Key",
+      secureApiKeyHeaderOrQueryNameType: "str",
+      secureApiKeyIsQuery: false,
+    });
+  } finally {
+    OpenaiApi.prototype.createModelResponse = originalCreateModelResponse;
+  }
+
+  assert.equal(capturedClientParams.length, 1);
+  assert.deepEqual(capturedClientParams[0].defaultHeaders, {
+    Authorization: null,
+    "X-API-Key": "sk-test",
+  });
+  assert.equal(capturedClientParams[0].defaultQuery, undefined);
+});
+
+test("applies query-string auth mode with typed header name", async () => {
+  const originalCreateModelResponse = OpenaiApi.prototype.createModelResponse;
+  const capturedClientParams = [];
+
+  OpenaiApi.prototype.createModelResponse = async function () {
+    capturedClientParams.push({ ...this.clientParams });
+    return { ok: true };
+  };
+
+  try {
+    await runAuthRoutingCase({
+      secureApiKeyHeaderOrQueryName: "OPENAI_AUTH_QUERY_PARAM",
+      secureApiKeyHeaderOrQueryNameType: "env",
+      secureApiKeyIsQuery: "true",
+    });
+  } finally {
+    OpenaiApi.prototype.createModelResponse = originalCreateModelResponse;
+  }
+
+  assert.equal(capturedClientParams.length, 1);
+  assert.deepEqual(capturedClientParams[0].defaultHeaders, {
+    Authorization: null,
+  });
+  assert.deepEqual(capturedClientParams[0].defaultQuery, {
+    "resolved:env:OPENAI_AUTH_QUERY_PARAM": "sk-test",
+  });
+});
+
+test("keeps OpenAI SDK default Authorization behavior when header stays Authorization", async () => {
+  const originalCreateModelResponse = OpenaiApi.prototype.createModelResponse;
+  const capturedClientParams = [];
+
+  OpenaiApi.prototype.createModelResponse = async function () {
+    capturedClientParams.push({ ...this.clientParams });
+    return { ok: true };
+  };
+
+  try {
+    await runAuthRoutingCase({
+      secureApiKeyHeaderOrQueryName: "Authorization",
+      secureApiKeyHeaderOrQueryNameType: "str",
+      secureApiKeyIsQuery: false,
+    });
+  } finally {
+    OpenaiApi.prototype.createModelResponse = originalCreateModelResponse;
+  }
+
+  assert.equal(capturedClientParams.length, 1);
+  assert.equal(capturedClientParams[0].defaultHeaders, undefined);
+  assert.equal(capturedClientParams[0].defaultQuery, undefined);
+});

package/test/service-host-editor-template.test.js

@@ -0,0 +1,53 @@
+"use strict";
+
+const assert = require("node:assert/strict");
+const fs = require("node:fs");
+const path = require("node:path");
+const test = require("node:test");
+
+const templatePath = path.join(__dirname, "..", "src", "node.html");
+const template = fs.readFileSync(templatePath, "utf8");
+
+test("service host API key editor uses native typedInput cred handling", () => {
+  assert.match(
+    template,
+    /types: \["cred", "env", "msg", "flow", "global"\],/
+  );
+  assert.match(
+    template,
+    /<input type="text" id="node-config-input-secureApiKeyValue" placeholder="" \/>/
+  );
+  assert.match(
+    template,
+    /<input\s+type="text"\s+id="node-config-input-secureApiKeyHeaderOrQueryName"\s+placeholder="Authorization"\s+\/>/
+  );
+  assert.match(
+    template,
+    /if \(inputValue && inputValue !== "__PWRD__"\) \{/
+  );
+  assert.match(
+    template,
+    /const syncApiKeyInputValue = function \(\) \{/
+  );
+  assert.match(
+    template,
+    /if \(selectedType !== "cred" && currentValue === "__PWRD__"\) \{/
+  );
+  assert.match(
+    template,
+    /apiKeyInput\.typedInput\("value", apiKeyRef\.val\(\) \|\| ""\);/
+  );
+  assert.match(
+    template,
+    /if \(selectedType === "cred" && previousApiKeyType !== "cred"\) \{/
+  );
+  assert.match(
+    template,
+    /const inputValue = apiKeyInput\.typedInput\("value"\);/
+  );
+  assert.match(
+    template,
+    /const existingCredValue = apiKeyInput\.val\(\);/
+  );
+  assert.ok(!/apiKeyInput\.prop\("type"/.test(template));
+});

package/test/service-host-node.test.js

@@ -0,0 +1,182 @@
+"use strict";
+
+const assert = require("node:assert/strict");
+const test = require("node:test");
+
+const nodeModule = require("../node.js");
+
+function createServiceHostNode(evaluateNodeProperty) {
+  let ServiceHostNode;
+
+  const RED = {
+    nodes: {
+      createNode: (node, config) => {
+        node.credentials = config.credentials || {};
+      },
+      registerType: (name, ctor) => {
+        if (name === "Service Host") {
+          ServiceHostNode = ctor;
+        }
+      },
+      getNode: () => undefined,
+    },
+    util: {
+      evaluateNodeProperty,
+    },
+  };
+
+  nodeModule(RED);
+  assert.ok(ServiceHostNode, "Service Host constructor should register");
+  return ServiceHostNode;
+}
+
+function createEvaluateNodeProperty(calls, options = {}) {
+  return (value, type, node, msg, callback) => {
+    calls.push({ value, type, node, msg, hasCallback: typeof callback === "function" });
+
+    if (type === "flow" || type === "global") {
+      const resolvedValue = `resolved:${type}:${value}`;
+      if (typeof callback === "function") {
+        const deliver = options.asyncFlowGlobal ? setImmediate : (fn) => fn();
+        deliver(() => callback(null, resolvedValue));
+        return undefined;
+      }
+      return resolvedValue;
+    }
+
+    if (type === "str" || type === "cred") {
+      if (typeof callback === "function") {
+        callback(null, value);
+        return undefined;
+      }
+      return value;
+    }
+
+    const resolvedValue = `resolved:${type}:${value}`;
+    if (typeof callback === "function") {
+      callback(null, resolvedValue);
+      return undefined;
+    }
+    return resolvedValue;
+  };
+}
+
+test("uses credential value when API key type is cred", () => {
+  const calls = [];
+  const ServiceHostNode = createServiceHostNode(createEvaluateNodeProperty(calls));
+  const node = new ServiceHostNode({
+    secureApiKeyValueType: "cred",
+    secureApiKeyValueRef: "",
+    credentials: { secureApiKeyValue: "sk-test" },
+  });
+
+  const result = node.evaluateTyped("secureApiKeyValue", {}, node);
+
+  assert.equal(result, "sk-test");
+  assert.equal(calls.length, 1);
+  assert.equal(calls[0].value, "sk-test");
+  assert.equal(calls[0].type, "cred");
+});
+
+test("uses explicit reference value when API key type is env", () => {
+  const calls = [];
+  const ServiceHostNode = createServiceHostNode(createEvaluateNodeProperty(calls));
+  const node = new ServiceHostNode({
+    secureApiKeyValueType: "env",
+    secureApiKeyValueRef: "OPENAI_API_KEY",
+    credentials: { secureApiKeyValue: "sk-ignored" },
+  });
+
+  const result = node.evaluateTyped("secureApiKeyValue", {}, node);
+
+  assert.equal(result, "resolved:env:OPENAI_API_KEY");
+  assert.equal(calls.length, 1);
+  assert.equal(calls[0].value, "OPENAI_API_KEY");
+  assert.equal(calls[0].type, "env");
+});
+
+test("supports legacy non-cred nodes that stored env reference in credentials", () => {
+  const calls = [];
+  const ServiceHostNode = createServiceHostNode(createEvaluateNodeProperty(calls));
+  const node = new ServiceHostNode({
+    secureApiKeyValueType: "env",
+    credentials: { secureApiKeyValue: "OPENAI_API_KEY" },
+  });
+
+  const result = node.evaluateTyped("secureApiKeyValue", {}, node);
+
+  assert.equal(result, "resolved:env:OPENAI_API_KEY");
+  assert.equal(calls.length, 1);
+  assert.equal(calls[0].value, "OPENAI_API_KEY");
+  assert.equal(calls[0].type, "env");
+});
+
+test("falls back to credential value when non-cred reference is empty", () => {
+  const calls = [];
+  const ServiceHostNode = createServiceHostNode(createEvaluateNodeProperty(calls));
+  const node = new ServiceHostNode({
+    secureApiKeyValueType: "env",
+    secureApiKeyValueRef: "",
+    credentials: { secureApiKeyValue: "OPENAI_API_KEY" },
+  });
+
+  const result = node.evaluateTyped("secureApiKeyValue", {}, node);
+
+  assert.equal(result, "resolved:env:OPENAI_API_KEY");
+  assert.equal(calls.length, 1);
+  assert.equal(calls[0].value, "OPENAI_API_KEY");
+  assert.equal(calls[0].type, "env");
+});
+
+test("supports legacy typed value stored only in credentials type field", () => {
+  const calls = [];
+  const ServiceHostNode = createServiceHostNode(createEvaluateNodeProperty(calls));
+  const node = new ServiceHostNode({
+    credentials: {
+      secureApiKeyValue: "OPENAI_API_KEY",
+      secureApiKeyValueType: "env",
+    },
+  });
+
+  const result = node.evaluateTyped("secureApiKeyValue", {}, node);
+
+  assert.equal(result, "resolved:env:OPENAI_API_KEY");
+  assert.equal(calls.length, 1);
+  assert.equal(calls[0].value, "OPENAI_API_KEY");
+  assert.equal(calls[0].type, "env");
+});
+
+test("supports legacy string API key values without reference field", () => {
+  const calls = [];
+  const ServiceHostNode = createServiceHostNode(createEvaluateNodeProperty(calls));
+  const node = new ServiceHostNode({
+    secureApiKeyValueType: "str",
+    credentials: { secureApiKeyValue: "sk-legacy" },
+  });
+
+  const result = node.evaluateTyped("secureApiKeyValue", {}, node);
+
+  assert.equal(result, "sk-legacy");
+  assert.equal(calls.length, 1);
+  assert.equal(calls[0].value, "sk-legacy");
+  assert.equal(calls[0].type, "str");
+});
+
+test("evaluateTypedAsync resolves flow/global types using callback path", async () => {
+  const calls = [];
+  const ServiceHostNode = createServiceHostNode(
+    createEvaluateNodeProperty(calls, { asyncFlowGlobal: true })
+  );
+  const node = new ServiceHostNode({
+    secureApiKeyValueType: "flow",
+    secureApiKeyValueRef: "openai.key",
+  });
+
+  const result = await node.evaluateTypedAsync("secureApiKeyValue", {}, node);
+
+  assert.equal(result, "resolved:flow:openai.key");
+  assert.equal(calls.length, 1);
+  assert.equal(calls[0].value, "openai.key");
+  assert.equal(calls[0].type, "flow");
+  assert.equal(calls[0].hasCallback, true);
+});

package/test/services.test.js

@@ -0,0 +1,147 @@
+"use strict";
+
+const assert = require("assert");
+const { createClient } = require("../src/client");
+const { createApi } = require("../src/index");
+
+// Mock the OpenAI API client
+jest.mock("../src/client", () => {
+  return {
+    createClient: jest.fn().mockReturnValue({
+      chat: {
+        completions: {
+          create: jest.fn().mockResolvedValue({ id: "chat-123", choices: [] }),
+        },
+      },
+      beta: {
+        threads: {
+          create: jest.fn().mockResolvedValue({ id: "thread-123" }),
+          messages: {
+            create: jest.fn().mockResolvedValue({ id: "message-123" }),
+            list: jest
+              .fn()
+              .mockResolvedValue({ data: [{ id: "message-123" }] }),
+            retrieve: jest.fn().mockResolvedValue({ id: "message-123" }),
+            update: jest
+              .fn()
+              .mockResolvedValue({ id: "message-123", updated: true }),
+          },
+        },
+      },
+      batches: {
+        create: jest.fn().mockResolvedValue({ id: "batch-123" }),
+        retrieve: jest
+          .fn()
+          .mockResolvedValue({ id: "batch-123", status: "pending" }),
+        list: jest.fn().mockResolvedValue({ data: [{ id: "batch-123" }] }),
+        cancel: jest
+          .fn()
+          .mockResolvedValue({ id: "batch-123", cancelled: true }),
+      },
+    }),
+  };
+});
+
+describe("API Services", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe("ChatService", () => {
+    it("should create chat completion", async () => {
+      const api = createApi({ apiKey: "test-key" });
+      const result = await api.chat.createChatCompletion({
+        payload: { messages: [{ role: "user", content: "Hello" }] },
+      });
+
+      assert.strictEqual(result.id, "chat-123");
+      expect(createClient).toHaveBeenCalledWith({ apiKey: "test-key" });
+    });
+  });
+
+  describe("MessagesService", () => {
+    it("should create a message", async () => {
+      const api = createApi({ apiKey: "test-key" });
+      const result = await api.messages.createMessage({
+        payload: { thread_id: "thread-123", content: "Hello" },
+      });
+
+      assert.strictEqual(result.id, "message-123");
+    });
+
+    it("should list messages", async () => {
+      const api = createApi({ apiKey: "test-key" });
+      const result = await api.messages.listMessages({
+        payload: { thread_id: "thread-123" },
+      });
+
+      assert.strictEqual(result.length, 1);
+      assert.strictEqual(result[0].id, "message-123");
+    });
+
+    it("should get a message", async () => {
+      const api = createApi({ apiKey: "test-key" });
+      const result = await api.messages.getMessage({
+        payload: { thread_id: "thread-123", message_id: "message-123" },
+      });
+
+      assert.strictEqual(result.id, "message-123");
+    });
+
+    it("should modify a message", async () => {
+      const api = createApi({ apiKey: "test-key" });
+      const result = await api.messages.modifyMessage({
+        payload: {
+          thread_id: "thread-123",
+          message_id: "message-123",
+          metadata: { updated: true },
+        },
+      });
+
+      assert.strictEqual(result.updated, true);
+    });
+  });
+
+  describe("BatchesService", () => {
+    it("should create a batch", async () => {
+      const api = createApi({ apiKey: "test-key" });
+      const result = await api.batches.createBatch({
+        payload: {
+          requests: [
+            { model: "gpt-4", messages: [{ role: "user", content: "Hello" }] },
+          ],
+        },
+      });
+
+      assert.strictEqual(result.id, "batch-123");
+    });
+
+    it("should retrieve a batch", async () => {
+      const api = createApi({ apiKey: "test-key" });
+      const result = await api.batches.retrieveBatch({
+        payload: { batch_id: "batch-123" },
+      });
+
+      assert.strictEqual(result.status, "pending");
+    });
+
+    it("should list batches", async () => {
+      const api = createApi({ apiKey: "test-key" });
+      const result = await api.batches.listBatches({
+        payload: {},
+      });
+
+      assert.strictEqual(result.length, 1);
+      assert.strictEqual(result[0].id, "batch-123");
+    });
+
+    it("should cancel a batch", async () => {
+      const api = createApi({ apiKey: "test-key" });
+      const result = await api.batches.cancelBatch({
+        payload: { batch_id: "batch-123" },
+      });
+
+      assert.strictEqual(result.cancelled, true);
+    });
+  });
+});

package/test/utils.test.js

@@ -0,0 +1,75 @@
+"use strict";
+
+const assert = require("assert");
+const { validation, streaming, fileHelpers } = require("../src/index").utils;
+
+describe("Utility Functions", () => {
+  describe("Validation", () => {
+    it("should validate required parameters", () => {
+      const schema = {
+        required: ["name"],
+        properties: {
+          name: { type: "string" },
+          age: { type: "number" },
+        },
+      };
+
+      // Valid case
+      expect(() =>
+        validation.validateParams({ name: "Test" }, schema)
+      ).not.toThrow();
+
+      // Invalid case - missing required field
+      expect(() => validation.validateParams({}, schema)).toThrow();
+
+      // Invalid case - wrong type
+      expect(() => validation.validateParams({ name: 123 }, schema)).toThrow();
+    });
+  });
+
+  describe("Streaming", () => {
+    it("should create a streaming handler", () => {
+      const onData = jest.fn();
+      const onError = jest.fn();
+      const onFinish = jest.fn();
+
+      const handler = streaming.createStreamHandler({
+        onData,
+        onError,
+        onFinish,
+      });
+
+      expect(handler).toHaveProperty("controller");
+      expect(handler).toHaveProperty("stream");
+
+      // Mock data event
+      const mockChunk = { choices: [{ delta: { content: "Hello" } }] };
+      handler.onChunk(mockChunk);
+      expect(onData).toHaveBeenCalledWith(mockChunk);
+
+      // Mock done event
+      handler.onDone();
+      expect(onFinish).toHaveBeenCalled();
+    });
+  });
+
+  describe("File Helpers", () => {
+    it("should determine file type from path", () => {
+      expect(fileHelpers.getFileTypeFromPath("image.png")).toBe("image");
+      expect(fileHelpers.getFileTypeFromPath("audio.mp3")).toBe("audio");
+      expect(fileHelpers.getFileTypeFromPath("document.pdf")).toBe("document");
+    });
+
+    it("should validate file size", () => {
+      const mockFile = { size: 1024 * 1024 }; // 1MB
+
+      // File under limit
+      expect(fileHelpers.validateFileSize(mockFile, 2 * 1024 * 1024)).toBe(
+        true
+      );
+
+      // File exceeds limit
+      expect(fileHelpers.validateFileSize(mockFile, 512 * 1024)).toBe(false);
+    });
+  });
+});