@multiplatform.one/frappe 6.0.0

package/src/fixtures.ts

@@ -0,0 +1,268 @@
+import type { FrappeDocData } from "./common/types";
+
+export interface FixtureDoc extends FrappeDocData {
+  name: string;
+  doctype: string;
+  [key: string]: any;
+}
+
+export type FixtureData = {
+  [doctype: string]: FixtureDoc[];
+};
+
+export interface FixtureProvider {
+  getList<TDoc extends FrappeDocData>(
+    doctype: string,
+    options?: {
+      fields?: readonly string[];
+      filters?: Partial<TDoc> | Array<[string, string, any]>;
+      orderBy?: { field: string; order: string } | Array<{ field: string; order: string }>;
+      limitStart?: number;
+      limit?: number;
+    },
+  ): Promise<Partial<TDoc>[]>;
+
+  getDoc<TDoc extends FrappeDocData>(
+    doctype: string,
+    name: string,
+    fields?: readonly string[],
+  ): Promise<Partial<TDoc> | null>;
+
+  createDoc<TDoc extends FrappeDocData>(doctype: string, doc: Partial<TDoc>): Promise<TDoc>;
+
+  updateDoc<TDoc extends FrappeDocData>(
+    doctype: string,
+    name: string,
+    values: Partial<TDoc>,
+  ): Promise<TDoc>;
+
+  deleteDoc(doctype: string, name: string): Promise<void>;
+}
+
+export class InMemoryFixtureProvider implements FixtureProvider {
+  private data: Map<string, Map<string, FixtureDoc>>;
+
+  constructor(fixtureData: FixtureData = {}) {
+    this.data = new Map();
+    for (const [doctype, docs] of Object.entries(fixtureData)) {
+      const doctypeMap = new Map<string, FixtureDoc>();
+      for (const doc of docs) {
+        doctypeMap.set(doc.name, { ...doc, doctype });
+      }
+      this.data.set(doctype, doctypeMap);
+    }
+  }
+
+  async getList<TDoc extends FrappeDocData>(
+    doctype: string,
+    options?: {
+      fields?: readonly string[];
+      filters?: Partial<TDoc> | Array<[string, string, any]>;
+      orderBy?: { field: string; order: string } | Array<{ field: string; order: string }>;
+      limitStart?: number;
+      limit?: number;
+    },
+  ): Promise<Partial<TDoc>[]> {
+    const doctypeMap = this.data.get(doctype);
+    if (!doctypeMap) return [];
+
+    let docs = Array.from(doctypeMap.values()) as TDoc[];
+
+    if (options?.filters) {
+      docs = this.applyFilters(docs, options.filters);
+    }
+
+    if (options?.orderBy) {
+      docs = this.applyOrderBy(docs, options.orderBy);
+    }
+
+    const start = options?.limitStart ?? 0;
+    const end = options?.limit ? start + options.limit : undefined;
+    docs = docs.slice(start, end);
+
+    if (options?.fields && options.fields.length > 0) {
+      return docs.map((doc) => this.projectFields(doc, options.fields!));
+    }
+
+    return docs as Partial<TDoc>[];
+  }
+
+  async getDoc<TDoc extends FrappeDocData>(
+    doctype: string,
+    name: string,
+    fields?: readonly string[],
+  ): Promise<Partial<TDoc> | null> {
+    const doctypeMap = this.data.get(doctype);
+    if (!doctypeMap) return null;
+
+    const doc = doctypeMap.get(name);
+    if (!doc) return null;
+
+    if (fields) {
+      return this.projectFields(doc as TDoc, fields);
+    }
+
+    return doc as Partial<TDoc>;
+  }
+
+  async createDoc<TDoc extends FrappeDocData>(doctype: string, doc: Partial<TDoc>): Promise<TDoc> {
+    if (!this.data.has(doctype)) {
+      this.data.set(doctype, new Map());
+    }
+
+    const doctypeMap = this.data.get(doctype)!;
+    const name =
+      (doc.name as string) ||
+      `${doctype}-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+
+    const newDoc: FixtureDoc = {
+      ...doc,
+      name,
+      doctype,
+      modified: new Date().toISOString(),
+      creation: new Date().toISOString(),
+    } as FixtureDoc;
+
+    doctypeMap.set(name, newDoc);
+    return newDoc as TDoc;
+  }
+
+  async updateDoc<TDoc extends FrappeDocData>(
+    doctype: string,
+    name: string,
+    values: Partial<TDoc>,
+  ): Promise<TDoc> {
+    const doctypeMap = this.data.get(doctype);
+    if (!doctypeMap) {
+      throw new Error(`DocType ${doctype} not found`);
+    }
+
+    const doc = doctypeMap.get(name);
+    if (!doc) {
+      throw new Error(`Document ${doctype}/${name} not found`);
+    }
+
+    const updatedDoc: FixtureDoc = {
+      ...doc,
+      ...values,
+      name,
+      doctype,
+      modified: new Date().toISOString(),
+    };
+
+    doctypeMap.set(name, updatedDoc);
+    return updatedDoc as TDoc;
+  }
+
+  async deleteDoc(doctype: string, name: string): Promise<void> {
+    const doctypeMap = this.data.get(doctype);
+    if (!doctypeMap) {
+      throw new Error(`DocType ${doctype} not found`);
+    }
+
+    if (!doctypeMap.has(name)) {
+      throw new Error(`Document ${doctype}/${name} not found`);
+    }
+
+    doctypeMap.delete(name);
+  }
+
+  private applyFilters<TDoc extends FrappeDocData>(
+    docs: TDoc[],
+    filters: Partial<TDoc> | Array<[string, string, any]>,
+  ): TDoc[] {
+    if (Array.isArray(filters)) {
+      return docs.filter((doc) => {
+        return filters.every(([field, operator, value]) => {
+          const docValue = (doc as any)[field];
+          switch (operator) {
+            case "=":
+              return docValue === value;
+            case "!=":
+              return docValue !== value;
+            case ">":
+              return docValue > value;
+            case "<":
+              return docValue < value;
+            case ">=":
+              return docValue >= value;
+            case "<=":
+              return docValue <= value;
+            case "like":
+              return String(docValue)
+                .toLowerCase()
+                .includes(String(value).toLowerCase().replace(/%/g, ""));
+            case "in":
+              return Array.isArray(value) && value.includes(docValue);
+            case "not in":
+              return Array.isArray(value) && !value.includes(docValue);
+            default:
+              return docValue === value;
+          }
+        });
+      });
+    }
+
+    return docs.filter((doc) => {
+      return Object.entries(filters).every(([field, value]) => {
+        return (doc as any)[field] === value;
+      });
+    });
+  }
+
+  private applyOrderBy<TDoc extends FrappeDocData>(
+    docs: TDoc[],
+    orderBy: { field: string; order: string } | Array<{ field: string; order: string }>,
+  ): TDoc[] {
+    const orderByArray = Array.isArray(orderBy) ? orderBy : [orderBy];
+
+    return [...docs].sort((a, b) => {
+      for (const { field, order } of orderByArray) {
+        const aVal = (a as any)[field];
+        const bVal = (b as any)[field];
+
+        if (aVal === bVal) continue;
+
+        const comparison = aVal < bVal ? -1 : 1;
+        return order === "desc" ? -comparison : comparison;
+      }
+      return 0;
+    });
+  }
+
+  private projectFields<TDoc extends FrappeDocData>(
+    doc: TDoc,
+    fields: readonly string[],
+  ): Partial<TDoc> {
+    const projected: any = {};
+    for (const field of fields) {
+      if (field in doc) {
+        projected[field] = (doc as any)[field];
+      }
+    }
+
+    if (!fields.includes("name")) projected.name = doc.name;
+    if (!fields.includes("doctype")) projected.doctype = doc.doctype;
+
+    return projected;
+  }
+
+  reset(fixtureData: FixtureData = {}) {
+    this.data.clear();
+    for (const [doctype, docs] of Object.entries(fixtureData)) {
+      const doctypeMap = new Map<string, FixtureDoc>();
+      for (const doc of docs) {
+        doctypeMap.set(doc.name, { ...doc, doctype });
+      }
+      this.data.set(doctype, doctypeMap);
+    }
+  }
+
+  getData(): FixtureData {
+    const result: FixtureData = {};
+    for (const [doctype, doctypeMap] of this.data.entries()) {
+      result[doctype] = Array.from(doctypeMap.values());
+    }
+    return result;
+  }
+}

package/src/frappeApp.spec.ts

@@ -0,0 +1,382 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { AuthModule } from "./auth";
+import { CallModule } from "./call";
+import { HttpClient } from "./core/http";
+import { DbModule } from "./db";
+import { FileModule } from "./file";
+import { AuthType } from "./core/types";
+import { FrappeApp } from "./frappeApp";
+import { RealtimeModule } from "./realtime";
+import { SyncModule } from "./sync";
+
+// Mock all dependencies
+vi.mock("./core/http");
+vi.mock("./db");
+vi.mock("./auth");
+vi.mock("./call");
+vi.mock("./file");
+vi.mock("./realtime");
+vi.mock("./sync");
+
+describe("FrappeApp", () => {
+  let app: FrappeApp;
+  const baseURL = "https://api.example.com";
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+
+    // Mock constructors - must use function expressions, not arrow functions
+    vi.mocked(HttpClient).mockImplementation(function (this: any) {
+      this.getAuthConfig = vi.fn();
+      this.updateAuth = vi.fn();
+      return this;
+    } as any);
+
+    vi.mocked(DbModule).mockImplementation(function (this: any) {
+      return this;
+    } as any);
+    vi.mocked(AuthModule).mockImplementation(function (this: any) {
+      return this;
+    } as any);
+    vi.mocked(CallModule).mockImplementation(function (this: any) {
+      return this;
+    } as any);
+    vi.mocked(FileModule).mockImplementation(function (this: any) {
+      return this;
+    } as any);
+    vi.mocked(RealtimeModule).mockImplementation(function (this: any) {
+      this.disconnect = vi.fn();
+      this.updateAuth = vi.fn();
+      return this;
+    } as any);
+    vi.mocked(SyncModule).mockImplementation(function (this: any) {
+      this.dispose = vi.fn();
+      return this;
+    } as any);
+  });
+
+  describe("constructor", () => {
+    it("should initialize with base URL only", () => {
+      app = new FrappeApp(baseURL);
+
+      expect(HttpClient).toHaveBeenCalledWith(baseURL, {});
+      expect(DbModule).toHaveBeenCalledWith(
+        expect.any(Object),
+        expect.objectContaining({ appName: undefined, customEndpoints: {} }),
+      );
+      expect(AuthModule).toHaveBeenCalledWith(expect.any(Object));
+      expect(CallModule).toHaveBeenCalledWith(expect.any(Object));
+      expect(FileModule).toHaveBeenCalledWith(expect.any(Object));
+      expect(RealtimeModule).toHaveBeenCalledWith(expect.objectContaining({ baseURL }));
+      expect(SyncModule).toHaveBeenCalledWith(
+        expect.any(Object),
+        expect.any(Object),
+        expect.objectContaining({
+          pageSize: 20,
+          persistKey: "frappe-sync",
+        }),
+      );
+    });
+
+    it("should initialize with auth config", () => {
+      const auth = {
+        sessionId: "session-123",
+        credentials: "include" as RequestCredentials,
+      };
+
+      app = new FrappeApp(baseURL, auth);
+
+      expect(HttpClient).toHaveBeenCalledWith(baseURL, auth);
+      expect(RealtimeModule).toHaveBeenCalledWith(expect.objectContaining({ baseURL }));
+    });
+
+    it("should initialize with custom endpoints", () => {
+      const customEndpoints = {
+        createDoc: "/custom/create-doc",
+        backfill: "/custom/backfill",
+      };
+
+      app = new FrappeApp(baseURL, {}, customEndpoints);
+
+      expect(DbModule).toHaveBeenCalledWith(
+        expect.any(Object),
+        expect.objectContaining({ customEndpoints }),
+      );
+    });
+
+    it("should initialize with all parameters", () => {
+      const auth = {
+        sessionId: "session-123",
+        token: "bearer-token",
+      };
+      const customEndpoints = {
+        createDoc: "/custom/create-doc",
+      };
+
+      app = new FrappeApp(baseURL, auth, customEndpoints);
+
+      expect(HttpClient).toHaveBeenCalledWith(baseURL, auth);
+      expect(DbModule).toHaveBeenCalledWith(
+        expect.any(Object),
+        expect.objectContaining({ customEndpoints }),
+      );
+      expect(RealtimeModule).toHaveBeenCalledWith(expect.objectContaining({ baseURL }));
+    });
+
+    it("should pass sync options with default callbacks", () => {
+      const consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+      const consoleWarnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+
+      app = new FrappeApp(baseURL);
+
+      const syncOptions = vi.mocked(SyncModule).mock.calls[0][2];
+
+      // Test error callback
+      syncOptions?.onMutationError?.({ error: "test error" } as any);
+      expect(consoleErrorSpy).toHaveBeenCalledWith("Mutation error:", {
+        error: "test error",
+      });
+
+      // Test conflict callback
+      syncOptions?.onConflict?.({ conflict: "test conflict" } as any);
+      expect(consoleWarnSpy).toHaveBeenCalledWith("Conflict detected:", {
+        conflict: "test conflict",
+      });
+
+      consoleErrorSpy.mockRestore();
+      consoleWarnSpy.mockRestore();
+    });
+  });
+
+  describe("module accessors", () => {
+    beforeEach(() => {
+      app = new FrappeApp(baseURL);
+    });
+
+    it("should return db module", () => {
+      const db = app.db();
+      expect(db).toBeDefined();
+      expect(DbModule).toHaveBeenCalled();
+    });
+
+    it("should return auth module", () => {
+      const auth = app.auth();
+      expect(auth).toBeDefined();
+      expect(AuthModule).toHaveBeenCalled();
+    });
+
+    it("should return call module", () => {
+      const call = app.call();
+      expect(call).toBeDefined();
+      expect(CallModule).toHaveBeenCalled();
+    });
+
+    it("should return file module", () => {
+      const file = app.file();
+      expect(file).toBeDefined();
+      expect(FileModule).toHaveBeenCalled();
+    });
+
+    it("should return realtime module", () => {
+      const realtime = app.realtime();
+      expect(realtime).toBeDefined();
+      expect(RealtimeModule).toHaveBeenCalled();
+    });
+
+    it("should return sync module", () => {
+      const sync = app.sync();
+      expect(sync).toBeDefined();
+      expect(SyncModule).toHaveBeenCalled();
+    });
+
+    it("should always return the same module instances", () => {
+      const db1 = app.db();
+      const db2 = app.db();
+      expect(db1).toBe(db2);
+
+      const auth1 = app.auth();
+      const auth2 = app.auth();
+      expect(auth1).toBe(auth2);
+
+      const call1 = app.call();
+      const call2 = app.call();
+      expect(call1).toBe(call2);
+
+      const file1 = app.file();
+      const file2 = app.file();
+      expect(file1).toBe(file2);
+
+      const realtime1 = app.realtime();
+      const realtime2 = app.realtime();
+      expect(realtime1).toBe(realtime2);
+
+      const sync1 = app.sync();
+      const sync2 = app.sync();
+      expect(sync1).toBe(sync2);
+    });
+  });
+
+  describe("dispose", () => {
+    it("should disconnect realtime and dispose sync", async () => {
+      app = new FrappeApp(baseURL);
+
+      const realtimeModule = app.realtime();
+      const syncModule = app.sync();
+
+      await app.dispose();
+
+      expect(realtimeModule.disconnect).toHaveBeenCalled();
+      expect(syncModule.dispose).toHaveBeenCalled();
+    });
+
+    it("should handle dispose errors gracefully", async () => {
+      app = new FrappeApp(baseURL);
+
+      const syncModule = app.sync();
+      vi.mocked(syncModule.dispose).mockRejectedValue(new Error("Disposal failed"));
+
+      await expect(app.dispose()).rejects.toThrow("Disposal failed");
+    });
+  });
+
+  describe("getConfig", () => {
+    it("should return auth config from http client", () => {
+      app = new FrappeApp(baseURL);
+
+      const mockConfig = {
+        sessionId: "session-456",
+        token: "token-789",
+      };
+
+      const httpClient = (app as any).http;
+      vi.mocked(httpClient.getAuthConfig).mockReturnValue(mockConfig);
+
+      const config = app.getConfig();
+
+      expect(config).toEqual(mockConfig);
+      expect(httpClient.getAuthConfig).toHaveBeenCalled();
+    });
+
+    it("should return empty config when no auth set", () => {
+      app = new FrappeApp(baseURL);
+
+      const httpClient = (app as any).http;
+      vi.mocked(httpClient.getAuthConfig).mockReturnValue({});
+
+      const config = app.getConfig();
+
+      expect(config).toEqual({});
+    });
+  });
+
+  describe("updateAuth", () => {
+    it("should update auth in http client and realtime", async () => {
+      app = new FrappeApp(baseURL);
+
+      const newAuth = {
+        useToken: true,
+        token: "new-token",
+        type: AuthType.Bearer,
+      };
+
+      const httpClient = (app as any).http;
+      const realtimeModule = app.realtime();
+
+      await app.updateAuth(newAuth);
+
+      expect(httpClient.updateAuth).toHaveBeenCalledWith(newAuth);
+      expect(realtimeModule.updateAuth).toHaveBeenCalledWith({
+        useToken: true,
+        token: "new-token",
+        type: AuthType.Bearer,
+      });
+    });
+
+    it("should handle partial auth updates", async () => {
+      app = new FrappeApp(baseURL);
+
+      const partialAuth = {
+        token: "updated-token",
+      };
+
+      const httpClient = (app as any).http;
+      const realtimeModule = app.realtime();
+
+      await app.updateAuth(partialAuth);
+
+      expect(httpClient.updateAuth).toHaveBeenCalledWith(partialAuth);
+      // Without useToken, realtime gets empty auth
+      expect(realtimeModule.updateAuth).toHaveBeenCalledWith({});
+    });
+
+    it("should handle empty auth update", async () => {
+      app = new FrappeApp(baseURL);
+
+      const httpClient = (app as any).http;
+      const realtimeModule = app.realtime();
+
+      await app.updateAuth({});
+
+      expect(httpClient.updateAuth).toHaveBeenCalledWith({});
+      expect(realtimeModule.updateAuth).toHaveBeenCalledWith({});
+    });
+  });
+
+  describe("integration scenarios", () => {
+    it("should properly wire modules together", () => {
+      app = new FrappeApp(baseURL);
+
+      // Verify DbModule received HttpClient instance and FrappeLiveConfig
+      expect(DbModule).toHaveBeenCalledWith(
+        expect.objectContaining({
+          getAuthConfig: expect.any(Function),
+          updateAuth: expect.any(Function),
+        }),
+        expect.objectContaining({
+          appName: undefined,
+          customEndpoints: {},
+        }),
+      );
+
+      // Verify AuthModule received HttpClient instance
+      expect(AuthModule).toHaveBeenCalledWith(
+        expect.objectContaining({
+          getAuthConfig: expect.any(Function),
+          updateAuth: expect.any(Function),
+        }),
+      );
+
+      // Verify SyncModule received DbModule and RealtimeModule instances
+      expect(SyncModule).toHaveBeenCalledWith(
+        expect.any(Object), // DbModule instance
+        expect.objectContaining({
+          disconnect: expect.any(Function),
+          updateAuth: expect.any(Function),
+        }), // RealtimeModule instance
+        expect.any(Object), // options
+      );
+    });
+
+    it("should create independent instances", () => {
+      const app1 = new FrappeApp(baseURL);
+      const app2 = new FrappeApp("https://other.example.com");
+
+      expect(app1).not.toBe(app2);
+      expect(app1.db()).not.toBe(app2.db());
+      expect(app1.auth()).not.toBe(app2.auth());
+      expect(app1.sync()).not.toBe(app2.sync());
+    });
+
+    it("should handle different auth configurations for different instances", () => {
+      const _app1 = new FrappeApp(baseURL, { sessionId: "session1" });
+      const _app2 = new FrappeApp(baseURL, { token: "token2" });
+
+      expect(HttpClient).toHaveBeenNthCalledWith(1, baseURL, {
+        sessionId: "session1",
+      });
+      expect(HttpClient).toHaveBeenNthCalledWith(2, baseURL, {
+        token: "token2",
+      });
+    });
+  });
+});