ocpp-ws-io 1.0.0-alpha

package/test/queue.test.ts

@@ -0,0 +1,133 @@
+import { describe, it, expect, vi } from "vitest";
+import { Queue } from "../src/queue.js";
+
+describe("Queue", () => {
+  it("should initialize with concurrency of 1", () => {
+    const q = new Queue();
+    expect(q.concurrency).toBe(1);
+    expect(q.pending).toBe(0);
+    expect(q.running).toBe(0);
+    expect(q.size).toBe(0);
+  });
+
+  it("should accept a custom concurrency", () => {
+    const q = new Queue(5);
+    expect(q.concurrency).toBe(5);
+  });
+
+  it("should enforce minimum concurrency of 1", () => {
+    const q = new Queue(0);
+    expect(q.concurrency).toBe(1);
+    const q2 = new Queue(-5);
+    expect(q2.concurrency).toBe(1);
+  });
+
+  it("should execute a single task", async () => {
+    const q = new Queue();
+    const result = await q.push(async () => 42);
+    expect(result).toBe(42);
+  });
+
+  it("should execute tasks in order with concurrency 1", async () => {
+    const q = new Queue(1);
+    const order: number[] = [];
+
+    const results = await Promise.all([
+      q.push(async () => {
+        order.push(1);
+        return "a";
+      }),
+      q.push(async () => {
+        order.push(2);
+        return "b";
+      }),
+      q.push(async () => {
+        order.push(3);
+        return "c";
+      }),
+    ]);
+
+    expect(results).toEqual(["a", "b", "c"]);
+    expect(order).toEqual([1, 2, 3]);
+  });
+
+  it("should limit concurrent execution", async () => {
+    const q = new Queue(2);
+    let maxConcurrent = 0;
+    let current = 0;
+
+    const makeTask = () => async () => {
+      current++;
+      maxConcurrent = Math.max(maxConcurrent, current);
+      await new Promise((r) => setTimeout(r, 10));
+      current--;
+      return true;
+    };
+
+    await Promise.all([
+      q.push(makeTask()),
+      q.push(makeTask()),
+      q.push(makeTask()),
+      q.push(makeTask()),
+    ]);
+
+    expect(maxConcurrent).toBe(2);
+  });
+
+  it("should reject with task errors", async () => {
+    const q = new Queue();
+    await expect(
+      q.push(async () => {
+        throw new Error("fail");
+      }),
+    ).rejects.toThrow("fail");
+  });
+
+  it("should continue after task rejections", async () => {
+    const q = new Queue(1);
+
+    const p1 = q
+      .push(async () => {
+        throw new Error("first fails");
+      })
+      .catch(() => "caught");
+
+    const p2 = q.push(async () => "second ok");
+
+    const results = await Promise.all([p1, p2]);
+    expect(results).toEqual(["caught", "second ok"]);
+  });
+
+  it("should update concurrency dynamically", async () => {
+    const q = new Queue(1);
+    expect(q.concurrency).toBe(1);
+
+    q.setConcurrency(5);
+    expect(q.concurrency).toBe(5);
+  });
+
+  it("should track size correctly", async () => {
+    const q = new Queue(1);
+    let resolveFirst!: () => void;
+
+    const p1 = q.push(
+      () =>
+        new Promise<void>((r) => {
+          resolveFirst = r;
+        }),
+    );
+    const p2 = q.push(async () => "b");
+
+    // p1 is running, p2 is pending
+    expect(q.running).toBe(1);
+    expect(q.pending).toBe(1);
+    expect(q.size).toBe(2);
+
+    resolveFirst();
+    await Promise.all([p1, p2]);
+
+    // After resolution, allow microtask queue to drain
+    await new Promise((r) => setTimeout(r, 0));
+    expect(q.size).toBe(0);
+  });
+});

package/test/server.test.ts

