@rynt/sdk 0.9.53

package/src/shared/definitions/defineGraphCache.ts

@@ -0,0 +1,216 @@
+import { computed, reactive, shallowReactive, type ComputedRef } from 'vue';
+
+export type BaseEntity = {
+  id: string;
+};
+
+/**
+ * Внутреннее состояние кеша:
+ * сущность может быть частично догружена из GraphQL
+ */
+type InternalEntity<T extends BaseEntity> = Partial<T> & BaseEntity;
+
+export type RelationDefinition =
+  | string
+  | { type: string; many?: boolean }
+  | ((value: unknown, seen?: Set<string>) => unknown);
+
+export type GraphCacheOptions<T extends BaseEntity> = {
+  relations?: Partial<Record<keyof T, RelationDefinition>>;
+};
+
+export type GraphCache<T extends BaseEntity> = {
+  /**
+   * Все сущности как реактивный массив
+   */
+  entities: ComputedRef<T[]>;
+
+  /**
+   * Получить или создать реактивную сущность
+   */
+  get: (id: string) => T;
+
+  has: (id: string) => boolean;
+
+  /**
+   * Главный метод:
+   * принимает nested GraphQL json и раскладывает по кешам
+   */
+  merge: (
+    input: (Partial<T> & BaseEntity) | Array<Partial<T> & BaseEntity>,
+    seen?: Set<string>,
+  ) => T | T[];
+
+  /**
+   * Локальный partial update
+   */
+  patch: (id: string, patchData: Partial<Omit<T, 'id'>>) => T;
+
+  remove: (id: string) => void;
+  clear: () => void;
+  cleanup: (maxAgeMs: number) => void;
+
+  /**
+   * Plain snapshot для сериализации/debug
+   */
+  snapshot: () => T[];
+};
+
+function getGlobalCaches(): Map<string, GraphCache<any>> {
+  const store = (globalThis as any).__rynt_graph_caches;
+  if (store) return store;
+  const map = new Map<string, GraphCache<any>>();
+  (globalThis as any).__rynt_graph_caches = map;
+  return map;
+}
+
+export function getGraphCache<T extends BaseEntity>(
+  name: string,
+): GraphCache<T> {
+  const cache = getGlobalCaches().get(name);
+
+  if (!cache) {
+    throw new Error(`Graph cache "${name}" is not registered`);
+  }
+
+  return cache as GraphCache<T>;
+}
+
+export function defineGraphCache<T extends BaseEntity>(
+  name: string,
+  options: GraphCacheOptions<T> = {},
+): GraphCache<T> {
+  const entitiesRaw = shallowReactive(new Map<string, InternalEntity<T>>());
+
+  const lastAccess = shallowReactive(new Map<string, number>());
+
+  const touch = (id: string) => {
+    lastAccess.set(id, Date.now());
+  };
+
+  const get = (id: string): T => {
+    let entity = entitiesRaw.get(id);
+
+    if (!entity) {
+      entity = reactive({
+        id,
+      } as InternalEntity<T>) as unknown as InternalEntity<T>;
+
+      entitiesRaw.set(id, entity);
+    }
+
+    touch(id);
+
+    return entity as T;
+  };
+
+  const resolveRelation = (
+    relation: RelationDefinition,
+    value: unknown,
+    seen: Set<string>,
+  ) => {
+    if (typeof relation === 'function') {
+      return relation(value, seen);
+    }
+
+    const type = typeof relation === 'string' ? relation : relation.type;
+    const many =
+      typeof relation === 'object' &&
+      'many' in relation &&
+      relation.many === true;
+
+    const relatedCache = getGraphCache(type);
+
+    if (many) {
+      return Array.isArray(value)
+        ? value.map((item) => relatedCache.merge(item as any, seen))
+        : [];
+    }
+
+    return value ? relatedCache.merge(value as any, seen) : value;
+  };
+
+  const mergeOne = (
+    entity: Partial<T> & BaseEntity,
+    seen = new Set<string>(),
+  ): T => {
+    const seenKey = `${name}:${entity.id}`;
+
+    if (seen.has(seenKey)) {
+      return get(entity.id);
+    }
+
+    seen.add(seenKey);
+
+    const target = get(entity.id) as Record<string, unknown>;
+
+    for (const key of Object.keys(entity) as Array<keyof T>) {
+      const value = entity[key];
+      if (value === undefined) continue;
+
+      const relation = options.relations?.[key];
+
+      target[key as string] = relation
+        ? resolveRelation(relation, value, seen)
+        : value;
+    }
+
+    return target as T;
+  };
+
+  const merge = (
+    input: (Partial<T> & BaseEntity) | Array<Partial<T> & BaseEntity>,
+    seen = new Set<string>(),
+  ): T | T[] => {
+    return Array.isArray(input)
+      ? input.map((item) => mergeOne(item, seen))
+      : mergeOne(input, seen);
+  };
+
+  const patch = (id: string, patchData: Partial<Omit<T, 'id'>>): T => {
+    const entity = get(id);
+    Object.assign(entity, patchData);
+    return entity;
+  };
+
+  const remove = (id: string) => {
+    entitiesRaw.delete(id);
+    lastAccess.delete(id);
+  };
+
+  const clear = () => {
+    entitiesRaw.clear();
+    lastAccess.clear();
+  };
+
+  const cleanup = (maxAgeMs: number) => {
+    const now = Date.now();
+
+    for (const [id, ts] of lastAccess.entries()) {
+      if (now - ts > maxAgeMs) {
+        remove(id);
+      }
+    }
+  };
+
+  const entities = computed<T[]>(() => Array.from(entitiesRaw.values()) as T[]);
+
+  const snapshot = (): T[] =>
+    entities.value.map((entity) => structuredClone(entity));
+
+  const cache: GraphCache<T> = {
+    entities,
+    get,
+    has: (id) => entitiesRaw.has(id),
+    merge,
+    patch,
+    remove,
+    clear,
+    cleanup,
+    snapshot,
+  };
+
+  getGlobalCaches().set(name, cache);
+
+  return cache;
+}

package/src/shared/definitions/defineStore.ts

@@ -0,0 +1,32 @@
+type StoreFunction<T, Args extends any[]> = (...args: Args) => T;
+
+function getStoreRegistry(): WeakMap<StoreFunction<any, any[]>, any> {
+  const store = (globalThis as any).__rynt_store_registry;
+  if (store) return store;
+  const map = new WeakMap<StoreFunction<any, any[]>, any>();
+  (globalThis as any).__rynt_store_registry = map;
+  return map;
+}
+
+export function defineStore<T, Args extends any[]>(
+  fn: StoreFunction<T, Args>,
+  singleton: boolean = true
+): StoreFunction<T, Args> {
+  if (singleton) {
+    getStoreRegistry().set(fn, fn);
+    return () => {
+      const storedValue = getStoreRegistry().get(fn);
+      if (typeof storedValue === 'function') {
+        const instance = storedValue();
+        getStoreRegistry().set(fn, instance);
+        return instance;
+      }
+      return storedValue;
+    };
+  }
+
+  // При singleton: false возвращаем функцию, которая принимает аргументы и передаёт их в fn
+  return ((...args: Args) => {
+    return fn(...args);
+  }) as StoreFunction<T, Args>;
+}

package/src/shared/definitions/index.ts

@@ -0,0 +1,2 @@
+export * from './defineStore';
+export * from './defineGraphCache';