rastack 0.0.16 → 0.0.20

package/sync/registry.ts

@@ -1,36 +1,36 @@
-import { EntityDescriptor, EntityKey, entityKey } from "./types";
-
-const entities = new Map<EntityKey, EntityDescriptor>();
-
-/**
- * Registers a sync-mode entity. Called from generated entity modules at
- * import time, so every entity a bundle uses is known before the engine
- * starts. Idempotent per (app, model).
- */
-export function defineEntity<TRow = any>(
-  descriptor: Omit<EntityDescriptor<TRow>, "__row">,
-): EntityDescriptor<TRow> {
-  const key = entityKey(descriptor as EntityDescriptor);
-  const existing = entities.get(key);
-  if (existing) {
-    return existing as EntityDescriptor<TRow>;
-  }
-  const entity: EntityDescriptor<TRow> = {
-    idField: "id",
-    ...descriptor,
-  };
-  entities.set(key, entity as EntityDescriptor);
-  return entity;
-}
-
-export function getRegisteredEntities(): EntityDescriptor[] {
-  return Array.from(entities.values());
-}
-
-export function getEntity(key: EntityKey): EntityDescriptor | undefined {
-  return entities.get(key);
-}
-
-export function clearEntityRegistry(): void {
-  entities.clear();
-}
+import { EntityDescriptor, EntityKey, entityKey } from "./types";
+
+const entities = new Map<EntityKey, EntityDescriptor>();
+
+/**
+ * Registers a sync-mode entity. Called from generated entity modules at
+ * import time, so every entity a bundle uses is known before the engine
+ * starts. Idempotent per (app, model).
+ */
+export function defineEntity<TRow = any>(
+  descriptor: Omit<EntityDescriptor<TRow>, "__row">,
+): EntityDescriptor<TRow> {
+  const key = entityKey(descriptor as EntityDescriptor);
+  const existing = entities.get(key);
+  if (existing) {
+    return existing as EntityDescriptor<TRow>;
+  }
+  const entity: EntityDescriptor<TRow> = {
+    idField: "id",
+    ...descriptor,
+  };
+  entities.set(key, entity as EntityDescriptor);
+  return entity;
+}
+
+export function getRegisteredEntities(): EntityDescriptor[] {
+  return Array.from(entities.values());
+}
+
+export function getEntity(key: EntityKey): EntityDescriptor | undefined {
+  return entities.get(key);
+}
+
+export function clearEntityRegistry(): void {
+  entities.clear();
+}

package/sync/store.ts