@@ -0,0 +1,274 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { OCPPServer } from "../src/server.js";
+import { OCPPClient } from "../src/client.js";
+import type { OCPPServerClient } from "../src/server-client.js";
+
+let server: OCPPServer;
+let port: number;
+
+const getPort = (srv: import("node:http").Server): number => {
+  const addr = srv.address();
+  if (addr && typeof addr !== "string") return addr.port;
+  return 0;
+};
+
+describe("OCPPServer", () => {
+  afterEach(async () => {
+    if (server) await server.close({ force: true }).catch(() => {});
+  });
+
+  it("should start listening on a port", async () => {
+    server = new OCPPServer({ protocols: ["ocpp1.6"] });
+    const httpServer = await server.listen(0);
+    const addr = httpServer.address();
+    expect(addr).toBeDefined();
+    expect(typeof addr !== "string" && addr?.port).toBeGreaterThan(0);
+  });
+
+  it("should reject connections without auth callback set", async () => {
+    server = new OCPPServer({ protocols: ["ocpp1.6"] });
+    // No auth callback set — should still accept (no auth check)
+    const httpServer = await server.listen(0);
+    port = getPort(httpServer);
+
+    const client = new OCPPClient({
+      identity: "CS001",
+      endpoint: `ws://localhost:${port}`,
+      protocols: ["ocpp1.6"],
+      reconnect: false,
+    });
+
+    await client.connect();
+    expect(client.state).toBe(OCPPClient.OPEN);
+    await client.close({ force: true });
+  });
+
+  it("should expose connected clients", async () => {
+    server = new OCPPServer({ protocols: ["ocpp1.6"] });
+    server.auth((accept) => accept({ protocol: "ocpp1.6" }));
+    const httpServer = await server.listen(0);
+    port = getPort(httpServer);
+
+    expect(server.clients.size).toBe(0);
+
+    const client = new OCPPClient({
+      identity: "CS001",
+      endpoint: `ws://localhost:${port}`,
+      protocols: ["ocpp1.6"],
+      reconnect: false,
+    });
+
+    await client.connect();
+
+    // Wait for server to register the client
+    await new Promise((r) => setTimeout(r, 100));
+
+    expect(server.clients.size).toBe(1);
+    const [serverClient] = server.clients;
+    expect(serverClient.identity).toBe("CS001");
+
+    await client.close({ force: true });
+  });
+
+  it('should emit "client" event when a station connects', async () => {
+    server = new OCPPServer({ protocols: ["ocpp1.6"] });
+    server.auth((accept) => accept({ protocol: "ocpp1.6" }));
+    const httpServer = await server.listen(0);
+    port = getPort(httpServer);
+
+    const clientReceived = new Promise<OCPPServerClient>((resolve) => {
+      server.on("client", (sc) => resolve(sc));
+    });
+
+    const client = new OCPPClient({
+      identity: "CS_EMIT",
+      endpoint: `ws://localhost:${port}`,
+      protocols: ["ocpp1.6"],
+      reconnect: false,
+    });
+
+    await client.connect();
+
+    const sc = await clientReceived;
+    expect(sc.identity).toBe("CS_EMIT");
+    expect(sc.handshake).toBeDefined();
+    expect(sc.handshake.identity).toBe("CS_EMIT");
+
+    await client.close({ force: true });
+  });
+
+  it("should reject connections via auth callback", async () => {
+    server = new OCPPServer({ protocols: ["ocpp1.6"] });
+    server.auth((_accept, reject) => {
+      reject(401, "Bad credentials");
+    });
+    const httpServer = await server.listen(0);
+    port = getPort(httpServer);
+
+    const client = new OCPPClient({
+      identity: "CS_REJECTED",
+      endpoint: `ws://localhost:${port}`,
+      protocols: ["ocpp1.6"],
+      reconnect: false,
+    });
+
+    // Suppress the 'error' event to prevent unhandled error
+    client.on("error", () => {});
+
+    await expect(client.connect()).rejects.toThrow();
+  });
+
+  it("should parse identity from URL path", async () => {
+    server = new OCPPServer({ protocols: ["ocpp1.6"] });
+    let receivedIdentity = "";
+
+    server.auth((accept, _reject, handshake) => {
+      receivedIdentity = handshake.identity;
+      accept({ protocol: "ocpp1.6" });
+    });
+
+    const httpServer = await server.listen(0);
+    port = getPort(httpServer);
+
+    const client = new OCPPClient({
+      identity: "MY-STATION-123",
+      endpoint: `ws://localhost:${port}`,
+      protocols: ["ocpp1.6"],
+      reconnect: false,
+    });
+
+    await client.connect();
+    expect(receivedIdentity).toBe("MY-STATION-123");
+    await client.close({ force: true });
+  });
+
+  it("should remove client on disconnect", async () => {
+    server = new OCPPServer({ protocols: ["ocpp1.6"] });
+    server.auth((accept) => accept({ protocol: "ocpp1.6" }));
+    const httpServer = await server.listen(0);
+    port = getPort(httpServer);
+
+    const client = new OCPPClient({
+      identity: "CS_DISC",
+      endpoint: `ws://localhost:${port}`,
+      protocols: ["ocpp1.6"],
+      reconnect: false,
+    });
+
+    await client.connect();
+    await new Promise((r) => setTimeout(r, 100));
+    expect(server.clients.size).toBe(1);
+
+    await client.close();
+    await new Promise((r) => setTimeout(r, 100));
+    expect(server.clients.size).toBe(0);
+  });
+
+  it("should close all clients on server close", async () => {
+    server = new OCPPServer({ protocols: ["ocpp1.6"] });
+    server.auth((accept) => accept({ protocol: "ocpp1.6" }));
+    const httpServer = await server.listen(0);
+    port = getPort(httpServer);
+
+    const client = new OCPPClient({
+      identity: "CS_CLOSE_ALL",
+      endpoint: `ws://localhost:${port}`,
+      protocols: ["ocpp1.6"],
+      reconnect: false,
+    });
+
+    await client.connect();
+    await new Promise((r) => setTimeout(r, 100));
+
+    await server.close({ force: true });
+    expect(server.clients.size).toBe(0);
+  });
+});
+
+describe("OCPPServerClient", () => {
+  afterEach(async () => {
+    if (server) await server.close({ force: true }).catch(() => {});
+  });
+
+  it("should inherit options from server", async () => {
+    server = new OCPPServer({
+      protocols: ["ocpp1.6"],
+      callTimeoutMs: 5000,
+    });
+    server.auth((accept) => accept({ protocol: "ocpp1.6" }));
+    const httpServer = await server.listen(0);
+    port = getPort(httpServer);
+
+    const clientReceived = new Promise<OCPPServerClient>((resolve) => {
+      server.on("client", (sc) => resolve(sc));
+    });
+
+    const client = new OCPPClient({
+      identity: "CS_INHERIT",
+      endpoint: `ws://localhost:${port}`,
+      protocols: ["ocpp1.6"],
+      reconnect: false,
+    });
+
+    await client.connect();
+    const sc = await clientReceived;
+
+    expect(sc.identity).toBe("CS_INHERIT");
+    expect(sc.state).toBe(OCPPClient.OPEN);
+    expect(sc.protocol).toBe("ocpp1.6");
+
+    await client.close({ force: true });
+  });
+
+  it("should reject connect() call", async () => {
+    server = new OCPPServer({ protocols: ["ocpp1.6"] });
+    server.auth((accept) => accept({ protocol: "ocpp1.6" }));
+    const httpServer = await server.listen(0);
+    port = getPort(httpServer);
+
+    const clientReceived = new Promise<OCPPServerClient>((resolve) => {
+      server.on("client", (sc) => resolve(sc));
+    });
+
+    const client = new OCPPClient({
+      identity: "CS_NO_CONNECT",
+      endpoint: `ws://localhost:${port}`,
+      protocols: ["ocpp1.6"],
+      reconnect: false,
+    });
+
+    await client.connect();
+    const sc = await clientReceived;
+
+    await expect(sc.connect()).rejects.toThrow(
+      "Cannot connect from server client",
+    );
+    await client.close({ force: true });
+  });
+
+  it("should expose session data", async () => {
+    server = new OCPPServer({ protocols: ["ocpp1.6"] });
+    server.auth((accept) => accept({ protocol: "ocpp1.6" }));
+    const httpServer = await server.listen(0);
+    port = getPort(httpServer);
+
+    const clientReceived = new Promise<OCPPServerClient>((resolve) => {
+      server.on("client", (sc) => resolve(sc));
+    });
+
+    const client = new OCPPClient({
+      identity: "CS_SESSION",
+      endpoint: `ws://localhost:${port}`,
+      protocols: ["ocpp1.6"],
+      reconnect: false,
+    });
+
+    await client.connect();
+    const sc = await clientReceived;
+
+    expect(sc.session).toBeDefined();
+    expect(typeof sc.session).toBe("object");
+
+    await client.close({ force: true });
+  });
+});

