@arcote.tech/arc 0.0.18 → 0.0.20

package/dist/collection/collection.d.ts

@@ -14,7 +14,7 @@ export type Deserialize<Id extends ArcIdAny, Schema extends ArcObjectAny> = obje
 } & ReturnType<Schema["deserialize"]>>;
 type CollectionQueryBuilder<T extends ArcCollection<any, any, any>> = {
     all: () => ArcAllItemsQueryBuilder<T>;
-    one: (id: util.GetType<T["id"]> | undefined) => ArcOneItemQueryBuilder<T>;
+    one: (id: util.GetType<T["id"]> | undefined | null) => ArcOneItemQueryBuilder<T>;
 };
 type CollectionCommandContext<Id extends ArcIdAny, Schema extends ArcObjectAny> = {
     one: (id: util.GetType<Id>) => Deserialize<Id, Schema>;

package/dist/elements/optional.d.ts

@@ -4,9 +4,9 @@ import type { ArcElement } from "./element";
 export declare class ArcOptional<E extends ArcElement> implements ArcElement {
     private parent;
     constructor(parent: E);
-    parse(value: util.FirstArgument<E["parse"]> | undefined): ReturnType<E["parse"]> | undefined;
-    serialize(value: util.FirstArgument<E["serialize"]> | undefined): ReturnType<E["serialize"]> | undefined;
-    deserialize(value: util.FirstArgument<E["deserialize"]> | undefined): ReturnType<E["deserialize"]> | undefined;
+    parse(value: util.FirstArgument<E["parse"]> | null | undefined): ReturnType<E["parse"]> | null;
+    serialize(value: util.FirstArgument<E["serialize"]> | null | undefined): ReturnType<E["serialize"]> | null;
+    deserialize(value: util.FirstArgument<E["deserialize"]> | null | undefined): ReturnType<E["deserialize"]> | null;
 }
 export type ArcOptionalAny = ArcOptional<ArcAbstract>;
 //# sourceMappingURL=optional.d.ts.map

package/dist/index.js

@@ -461,8 +461,10 @@ import { apply } from "mutative";
 function deepMerge(target, source) {
   const output = { ...target };
   for (const key in source) {
-    if (source[key] === undefined)
+    if (source[key] === undefined) {
+      output[key] = undefined;
       continue;
+    }
     if (isObject(source[key]) && isObject(target[key])) {
       output[key] = deepMerge(target[key], source[key]);
     } else {
@@ -691,6 +693,7 @@ class ForkedDataStorage extends DataStorage {
       store: store.storeName,
       changes: store.changes
     }));
+    console.log(changes);
     await this.master.commitChanges(changes);
   }
 }
