@multiplatform.one/frappe 6.0.0

package/src/plugin/index.ts

@@ -0,0 +1,141 @@
+interface OpenAPI {
+  components?: {
+    schemas?: Record<string, any>;
+  };
+  paths?: Record<string, any>;
+}
+
+interface PluginConfig {
+  openapiUrl?: string;
+  namespace?: string;
+  cacheTTL?: number;
+}
+
+interface LanguageServiceProxy {
+  getExternalFiles(): string[];
+  getSourceFile(
+    fileName: string,
+    languageVersion: any,
+    _onError?: any,
+    _shouldCreateNewSourceFile?: boolean,
+    _length?: number,
+  ): any;
+}
+
+function init(modules: { typescript: any }) {
+  const ts = modules.typescript;
+  let openapi: OpenAPI | null = null;
+  let ns = "@frappe/types";
+  let lastFetch = 0;
+  let ttl = 60_000;
+
+  function create(info: any): LanguageServiceProxy {
+    const config: PluginConfig = info.config || {};
+    const url = (config.openapiUrl || "").toString();
+    ns = (config.namespace || ns).toString();
+    ttl = Number(config.cacheTTL || ttl);
+
+    async function ensureOpenAPI() {
+      const now = Date.now();
+      if (openapi && now - lastFetch < ttl) return;
+      if (!url) return;
+      try {
+        const res = await fetch(url);
+        openapi = await res.json();
+        lastFetch = now;
+      } catch {
+        // Silently ignore fetch errors
+      }
+    }
+
+    const proxy = new Proxy(info.languageService, {
+      get(target: any, prop: string) {
+        if (prop !== "getSemanticDiagnostics") return target[prop];
+        return async function (this: any, ...args: any[]) {
+          await ensureOpenAPI();
+          return target.getSemanticDiagnostics.apply(this, args);
+        };
+      },
+    });
+
+    function getExternalFiles(): string[] {
+      return openapi ? ["frappe-virtual-types.d.ts"] : [];
+    }
+
+    function getSourceFile(
+      fileName: string,
+      languageVersion: any,
+      _onError?: any,
+      _shouldCreateNewSourceFile?: boolean,
+      _length?: number,
+    ) {
+      if (fileName === "frappe-virtual-types.d.ts" && openapi) {
+        const content = emitDTS(openapi, ns);
+        return ts.createSourceFile(fileName, content, languageVersion);
+      }
+      return undefined;
+    }
+
+    return {
+      ...proxy,
+      getExternalFiles,
+      getSourceFile,
+    };
+  }
+
+  function emitDTS(spec: OpenAPI, ns: string): string {
+    const lines: string[] = [];
+    lines.push(`declare module "${ns}" {`);
+    const schemas = spec?.components?.schemas || {};
+    const paths = spec.paths || {};
+    const doctypes = new Set<string>();
+    for (const p of Object.keys(paths)) {
+      const parts = p.split("/").filter(Boolean);
+      const idx = parts.indexOf("resource");
+      if (idx >= 0 && parts[idx + 1]) doctypes.add(parts[idx + 1]);
+    }
+    lines.push(
+      `  export type Doctype = ${[...doctypes].map((d) => `'${d}'`).join(" | ") || "string"}`,
+    );
+    for (const [name, schema] of Object.entries(schemas)) {
+      if (schema?.enum) {
+        const members = schema.enum.map((x) => JSON.stringify(x)).join(" | ");
+        lines.push(`  export type ${safe(name)} = ${members}`);
+        continue;
+      }
+      if (schema?.type === "object" && schema?.properties) {
+        lines.push(`  export interface ${safe(name)} {`);
+        for (const [k, v] of Object.entries(schema?.properties || {})) {
+          const t = mapType(v);
+          const rq = Array.isArray(schema?.required) ? schema.required : [];
+          const optional = rq.indexOf(k) === -1;
+          lines.push(`    ${safe(k)}${optional ? "?" : ""}: ${t}`);
+        }
+        lines.push("  }");
+      }
+    }
+    lines.push("}");
+    return lines.join("\n");
+  }
+
+  function safe(s: string): string {
+    return s.replace(/[^a-zA-Z0-9_]/g, "_");
+  }
+
+  function mapType(v: any): string {
+    if (!v) return "any";
+    if (v.$ref) return safe(v.$ref.split("/").pop() || "any");
+    const t = v.type || v.schema?.type;
+    if (t === "string") return "string";
+    if (t === "integer" || t === "number") return "number";
+    if (t === "boolean") return "boolean";
+    if (t === "array") return `${mapType(v.items)}[]`;
+    if (t === "object") return "Record<string, any>";
+    return "any";
+  }
+
+  return { create };
+}
+
+// Export for ES modules (CJS is handled by the build tool)
+export default init;

