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

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

@@ -0,0 +1,56 @@
+"use strict";
+
+// This file is about the editor-side Service Host experience.
+// It checks that the config UI still exposes the typed-input behavior we rely on for API keys and related fields.
+
+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,185 @@
+"use strict";
+
+// This file covers the runtime side of the Service Host config node.
+// It makes sure typed values resolve the right way, including the older storage formats we still support.
+
+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,150 @@
+"use strict";
+
+// This is a legacy high-level service test file.
+// It exercises the older service factory layer and mocked API client behavior in a more end-to-end style.
+
+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,78 @@
+"use strict";
+
+// This is a legacy utility test file.
+// It checks the small helper surfaces like validation, streaming helpers, and file utilities in plain terms.
+
+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);
+    });
+  });
+});