@prometheus-ags/entity-graph-core 3.0.2 → 3.0.3

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @prometheus-ags/entity-graph-core
 
+## 3.0.3
+
+### Patch Changes
+
+- Ingest fetched entity lists, lifecycle metadata, and list projections in one
+  atomic graph publication. Core and React list paths no longer publish once per
+  returned row.
+
 ## 3.0.0
 
 ### Patch Changes

package/dist/index.cjs

@@ -428,6 +428,135 @@ function hasMergeStrategy(type) {
   return byType.has(type) || globalDefault !== null;
 }
 
+// src/view/evaluator.ts
+function matchesFilter(entity, filter) {
+  if (Array.isArray(filter)) return filter.every((clause) => matchesClause(entity, clause));
+  return matchesGroup(entity, filter);
+}
+function matchesGroup(entity, group) {
+  const { logic, clauses } = group;
+  if (logic === "and") return clauses.every((c) => "logic" in c ? matchesGroup(entity, c) : matchesClause(entity, c));
+  return clauses.some((c) => "logic" in c ? matchesGroup(entity, c) : matchesClause(entity, c));
+}
+function matchesClause(entity, clause) {
+  const { field, op, value, predicate } = clause;
+  const fv = getNestedValue(entity, field);
+  switch (op) {
+    case "eq":
+      return fv === value;
+    case "neq":
+      return fv !== value;
+    case "gt":
+      return fv > value;
+    case "gte":
+      return fv >= value;
+    case "lt":
+      return fv < value;
+    case "lte":
+      return fv <= value;
+    case "in":
+      return Array.isArray(value) && value.includes(fv);
+    case "nin":
+      return Array.isArray(value) && !value.includes(fv);
+    case "isNull":
+      return fv == null;
+    case "isNotNull":
+      return fv != null;
+    case "contains":
+      return typeof fv === "string" && typeof value === "string" && fv.toLowerCase().includes(value.toLowerCase());
+    case "startsWith":
+      return typeof fv === "string" && typeof value === "string" && fv.toLowerCase().startsWith(value.toLowerCase());
+    case "endsWith":
+      return typeof fv === "string" && typeof value === "string" && fv.toLowerCase().endsWith(value.toLowerCase());
+    case "between": {
+      const [lo, hi] = value;
+      return fv >= lo && fv <= hi;
+    }
+    case "arrayContains":
+      return Array.isArray(fv) && fv.includes(value);
+    case "arrayOverlaps":
+      return Array.isArray(fv) && Array.isArray(value) && value.some((v) => fv.includes(v));
+    case "matches":
+      return typeof fv === "string" && new RegExp(value).test(fv);
+    case "custom":
+      return predicate ? predicate(fv, entity) : true;
+    default:
+      return true;
+  }
+}
+function matchesSearch(entity, query, fields) {
+  if (!query.trim()) return true;
+  const lq = query.toLowerCase();
+  return fields.some((field) => {
+    const v = getNestedValue(entity, field);
+    return typeof v === "string" && v.toLowerCase().includes(lq);
+  });
+}
+function compareEntities(a, b, sort) {
+  for (const clause of sort) {
+    const r = compareByClause(a, b, clause);
+    if (r !== 0) return r;
+  }
+  return 0;
+}
+function compareByClause(a, b, clause) {
+  const { field, direction, nulls = "last", comparator } = clause;
+  const av = getNestedValue(a, field);
+  const bv = getNestedValue(b, field);
+  const aNull = av == null;
+  const bNull = bv == null;
+  if (aNull && bNull) return 0;
+  if (aNull) return nulls === "first" ? -1 : 1;
+  if (bNull) return nulls === "first" ? 1 : -1;
+  let cmp;
+  if (comparator) cmp = comparator(av, bv);
+  else if (typeof av === "string" && typeof bv === "string") cmp = av.localeCompare(bv, void 0, { sensitivity: "base", numeric: true });
+  else if (typeof av === "number" && typeof bv === "number") cmp = av - bv;
+  else cmp = String(av).localeCompare(String(bv));
+  return direction === "desc" ? -cmp : cmp;
+}
+function findInsertionIndex(entity, sortedIds, getEntity, sort) {
+  let lo = 0;
+  let hi = sortedIds.length;
+  while (lo < hi) {
+    const mid = lo + hi >>> 1;
+    const me = getEntity(sortedIds[mid]);
+    if (!me) {
+      lo = mid + 1;
+      continue;
+    }
+    if (compareEntities(entity, me, sort) <= 0) hi = mid;
+    else lo = mid + 1;
+  }
+  return lo;
+}
+function applyView(ids, getEntity, filter, sort, search) {
+  let entries = [];
+  for (const id of ids) {
+    const entity = getEntity(id);
+    if (!entity) continue;
+    entries.push({ id, entity });
+  }
+  if (filter && entries.length > 0) entries = entries.filter(({ entity }) => matchesFilter(entity, filter));
+  if (search?.query) entries = entries.filter(({ entity }) => matchesSearch(entity, search.query, search.fields));
+  if (sort && sort.length > 0) entries.sort((a, b) => compareEntities(a.entity, b.entity, sort));
+  return entries.map((e) => e.id);
+}
+function checkCompleteness(loadedCount, total, hasNextPage) {
+  if (!hasNextPage && total !== null && loadedCount >= total) return { isComplete: true, reason: "all-loaded" };
+  if (hasNextPage) return { isComplete: false, reason: "has-more-pages" };
+  return { isComplete: true, reason: "no-more-pages" };
+}
+function getNestedValue(obj, path) {
+  const parts = path.replace(/\[(\d+)\]/g, ".$1").split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current == null || typeof current !== "object") return void 0;
+    current = current[part];
+  }
+  return current;
+}
+
 // src/graph.ts
 var EMPTY_IDS = [];
 var EMPTY_ENTITY_STATE = {
@@ -512,6 +641,117 @@ function createGraphStore() {
             if (!s.syncMetadata[key]) s.syncMetadata[key] = defaultSyncMetadata();
           }
         }),