package/test/util.test.ts

@@ -0,0 +1,103 @@
+import { describe, it, expect } from "vitest";
+import {
+  createRPCError,
+  getErrorPlainObject,
+  getPackageIdent,
+} from "../src/util.js";
+import {
+  RPCGenericError,
+  RPCNotImplementedError,
+  RPCFormatViolationError,
+  RPCInternalError,
+  RPCSecurityError,
+  RPCFrameworkError,
+} from "../src/errors.js";
+
+describe("createRPCError", () => {
+  it('should create RPCGenericError for "GenericError" code', () => {
+    const err = createRPCError("GenericError", "test msg");
+    expect(err).toBeInstanceOf(RPCGenericError);
+    expect(err.rpcErrorCode).toBe("GenericError");
+    expect(err.message).toBe("test msg");
+  });
+
+  it('should create RPCNotImplementedError for "NotImplemented" code', () => {
+    const err = createRPCError("NotImplemented");
+    expect(err).toBeInstanceOf(RPCNotImplementedError);
+    expect(err.rpcErrorCode).toBe("NotImplemented");
+  });
+
+  it("should create RPCFormatViolationError", () => {
+    const err = createRPCError("FormatViolation", "bad format");
+    expect(err).toBeInstanceOf(RPCFormatViolationError);
+    expect(err.rpcErrorCode).toBe("FormatViolation");
+  });
+
+  it("should create RPCInternalError", () => {
+    const err = createRPCError("InternalError", "internal");
+    expect(err).toBeInstanceOf(RPCInternalError);
+  });
+
+  it("should create RPCSecurityError", () => {
+    const err = createRPCError("SecurityError");
+    expect(err).toBeInstanceOf(RPCSecurityError);
+  });
+
+  it("should create RPCFrameworkError", () => {
+    const err = createRPCError("RpcFrameworkError");
+    expect(err).toBeInstanceOf(RPCFrameworkError);
+  });
+
+  it("should fallback to RPCGenericError for unknown error codes", () => {
+    const err = createRPCError("SomethingUnknown", "unknown code");
+    expect(err).toBeInstanceOf(RPCGenericError);
+    expect(err.rpcErrorCode).toBe("GenericError");
+  });
+
+  it("should include details in error when provided", () => {
+    const details = { key: "value" };
+    const err = createRPCError("GenericError", "msg", details);
+    expect(err.details).toEqual({ key: "value" });
+  });
+
+  it("should default details to empty object", () => {
+    const err = createRPCError("GenericError", "msg");
+    expect(err.details).toEqual({});
+  });
+});
+
+describe("getErrorPlainObject", () => {
+  it("should convert Error to plain object", () => {
+    const err = new Error("hello");
+    const obj = getErrorPlainObject(err);
+    expect(obj.message).toBe("hello");
+    expect(typeof obj.stack).toBe("string");
+  });
+
+  it("should handle RPCError with custom properties", () => {
+    const err = createRPCError("NotImplemented", "no handler");
+    const obj = getErrorPlainObject(err);
+    expect(obj.rpcErrorCode).toBe("NotImplemented");
+    expect(obj.message).toBe("no handler");
+  });
+
+  it("should handle errors with circular references gracefully", () => {
+    const err = new Error("circular");
+    (err as unknown as Record<string, unknown>).self = err;
+    // Should not throw, should return at least name and message
+    const obj = getErrorPlainObject(err);
+    expect(obj.name).toBe("Error");
+    expect(obj.message).toBe("circular");
+  });
+});
+
+describe("getPackageIdent", () => {
+  it("should return package identifier string", () => {
+    const ident = getPackageIdent();
+    expect(ident).toContain("ocpp-ws-io");
+  });
+
+  it("should return consistent value on repeated calls", () => {
+    expect(getPackageIdent()).toBe(getPackageIdent());
+  });
+});