@@ -1,126 +1,126 @@
-import { EntityKey } from "./types";
-
-type Listener = () => void;
-
-interface EntityCache {
-  rows: Map<string, Record<string, any>>;
-  /** Stable array reference for useSyncExternalStore; rebuilt on change. */
-  listSnapshot: Record<string, any>[] | null;
-  ready: boolean;
-  listeners: Set<Listener>;
-}
-
-/**
- * The in-memory object pool. One cache per entity, keyed `${app}.${model}`.
- * The store is only the live working set: durable state lives in the
- * persistence layer and is only written from server deltas, so local disk
- * always remains a subset of server state (Linear's invariant).
- */
-export class SyncStore {
-  private caches = new Map<EntityKey, EntityCache>();
-
-  private cache(entity: EntityKey): EntityCache {
-    let cache = this.caches.get(entity);
-    if (!cache) {
-      cache = {
-        rows: new Map(),
-        listSnapshot: null,
-        ready: false,
-        listeners: new Set(),
-      };
-      this.caches.set(entity, cache);
-    }
-    return cache;
-  }
-
-  get(entity: EntityKey, id: string): Record<string, any> | undefined {
-    return this.cache(entity).rows.get(id);
-  }
-
-  getList(entity: EntityKey): Record<string, any>[] {
-    const cache = this.cache(entity);
-    if (!cache.listSnapshot) {
-      cache.listSnapshot = Array.from(cache.rows.values());
-    }
-    return cache.listSnapshot;
-  }
-
-  isReady(entity: EntityKey): boolean {
-    return this.cache(entity).ready;
-  }
-
-  markReady(entity: EntityKey): void {
-    const cache = this.cache(entity);
-    if (!cache.ready) {
-      cache.ready = true;
-      this.emit(cache);
-    }
-  }
-
-  upsert(entity: EntityKey, id: string, row: Record<string, any>): void {
-    const cache = this.cache(entity);
-    cache.rows.set(id, row);
-    this.emit(cache);
-  }
-
-  merge(
-    entity: EntityKey,
-    id: string,
-    changes: Record<string, any>,
-  ): Record<string, any> {
-    const cache = this.cache(entity);
-    const next = { ...(cache.rows.get(id) || {}), ...changes };
-    cache.rows.set(id, next);
-    this.emit(cache);
-    return next;
-  }
-
-  remove(entity: EntityKey, id: string): void {
-    const cache = this.cache(entity);
-    if (cache.rows.delete(id)) {
-      this.emit(cache);
-    }
-  }
-
-  replaceId(entity: EntityKey, fromId: string, toId: string): void {
-    const cache = this.cache(entity);
-    const row = cache.rows.get(fromId);
-    if (row !== undefined) {
-      cache.rows.delete(fromId);
-      cache.rows.set(toId, row);
-      this.emit(cache);
-    }
-  }
-
-  hydrate(entity: EntityKey, rows: Record<string, any>[], idField: string): void {
-    const cache = this.cache(entity);
-    rows.forEach((row) => {
-      const id = String(row[idField]);
-      cache.rows.set(id, row);
-    });
-    cache.ready = true;
-    this.emit(cache);
-  }
-
-  subscribe(entity: EntityKey, listener: Listener): () => void {
-    const cache = this.cache(entity);
-    cache.listeners.add(listener);
-    return () => {
-      cache.listeners.delete(listener);
-    };
-  }
-
-  clear(): void {
-    this.caches.forEach((cache) => {
-      cache.rows.clear();
-      cache.listSnapshot = null;
-      cache.ready = false;
-      cache.listeners.forEach((listener) => listener());
-    });
-  }
-
-  private emit(cache: EntityCache): void {
-    cache.listSnapshot = null;
-    cache.listeners.forEach((listener) => listener());
-  }
-}
+import { EntityKey } from "./types";
+
+type Listener = () => void;
+
+interface EntityCache {
+  rows: Map<string, Record<string, any>>;
+  /** Stable array reference for useSyncExternalStore; rebuilt on change. */
+  listSnapshot: Record<string, any>[] | null;
+  ready: boolean;
+  listeners: Set<Listener>;
+}
+
+/**
+ * The in-memory object pool. One cache per entity, keyed `${app}.${model}`.
+ * The store is only the live working set: durable state lives in the
+ * persistence layer and is only written from server deltas, so local disk
+ * always remains a subset of server state (Linear's invariant).
+ */
+export class SyncStore {
+  private caches = new Map<EntityKey, EntityCache>();
+
+  private cache(entity: EntityKey): EntityCache {
+    let cache = this.caches.get(entity);
+    if (!cache) {
+      cache = {
+        rows: new Map(),
+        listSnapshot: null,
+        ready: false,
+        listeners: new Set(),
+      };
+      this.caches.set(entity, cache);
+    }
+    return cache;
+  }
+
+  get(entity: EntityKey, id: string): Record<string, any> | undefined {
+    return this.cache(entity).rows.get(id);
+  }
+
+  getList(entity: EntityKey): Record<string, any>[] {
+    const cache = this.cache(entity);
+    if (!cache.listSnapshot) {
+      cache.listSnapshot = Array.from(cache.rows.values());
+    }
+    return cache.listSnapshot;
+  }
+
+  isReady(entity: EntityKey): boolean {
+    return this.cache(entity).ready;
+  }
+
+  markReady(entity: EntityKey): void {
+    const cache = this.cache(entity);
+    if (!cache.ready) {
+      cache.ready = true;
+      this.emit(cache);
+    }
+  }
+
+  upsert(entity: EntityKey, id: string, row: Record<string, any>): void {
+    const cache = this.cache(entity);
+    cache.rows.set(id, row);
+    this.emit(cache);
+  }
+
+  merge(
+    entity: EntityKey,
+    id: string,
+    changes: Record<string, any>,
+  ): Record<string, any> {
+    const cache = this.cache(entity);
+    const next = { ...(cache.rows.get(id) || {}), ...changes };
+    cache.rows.set(id, next);
+    this.emit(cache);
+    return next;
+  }
+
+  remove(entity: EntityKey, id: string): void {
+    const cache = this.cache(entity);
+    if (cache.rows.delete(id)) {
+      this.emit(cache);
+    }
+  }
+
+  replaceId(entity: EntityKey, fromId: string, toId: string): void {
+    const cache = this.cache(entity);
+    const row = cache.rows.get(fromId);
+    if (row !== undefined) {
+      cache.rows.delete(fromId);
+      cache.rows.set(toId, row);
+      this.emit(cache);
+    }
+  }
+
+  hydrate(entity: EntityKey, rows: Record<string, any>[], idField: string): void {
+    const cache = this.cache(entity);
+    rows.forEach((row) => {
+      const id = String(row[idField]);
+      cache.rows.set(id, row);
+    });
+    cache.ready = true;
+    this.emit(cache);
+  }
+
+  subscribe(entity: EntityKey, listener: Listener): () => void {
+    const cache = this.cache(entity);
+    cache.listeners.add(listener);
+    return () => {
+      cache.listeners.delete(listener);
+    };
+  }
+
+  clear(): void {
+    this.caches.forEach((cache) => {
+      cache.rows.clear();
+      cache.listSnapshot = null;
+      cache.ready = false;
+      cache.listeners.forEach((listener) => listener());
+    });
+  }
+
+  private emit(cache: EntityCache): void {
+    cache.listSnapshot = null;
+    cache.listeners.forEach((listener) => listener());
+  }
+}