+        ingestFetchedList: (type, entries, options = {}) => set((s) => {
+          const fetchedAt = Date.now();
+          const ids = entries.map(({ id }) => id);
+          const batches = [
+            { type, entries },
+            ...options.sideBatches ?? []
+          ];
+          const origins = /* @__PURE__ */ new Map();
+          for (const batch of batches) {
+            if (!s.entities[batch.type]) s.entities[batch.type] = {};
+            for (const { id } of batch.entries) {
+              const key = ek(batch.type, id);
+              if (!origins.has(key)) {
+                origins.set(key, s.syncMetadata[key]?.origin ?? "server");
+              }
+            }
+          }
+          for (const batch of batches) {
+            const strategy = getMergeStrategy(batch.type);
+            for (const { id, data } of batch.entries) {
+              const key = ek(batch.type, id);
+              const ctx = {
+                type: batch.type,
+                id,
+                origin: origins.get(key) ?? "server",
+                updatedAt: fetchedAt
+              };
+              s.entities[batch.type][id] = strategy(s.entities[batch.type][id], data, ctx);
+            }
+          }
+          const completed = /* @__PURE__ */ new Set();
+          for (const batch of batches) {
+            for (const { id } of batch.entries) {
+              const key = ek(batch.type, id);
+              if (completed.has(key)) continue;
+              completed.add(key);
+              if (!s.entityStates[key]) s.entityStates[key] = defaultEntityState();
+              s.entityStates[key].lastFetched = fetchedAt;
+              s.entityStates[key].isFetching = false;
+              s.entityStates[key].error = null;
+              s.entityStates[key].stale = false;
+              s.syncMetadata[key] = {
+                ...s.syncMetadata[key] ?? defaultSyncMetadata(),
+                synced: true,
+                origin: "server",
+                updatedAt: fetchedAt
+              };
+            }
+          }
+          const readDraftEntity = (id) => {
+            const base = s.entities[type]?.[id];
+            if (!base) return null;
+            const patch = s.patches[type]?.[id];
+            const metadata = s.syncMetadata[ek(type, id)] ?? defaultSyncMetadata();
+            return {
+              ...base,
+              ...patch ?? {},
+              $synced: metadata.synced,
+              $origin: metadata.origin,
+              $updatedAt: metadata.updatedAt
+            };
+          };
+          for (const target of options.lists ?? []) {
+            const existing = s.lists[target.key] ?? defaultListState();
+            const targetIds = target.ids ?? ids;
+            const nextIds = target.mode === "append" ? Array.from(/* @__PURE__ */ new Set([...existing.ids, ...targetIds])) : targetIds;
+            s.lists[target.key] = {
+              ...existing,
+              ...target.meta ?? {},
+              ids: nextIds,
+              isFetching: false,
+              isFetchingMore: false,
+              error: null,
+              lastError: null,
+              stale: false,
+              lastFetched: fetchedAt
+            };
+          }
+          for (const projection of options.projections ?? []) {
+            const existing = s.lists[projection.key] ?? defaultListState();
+            const nextIds = [...existing.ids];
+            const { filter, sort, search } = projection.view;
+            for (const id of new Set(ids)) {
+              if (nextIds.includes(id)) continue;
+              const entity = readDraftEntity(id);
+              if (!entity) continue;
+              const matches = (!filter || matchesFilter(entity, filter)) && (!search?.query || matchesSearch(entity, search.query, search.fields));
+              if (!matches) continue;
+              if (sort && sort.length > 0) {
+                const index = findInsertionIndex(entity, nextIds, readDraftEntity, sort);
+                nextIds.splice(index, 0, id);
+              } else {
+                nextIds.unshift(id);
+              }
+            }
+            s.lists[projection.key] = projection.completeFetch ? {
+              ...existing,
+              ids: nextIds,
+              isFetching: false,
+              isFetchingMore: false,
+              error: null,
+              lastError: null,
+              stale: false,
+              lastFetched: fetchedAt
+            } : { ...existing, ids: nextIds };
+          }
+          for (const key of options.finishListFetches ?? []) {
+            if (!s.lists[key]) s.lists[key] = defaultListState();
+            s.lists[key].isFetching = false;
+          }
+        }),
         replaceEntity: (type, id, data) => set((s) => {
           if (!s.entities[type]) s.entities[type] = {};
           s.entities[type][id] = data;
@@ -1006,12 +1246,12 @@ async function fetchList(opts, params, engineOpts, isLoadMore = false, storeApi
     try {
       const response = await fetch(params);
       const normalized = response.items.map(normalize);
-      storeApi.getState().upsertEntities(type, normalized.map(({ id, data }) => ({ id, data })));
-      for (const { id } of normalized) storeApi.getState().setEntityFetched(type, id);
-      const ids = normalized.map(({ id }) => id);
       const meta = { total: response.total ?? null, nextCursor: response.nextCursor ?? null, prevCursor: response.prevCursor ?? null, hasNextPage: response.hasNextPage ?? !!response.nextCursor, hasPrevPage: response.hasPrevPage ?? !!response.prevCursor, currentPage: response.page ?? null, pageSize: response.pageSize ?? null };
-      if (mode === "append" && isLoadMore) storeApi.getState().appendListResult(key, ids, meta);
-      else storeApi.getState().setListResult(key, ids, meta);
+      storeApi.getState().ingestFetchedList(
+        type,
+        normalized.map(({ id, data }) => ({ id, data })),
+        { lists: [{ key, mode: mode === "append" && isLoadMore ? "append" : "replace", meta }] }
+      );
       if (sideEffects) sideEffects(response.items, storeApi);
       opts.onSuccess?.(response);
     } catch (err) {
@@ -1872,135 +2112,6 @@ function subscribeTimeTravel(cb) {
   return () => listeners.delete(cb);
 }
 
-// src/view/evaluator.ts
-function matchesFilter(entity, filter) {
-  if (Array.isArray(filter)) return filter.every((clause) => matchesClause(entity, clause));
-  return matchesGroup(entity, filter);
-}
-function matchesGroup(entity, group) {
-  const { logic, clauses } = group;
-  if (logic === "and") return clauses.every((c) => "logic" in c ? matchesGroup(entity, c) : matchesClause(entity, c));
-  return clauses.some((c) => "logic" in c ? matchesGroup(entity, c) : matchesClause(entity, c));
-}
-function matchesClause(entity, clause) {
-  const { field, op, value, predicate } = clause;
-  const fv = getNestedValue(entity, field);
-  switch (op) {
-    case "eq":
-      return fv === value;
-    case "neq":
-      return fv !== value;
-    case "gt":
-      return fv > value;
-    case "gte":
-      return fv >= value;
-    case "lt":
-      return fv < value;
-    case "lte":
-      return fv <= value;
-    case "in":
-      return Array.isArray(value) && value.includes(fv);
-    case "nin":
-      return Array.isArray(value) && !value.includes(fv);
-    case "isNull":
-      return fv == null;
-    case "isNotNull":
-      return fv != null;
-    case "contains":
-      return typeof fv === "string" && typeof value === "string" && fv.toLowerCase().includes(value.toLowerCase());
-    case "startsWith":
-      return typeof fv === "string" && typeof value === "string" && fv.toLowerCase().startsWith(value.toLowerCase());
-    case "endsWith":
-      return typeof fv === "string" && typeof value === "string" && fv.toLowerCase().endsWith(value.toLowerCase());
-    case "between": {
-      const [lo, hi] = value;
-      return fv >= lo && fv <= hi;
-    }
-    case "arrayContains":
-      return Array.isArray(fv) && fv.includes(value);
-    case "arrayOverlaps":
-      return Array.isArray(fv) && Array.isArray(value) && value.some((v) => fv.includes(v));
-    case "matches":
-      return typeof fv === "string" && new RegExp(value).test(fv);
-    case "custom":
-      return predicate ? predicate(fv, entity) : true;
-    default:
-      return true;
-  }
-}
-function matchesSearch(entity, query, fields) {
-  if (!query.trim()) return true;
-  const lq = query.toLowerCase();
-  return fields.some((field) => {
-    const v = getNestedValue(entity, field);
-    return typeof v === "string" && v.toLowerCase().includes(lq);
-  });
-}
-function compareEntities(a, b, sort) {
-  for (const clause of sort) {
-    const r = compareByClause(a, b, clause);
-    if (r !== 0) return r;
-  }
-  return 0;
-}
-function compareByClause(a, b, clause) {
-  const { field, direction, nulls = "last", comparator } = clause;
-  const av = getNestedValue(a, field);
-  const bv = getNestedValue(b, field);
-  const aNull = av == null;
-  const bNull = bv == null;
-  if (aNull && bNull) return 0;
-  if (aNull) return nulls === "first" ? -1 : 1;
-  if (bNull) return nulls === "first" ? 1 : -1;
-  let cmp;
-  if (comparator) cmp = comparator(av, bv);
-  else if (typeof av === "string" && typeof bv === "string") cmp = av.localeCompare(bv, void 0, { sensitivity: "base", numeric: true });
-  else if (typeof av === "number" && typeof bv === "number") cmp = av - bv;
-  else cmp = String(av).localeCompare(String(bv));
-  return direction === "desc" ? -cmp : cmp;
-}
-function findInsertionIndex(entity, sortedIds, getEntity, sort) {
-  let lo = 0;
-  let hi = sortedIds.length;
-  while (lo < hi) {
-    const mid = lo + hi >>> 1;
-    const me = getEntity(sortedIds[mid]);
-    if (!me) {
-      lo = mid + 1;
-      continue;
-    }
-    if (compareEntities(entity, me, sort) <= 0) hi = mid;
-    else lo = mid + 1;
-  }
-  return lo;
-}
-function applyView(ids, getEntity, filter, sort, search) {
-  let entries = [];
-  for (const id of ids) {
-    const entity = getEntity(id);
-    if (!entity) continue;
-    entries.push({ id, entity });
-  }
-  if (filter && entries.length > 0) entries = entries.filter(({ entity }) => matchesFilter(entity, filter));
-  if (search?.query) entries = entries.filter(({ entity }) => matchesSearch(entity, search.query, search.fields));
-  if (sort && sort.length > 0) entries.sort((a, b) => compareEntities(a.entity, b.entity, sort));
-  return entries.map((e) => e.id);
-}
-function checkCompleteness(loadedCount, total, hasNextPage) {
-  if (!hasNextPage && total !== null && loadedCount >= total) return { isComplete: true, reason: "all-loaded" };
-  if (hasNextPage) return { isComplete: false, reason: "has-more-pages" };
-  return { isComplete: true, reason: "no-more-pages" };
-}
-function getNestedValue(obj, path) {
-  const parts = path.replace(/\[(\d+)\]/g, ".$1").split(".");
-  let current = obj;
-  for (const part of parts) {
-    if (current == null || typeof current !== "object") return void 0;
-    current = current[part];
-  }
-  return current;
-}
-
 // src/view/incremental.ts
 var IncrementalView = class {
   opts;