@multiplatform.one/frappe 6.0.0

package/dist/cjs/collection.cjs

@@ -0,0 +1,278 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var collection_exports = {};
+__export(collection_exports, {
+  createFixtureCollection: () => createFixtureCollection,
+  createFrappeCollection: () => createFrappeCollection,
+  fixtureCollectionOptions: () => fixtureCollectionOptions,
+  frappeCollectionOptions: () => frappeCollectionOptions
+});
+module.exports = __toCommonJS(collection_exports);
+var import_db = require("@tanstack/db");
+var import_types = require("./sync/types.cjs");
+function frappeCollectionOptions(doctype, config) {
+  const {
+    sync: syncModule,
+    fields,
+    filters,
+    orderBy,
+    limit
+  } = config;
+  const syncFn = params => {
+    const {
+      begin,
+      write,
+      commit,
+      markReady
+    } = params;
+    let subscriptionId;
+    let storeUnsubscribe;
+    let lastKnownNames = /* @__PURE__ */new Set();
+    async function initSync() {
+      try {
+        const query = {
+          doctype,
+          fields,
+          filters,
+          orderBy,
+          limit
+        };
+        const result = await syncModule.subscribe(query);
+        subscriptionId = result.subscriptionId;
+        const initialDocs = syncModule.getDocsForSubscription(subscriptionId);
+        if (initialDocs.length > 0) {
+          begin();
+          for (const doc of initialDocs) {
+            write({
+              type: "insert",
+              value: doc
+            });
+            lastKnownNames.add(doc.name);
+          }
+          commit();
+        }
+        storeUnsubscribe = syncModule.subscribeStore(() => {
+          if (!subscriptionId) return;
+          const currentDocs = syncModule.getDocsForSubscription(subscriptionId);
+          const currentNames = new Set(currentDocs.map(d => d.name));
+          begin();
+          for (const doc of currentDocs) {
+            if (lastKnownNames.has(doc.name)) {
+              write({
+                type: "update",
+                value: doc
+              });
+            } else {
+              write({
+                type: "insert",
+                value: doc
+              });
+            }
+          }
+          for (const name of lastKnownNames) {
+            if (!currentNames.has(name)) {
+              write({
+                type: "delete",
+                value: {
+                  name,
+                  doctype
+                }
+              });
+            }
+          }
+          commit();
+          lastKnownNames = currentNames;
+        });
+      } catch (error) {
+        console.error(`[frappe-collection] Initial sync failed for ${doctype}:`, error);
+      } finally {
+        markReady();
+      }
+    }
+    initSync();
+    return () => {
+      if (storeUnsubscribe) {
+        storeUnsubscribe();
+        storeUnsubscribe = void 0;
+      }
+      if (subscriptionId) {
+        syncModule.unsubscribe(subscriptionId);
+        subscriptionId = void 0;
+      }
+    };
+  };
+  return {
+    id: config.id ?? doctype,
+    getKey: doc => doc.name,
+    sync: {
+      sync: syncFn
+    },
+    onInsert: async ({
+      transaction
+    }) => {
+      for (const mutation of transaction.mutations) {
+        const doc = mutation.modified;
+        await syncModule.mutate({
+          mutationId: crypto.randomUUID?.() ?? Math.random().toString(36).substring(2),
+          operation: import_types.Operation.Create,
+          doc: {
+            ...doc,
+            doctype
+          }
+        });
+      }
+    },
+    onUpdate: async ({
+      transaction
+    }) => {
+      for (const mutation of transaction.mutations) {
+        const doc = mutation.changes ?? mutation.modified;
+        const name = mutation.key;
+        await syncModule.mutate({
+          mutationId: crypto.randomUUID?.() ?? Math.random().toString(36).substring(2),
+          operation: import_types.Operation.Update,
+          doc: {
+            ...doc,
+            doctype,
+            name
+          }
+        });
+      }
+    },
+    onDelete: async ({
+      transaction
+    }) => {
+      for (const mutation of transaction.mutations) {
+        const name = mutation.key;
+        await syncModule.mutate({
+          mutationId: crypto.randomUUID?.() ?? Math.random().toString(36).substring(2),
+          operation: import_types.Operation.Delete,
+          doc: {
+            doctype,
+            name
+          }
+        });
+      }
+    }
+  };
+}
+function createFrappeCollection(doctype, config) {
+  return (0, import_db.createCollection)(frappeCollectionOptions(doctype, config));
+}
+function fixtureCollectionOptions(doctype, config) {
+  const {
+    fixtures,
+    fields,
+    filters,
+    orderBy,
+    limit,
+    limitStart
+  } = config;
+  const syncFn = params => {
+    const {
+      begin,
+      write,
+      commit,
+      markReady
+    } = params;
+    async function initSync() {
+      try {
+        const orderByForFixture = orderBy && !Array.isArray(orderBy) ? {
+          field: orderBy.field,
+          order: String(orderBy.order)
+        } : Array.isArray(orderBy) ? orderBy.map(ob => ({
+          field: ob.field,
+          order: String(ob.order)
+        })) : void 0;
+        const docs = await fixtures.getList(doctype, {
+          fields,
+          filters,
+          orderBy: orderByForFixture,
+          limitStart,
+          limit
+        });
+        if (docs.length > 0) {
+          begin();
+          for (const doc of docs) {
+            const fullDoc = {
+              ...doc,
+              doctype
+            };
+            write({
+              type: "insert",
+              value: fullDoc
+            });
+          }
+          commit();
+        }
+      } catch (error) {
+        console.error(`[frappe-collection] Fixture sync failed for ${doctype}:`, error);
+      } finally {
+        markReady();
+      }
+    }
+    initSync();
+    return () => {};
+  };
+  return {
+    id: config.id ?? doctype,
+    getKey: doc => doc.name,
+    sync: {
+      sync: syncFn
+    },
+    onInsert: async ({
+      transaction
+    }) => {
+      for (const mutation of transaction.mutations) {
+        const doc = mutation.modified;
+        await fixtures.createDoc(doctype, {
+          ...doc,
+          doctype
+        });
+      }
+    },
+    onUpdate: async ({
+      transaction
+    }) => {
+      for (const mutation of transaction.mutations) {
+        const doc = mutation.changes ?? mutation.modified;
+        const name = mutation.key;
+        await fixtures.updateDoc(doctype, name, {
+          ...doc,
+          doctype
+        });
+      }
+    },
+    onDelete: async ({
+      transaction
+    }) => {
+      for (const mutation of transaction.mutations) {
+        const name = mutation.key;
+        await fixtures.deleteDoc(doctype, name);
+      }
+    }
+  };
+}
+function createFixtureCollection(doctype, config) {
+  return (0, import_db.createCollection)(fixtureCollectionOptions(doctype, config));
+}