package/test/ws-util.test.ts

@@ -0,0 +1,93 @@
+import { describe, it, expect } from "vitest";
+import { parseSubprotocols, isValidStatusCode } from "../src/ws-util.js";
+
+describe("parseSubprotocols", () => {
+  it("should parse a single subprotocol", () => {
+    const result = parseSubprotocols("ocpp1.6");
+    expect(result).toEqual(new Set(["ocpp1.6"]));
+  });
+
+  it("should parse multiple subprotocols", () => {
+    const result = parseSubprotocols("ocpp1.6, ocpp2.0.1");
+    expect(result).toEqual(new Set(["ocpp1.6", "ocpp2.0.1"]));
+  });
+
+  it("should parse multiple subprotocols with extra whitespace", () => {
+    const result = parseSubprotocols("ocpp1.6 , ocpp2.0.1 ,  ocpp2.1");
+    expect(result).toEqual(new Set(["ocpp1.6", "ocpp2.0.1", "ocpp2.1"]));
+  });
+
+  it("should parse a single protocol without commas", () => {
+    const result = parseSubprotocols("chat");
+    expect(result).toEqual(new Set(["chat"]));
+  });
+
+  it("should throw on empty string", () => {
+    expect(() => parseSubprotocols("")).toThrow(SyntaxError);
+  });
+
+  it("should throw on leading comma", () => {
+    expect(() => parseSubprotocols(",ocpp1.6")).toThrow(SyntaxError);
+  });
+
+  it("should throw on trailing comma", () => {
+    expect(() => parseSubprotocols("ocpp1.6,")).toThrow(SyntaxError);
+  });
+
+  it("should throw on duplicate protocols", () => {
+    expect(() => parseSubprotocols("ocpp1.6, ocpp1.6")).toThrow(SyntaxError);
+    expect(() => parseSubprotocols("ocpp1.6, ocpp1.6")).toThrow("duplicated");
+  });
+
+  it("should throw on invalid characters", () => {
+    expect(() => parseSubprotocols("ocpp[1.6]")).toThrow(SyntaxError);
+  });
+
+  it("should handle tab whitespace", () => {
+    const result = parseSubprotocols("ocpp1.6\t,\tocpp2.0.1");
+    expect(result).toEqual(new Set(["ocpp1.6", "ocpp2.0.1"]));
+  });
+});
+
+describe("isValidStatusCode", () => {
+  it("should accept 1000 (normal close)", () => {
+    expect(isValidStatusCode(1000)).toBe(true);
+  });
+
+  it("should accept 1001 (going away)", () => {
+    expect(isValidStatusCode(1001)).toBe(true);
+  });
+
+  it("should accept 1002 (protocol error)", () => {
+    expect(isValidStatusCode(1002)).toBe(true);
+  });
+
+  it("should accept 1011 (unexpected condition)", () => {
+    expect(isValidStatusCode(1011)).toBe(true);
+  });
+
+  it("should reject 1004 (reserved)", () => {
+    expect(isValidStatusCode(1004)).toBe(false);
+  });
+
+  it("should reject 1005 (no status received)", () => {
+    expect(isValidStatusCode(1005)).toBe(false);
+  });
+
+  it("should reject 1006 (abnormal closure)", () => {
+    expect(isValidStatusCode(1006)).toBe(false);
+  });
+
+  it("should accept 3000-4999 (application defined)", () => {
+    expect(isValidStatusCode(3000)).toBe(true);
+    expect(isValidStatusCode(4999)).toBe(true);
+    expect(isValidStatusCode(4000)).toBe(true);
+  });
+
+  it("should reject codes outside valid ranges", () => {
+    expect(isValidStatusCode(999)).toBe(false);
+    expect(isValidStatusCode(5000)).toBe(false);
+    expect(isValidStatusCode(0)).toBe(false);
+    expect(isValidStatusCode(2000)).toBe(false);
+  });
+});

package/tsconfig.json

@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2022"],
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "test"]
+}

package/tsup.config.ts

@@ -0,0 +1,16 @@
+import { defineConfig } from "tsup";
+
+export default defineConfig({
+  entry: {
+    index: "src/index.ts",
+    "adapters/redis": "src/adapters/redis.ts",
+  },
+  format: ["cjs", "esm"],
+  dts: true,
+  splitting: false,
+  sourcemap: true,
+  clean: true,
+  outDir: "dist",
+  target: "node18",
+  shims: true,
+});

package/vitest.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    globals: true,
+    testTimeout: 10000,
+    hookTimeout: 10000,
+    include: ["test/**/*.test.ts"],
+  },
+});