@@ -733,6 +736,7 @@ class MasterStoreState extends StoreState {
     if (change.type === "modify") {
       const existing = await transaction.findById(this.storeName, change.id);
       const updated = existing ? deepMerge(existing, change.data) : { _id: change.id, ...change.data };
+      console.log("updated", updated);
       await transaction.set(this.storeName, updated);
       const item = this.deserialize ? this.deserialize(updated) : updated;
       this.items.set(change.id, item);
@@ -890,17 +894,17 @@ class ArcOptional {
   }
   parse(value) {
     if (!value)
-      return;
+      return null;
     return this.parent.parse(value);
   }
   serialize(value) {
     if (value)
       return this.parent.serialize(value);
-    return;
+    return null;
   }
   deserialize(value) {
     if (!value)
-      return;
+      return null;
     return this.parent.deserialize(value);
   }
 }
@@ -1210,9 +1214,7 @@ class RTCClient {
   reconnectAttempts = 0;
   maxReconnectAttempts = 5;
   syncProgressCallback;
-  syncResolve;
   syncPromise = null;
-  pendingStoreChanges = [];
   constructor(storage) {
     this.storage = storage;
   }
@@ -1220,13 +1222,54 @@ class RTCClient {
     if (this.syncPromise)
       return this.syncPromise;
     this.syncProgressCallback = progressCallback;
-    this.syncPromise = new Promise((resolve) => {
-      this.syncResolve = resolve;
-      this.connect();
-    });
+    this.syncPromise = this.performSync();
     return this.syncPromise;
   }
-  async connect() {
+  async performSync() {
+    this.connectWebSocket();
+    const arcState = await this.storage.getStore("state").findById("$arc", (a) => a);
+    const response = await fetch(`/ws/sync?lastSync=${arcState?.lastSyncDate || ""}`, {
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+    if (!response.ok) {
+      throw new Error("Sync failed");
+    }
+    const { results, syncDate } = await response.json();
+    const pendingStoreChanges = [];
+    for (const { store, items } of results) {
+      this.syncProgressCallback?.({ store, size: items.length });
+      const storeState = this.storage.getStore(store);
+      if (!storeState) {
+        console.error(`Store ${store} not found`);
+        continue;
+      }
+      const changes = items.map((item) => {
+        if (item.deleted) {
+          return {
+            type: "delete",
+            id: item._id
+          };
+        }
+        return {
+          type: "set",
+          data: item
+        };
+      });
+      pendingStoreChanges.push(storeState.applyChanges(changes));
+    }
+    await Promise.all(pendingStoreChanges);
+    const stateStorage = this.storage.getStore("state");
+    await stateStorage.applyChanges([
+      {
+        type: "set",
+        data: { _id: "$arc", lastSyncDate: syncDate }
+      }
+    ]);
+  }
+  async connectWebSocket() {
     this._socket = new WebSocket(`wss://${window.location.host}/ws`);
     this.openSocket = new Promise((resolve) => {
       this._socket.addEventListener("open", () => {
@@ -1234,7 +1277,6 @@ class RTCClient {
         resolve(this._socket);
       });
     });
-    const arcState = await this.storage.getStore("state").findById("$arc", (a) => a);
     this._socket.addEventListener("message", (e) => {
       this.onMessage(JSON.parse(e.data));
     });
@@ -1243,17 +1285,13 @@ class RTCClient {
       console.error("WebSocket closed", e);
       this.reconnect();
     });
-    this.sendMessage({
-      type: "sync",
-      lastDate: arcState?.lastSyncDate || null
-    });
   }
   reconnect() {
     if (this.reconnectAttempts < this.maxReconnectAttempts) {
       const timeout = Math.pow(2, this.reconnectAttempts) * 1000;
       setTimeout(() => {
         this.reconnectAttempts++;
-        this.connect();
+        this.connectWebSocket();
       }, timeout);
     } else {
       console.error("Max reconnect attempts reached. Giving up.");
@@ -1267,44 +1305,6 @@ class RTCClient {
   }
   onMessage(message) {
     switch (message.type) {
-      case "sync-result":
-        {
-          const { store, items } = message;
-          this.syncProgressCallback?.({ store, size: items.length });
-          const storeState = this.storage.getStore(store);
-          if (!storeState) {
-            console.error(`Store ${store} not found`);
-            return;
-          }
-          const changes = items.map((item) => {
-            if (item.deleted) {
-              return {
-                type: "delete",
-                id: item._id
-              };
-            }
-            return {
-              type: "set",
-              data: item
-            };
-          });
-          this.pendingStoreChanges.push(storeState.applyChanges(changes));
-        }
-        break;
-      case "sync-done":
-        Promise.all(this.pendingStoreChanges).then(() => {
-          const stateStorage = this.storage.getStore("state");
-          stateStorage.applyChanges([
-            {
-              type: "set",
-              data: { _id: "$arc", lastSyncDate: message.date }
-            }
-          ]).then(() => {
-            this.pendingStoreChanges = [];
-            this.syncResolve?.();
-          });
-        });
-        break;
       case "state-changes":
         this.storage.applyChanges(message.changes);
         break;

package/package.json

@@ -4,7 +4,7 @@
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",
-  "version": "0.0.18",
+  "version": "0.0.20",
   "private": false,
   "author": "Przemysław Krasiński [arcote.tech]",
   "description": "Arc is a framework designed to align code closely with business logic, streamlining development and enhancing productivity.",