package/src/realtime.spec.ts

@@ -0,0 +1,453 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { RealtimeModule } from "./realtime";
+
+// Mock socket.io-client
+const mockSocket = {
+  connected: false,
+  on: vi.fn(),
+  off: vi.fn(),
+  emit: vi.fn(),
+  connect: vi.fn(),
+  disconnect: vi.fn(),
+  id: "mock-socket-id",
+};
+
+vi.mock("socket.io-client", () => ({
+  io: vi.fn(() => {
+    // Return the mock socket when io() is called
+    return mockSocket;
+  }),
+}));
+
+describe("RealtimeModule", () => {
+  let realtime: RealtimeModule;
+
+  beforeEach(() => {
+    // Reset all mocks
+    vi.clearAllMocks();
+    mockSocket.connected = false;
+    mockSocket.on.mockImplementation((event: string, handler: Function) => {
+      // Simulate immediate connection for testing
+      if (event === "connect") {
+        mockSocket.connected = true;
+        setTimeout(() => handler(), 0);
+      }
+    });
+
+    realtime = new RealtimeModule({ baseURL: "http://localhost:3000" });
+  });
+
+  afterEach(() => {
+    // Clean up realtime module if it exists
+    if (realtime) {
+      realtime.disconnect();
+      realtime = undefined as any;
+    }
+    vi.clearAllMocks();
+  });
+
+  describe("constructor", () => {
+    it("should initialize without throwing", () => {
+      expect(() => new RealtimeModule({ baseURL: "http://localhost:3000" })).not.toThrow();
+    });
+
+    it("should initialize with auth config", () => {
+      const auth = { token: "test-token", useToken: true };
+      expect(() => new RealtimeModule({ baseURL: "http://localhost:3000", auth })).not.toThrow();
+    });
+
+    it("should detect platform", () => {
+      // Test React Native detection
+      const originalUA = (global as any).navigator?.userAgent;
+      Object.defineProperty(global, "navigator", {
+        value: { userAgent: "ReactNative" },
+        writable: true,
+      });
+      const rnInstance = new RealtimeModule({
+        baseURL: "http://localhost:3000",
+      });
+      expect(rnInstance).toBeDefined();
+
+      // Restore
+      if (originalUA) {
+        Object.defineProperty(global, "navigator", {
+          value: { userAgent: originalUA },
+          writable: true,
+        });
+      }
+    });
+  });
+
+  describe("connect", () => {
+    it("should establish socket connection", async () => {
+      await (realtime as any).connect();
+      expect(mockSocket.on).toHaveBeenCalledWith("connect", expect.any(Function));
+      expect(mockSocket.on).toHaveBeenCalledWith("disconnect", expect.any(Function));
+    });
+
+    it("should not connect twice", async () => {
+      await (realtime as any).connect();
+      const callCount = mockSocket.on.mock.calls.length;
+      await (realtime as any).connect();
+      expect(mockSocket.on).toHaveBeenCalledTimes(callCount); // No additional calls
+    });
+
+    it("should handle connection errors", async () => {
+      mockSocket.on.mockImplementation((event: string, handler: Function) => {
+        if (event === "connect_error") {
+          setTimeout(() => handler(new Error("Connection failed")), 0);
+        }
+      });
+      await (realtime as any).connect();
+      expect(mockSocket.on).toHaveBeenCalledWith("connect_error", expect.any(Function));
+    });
+  });
+
+  describe("on", () => {
+    it("should register event handler and create socket listener dynamically", async () => {
+      const handler = vi.fn();
+      await realtime.on("custom_event", handler);
+
+      // Should create socket listener for new event
+      expect(mockSocket.on).toHaveBeenCalledWith("custom_event", expect.any(Function));
+    });
+
+    it("should register multiple handlers for same event without duplicating socket listener", async () => {
+      const handler1 = vi.fn();
+      const handler2 = vi.fn();
+
+      // First connect to avoid the double registration issue
+      await (realtime as any).connect();
+
+      // Now add handlers after connection is established
+      await realtime.on("doc_changed", handler1);
+      const firstCallCount = mockSocket.on.mock.calls.filter(
+        (call: any[]) => call[0] === "doc_changed",
+      ).length;
+
+      await realtime.on("doc_changed", handler2);
+      const secondCallCount = mockSocket.on.mock.calls.filter(
+        (call: any[]) => call[0] === "doc_changed",
+      ).length;
+
+      // Should only create one socket listener for the event
+      expect(firstCallCount).toBe(1);
+      expect(secondCallCount).toBe(1); // Should not increase
+    });
+
+    it("should handle any event type", async () => {
+      const events = [
+        "doc_changed",
+        "doc_deleted",
+        "chat_message",
+        "notification",
+        "custom_event",
+        "iot_sensor",
+        "game_state",
+      ];
+
+      // Connect first to avoid double registration
+      await (realtime as any).connect();
+
+      for (const event of events) {
+        const handler = vi.fn();
+        await realtime.on(event, handler);
+      }
+
+      // Each event should have its socket listener
+      events.forEach((event) => {
+        const calls = mockSocket.on.mock.calls.filter((call: any[]) => call[0] === event);
+        expect(calls.length).toBe(1);
+      });
+    });
+
+    it("should forward events to registered handlers", async () => {
+      const handler1 = vi.fn();
+      const handler2 = vi.fn();
+
+      await realtime.on("test_event", handler1);
+      await realtime.on("test_event", handler2);
+
+      // Get the socket listener that was registered
+      const socketListener = mockSocket.on.mock.calls.find(
+        (call: any[]) => call[0] === "test_event",
+      )?.[1];
+
+      // Simulate receiving an event
+      const payload = { data: "test" };
+      socketListener(payload);
+
+      // Both handlers should receive the event
+      expect(handler1).toHaveBeenCalledWith(payload);
+      expect(handler2).toHaveBeenCalledWith(payload);
+    });
+
+    it("should connect automatically when adding first handler", async () => {
+      const handler = vi.fn();
+      await realtime.on("test_event", handler);
+
+      expect(mockSocket.on).toHaveBeenCalledWith("connect", expect.any(Function));
+    });
+  });
+
+  describe("off", () => {
+    it("should remove event handler", async () => {
+      const handler1 = vi.fn();
+      const handler2 = vi.fn();
+
+      await realtime.on("test_event", handler1);
+      await realtime.on("test_event", handler2);
+
+      realtime.off("test_event", handler1);
+
+      // Get the socket listener
+      const socketListener = mockSocket.on.mock.calls.find(
+        (call: any[]) => call[0] === "test_event",
+      )?.[1];
+
+      // Simulate event
+      const payload = { data: "test" };
+      socketListener(payload);
+
+      // Only handler2 should be called
+      expect(handler1).not.toHaveBeenCalled();
+      expect(handler2).toHaveBeenCalledWith(payload);
+    });
+
+    it("should remove socket listener when last handler is removed", async () => {
+      const handler = vi.fn();
+
+      await realtime.on("test_event", handler);
+      realtime.off("test_event", handler);
+
+      // Socket listener should be removed (off is called with event name and handler)
+      expect(mockSocket.off).toHaveBeenCalledWith("test_event", expect.any(Function));
+    });
+
+    it("should not remove socket listener if other handlers remain", async () => {
+      const handler1 = vi.fn();
+      const handler2 = vi.fn();
+
+      await realtime.on("test_event", handler1);
+      await realtime.on("test_event", handler2);
+
+      realtime.off("test_event", handler1);
+
+      // Socket listener should NOT be removed
+      expect(mockSocket.off).not.toHaveBeenCalledWith("test_event");
+    });
+
+    it("should handle removing non-existent handler gracefully", () => {
+      const handler = vi.fn();
+      expect(() => realtime.off("test_event", handler)).not.toThrow();
+    });
+  });
+
+  describe("subscribeDoc / unsubscribeDoc", () => {
+    it("should emit doc_subscribe event", async () => {
+      mockSocket.connected = true;
+      (realtime as any).socketHealthy = true;
+
+      await realtime.subscribeDoc("Task", "TASK-001");
+      expect(mockSocket.emit).toHaveBeenCalledWith("doc_subscribe", {
+        doctype: "Task",
+        name: "TASK-001",
+      });
+    });
+
+    it("should emit doc_unsubscribe event", async () => {
+      mockSocket.connected = true;
+      (realtime as any).socketHealthy = true;
+      (realtime as any).socket = mockSocket;
+
+      realtime.unsubscribeDoc("Task", "TASK-001");
+      expect(mockSocket.emit).toHaveBeenCalledWith("doc_unsubscribe", {
+        doctype: "Task",
+        name: "TASK-001",
+      });
+    });
+
+    it("should connect before subscribing if not connected", async () => {
+      await realtime.subscribeDoc("Task", "TASK-001");
+      expect(mockSocket.on).toHaveBeenCalledWith("connect", expect.any(Function));
+    });
+  });
+
+  describe("subscribeList / unsubscribeList", () => {
+    it("should emit list_subscribe event", async () => {
+      mockSocket.connected = true;
+      (realtime as any).socketHealthy = true;
+
+      await realtime.subscribeList("Task", { status: "Open" });
+      expect(mockSocket.emit).toHaveBeenCalledWith("list_subscribe", {
+        doctype: "Task",
+        filters: { status: "Open" },
+      });
+    });
+
+    it("should emit list_unsubscribe event", async () => {
+      mockSocket.connected = true;
+      (realtime as any).socketHealthy = true;
+      (realtime as any).socket = mockSocket;
+
+      realtime.unsubscribeList("Task");
+      expect(mockSocket.emit).toHaveBeenCalledWith("list_unsubscribe", {
+        doctype: "Task",
+      });
+    });
+  });
+
+  describe("isHealthy", () => {
+    it("should return true when socket is connected and healthy", async () => {
+      await (realtime as any).connect();
+
+      // Simulate successful connection
+      const connectHandler = mockSocket.on.mock.calls.find(
+        (call: any[]) => call[0] === "connect",
+      )?.[1];
+      connectHandler();
+
+      expect(realtime.isHealthy()).toBe(true);
+    });
+
+    it("should return false when disconnected", () => {
+      expect(realtime.isHealthy()).toBe(false);
+    });
+
+    it("should return false after disconnect event", async () => {
+      await (realtime as any).connect();
+
+      // First connect
+      const connectHandler = mockSocket.on.mock.calls.find(
+        (call: any[]) => call[0] === "connect",
+      )?.[1];
+      connectHandler();
+
+      expect(realtime.isHealthy()).toBe(true);
+
+      // Then disconnect
+      const disconnectHandler = mockSocket.on.mock.calls.find(
+        (call: any[]) => call[0] === "disconnect",
+      )?.[1];
+      disconnectHandler("transport close");
+
+      expect(realtime.isHealthy()).toBe(false);
+    });
+  });
+
+  describe("disconnect", () => {
+    it("should disconnect socket", async () => {
+      await (realtime as any).connect();
+      realtime.disconnect();
+
+      expect(mockSocket.disconnect).toHaveBeenCalled();
+    });
+
+    it("should clear all handlers", async () => {
+      const handler1 = vi.fn();
+      const handler2 = vi.fn();
+
+      await realtime.on("event1", handler1);
+      await realtime.on("event2", handler2);
+
+      realtime.disconnect();
+
+      // Should disconnect the socket
+      expect(mockSocket.disconnect).toHaveBeenCalled();
+
+      // After disconnect, handlers should be cleared
+      // Try to trigger an event - handlers should not be called
+      const socketListener1 = mockSocket.on.mock.calls.find(
+        (call: any[]) => call[0] === "event1",
+      )?.[1];
+
+      if (socketListener1) {
+        socketListener1({ data: "test" });
+        expect(handler1).not.toHaveBeenCalled();
+      }
+    });
+
+    it("should handle multiple disconnects gracefully", () => {
+      expect(() => {
+        realtime.disconnect();
+        realtime.disconnect();
+      }).not.toThrow();
+    });
+  });
+
+  describe("emit", () => {
+    it("should emit events through socket", async () => {
+      mockSocket.connected = true;
+      (realtime as any).socketHealthy = true;
+      (realtime as any).socket = mockSocket;
+
+      const payload = { test: "data" };
+      realtime.emit("custom_event", payload);
+
+      expect(mockSocket.emit).toHaveBeenCalledWith("custom_event", payload);
+    });
+
+    it("should not emit when not connected", () => {
+      const payload = { test: "data" };
+      realtime.emit("custom_event", payload);
+
+      expect(mockSocket.emit).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("reconnection handling", () => {
+    it("should re-register existing handlers when connection is re-established", async () => {
+      const handler = vi.fn();
+
+      // First establish connection to avoid double registration
+      await (realtime as any).connect();
+
+      // Add handler after connection
+      await realtime.on("test_event", handler);
+
+      // Track initial socket listener registration
+      const initialCalls = mockSocket.on.mock.calls.filter(
+        (call: any[]) => call[0] === "test_event",
+      );
+      expect(initialCalls.length).toBe(1);
+
+      // Clear mock and simulate socket reconnection without calling disconnect()
+      // (which would clear handlers)
+      mockSocket.on.mockClear();
+      (realtime as any).socket = undefined;
+      (realtime as any).socketHealthy = false;
+      (realtime as any).isConnecting = false; // Reset isConnecting flag
+
+      // Re-establish connection - should re-register events from handlerMap
+      await (realtime as any).connect();
+
+      // Should re-register events that are still in handlerMap
+      const reconnectCalls = mockSocket.on.mock.calls.filter(
+        (call: any[]) => call[0] === "test_event",
+      );
+      expect(reconnectCalls.length).toBe(1);
+    });
+
+    it("should not maintain handlers after explicit disconnect", async () => {
+      const handler1 = vi.fn();
+      const handler2 = vi.fn();
+
+      await realtime.on("event1", handler1);
+      await realtime.on("event2", handler2);
+
+      // Disconnect clears handlerMap
+      realtime.disconnect();
+
+      // Clear mocks and reconnect
+      mockSocket.on.mockClear();
+      await (realtime as any).connect();
+
+      // Events should NOT be re-registered since handlerMap was cleared
+      const event1Calls = mockSocket.on.mock.calls.filter((call: any[]) => call[0] === "event1");
+      const event2Calls = mockSocket.on.mock.calls.filter((call: any[]) => call[0] === "event2");
+
+      expect(event1Calls.length).toBe(0);
+      expect(event2Calls.length).toBe(0);
+    });
+  });
+});