@logixjs/query 0.0.1

package/dist/index.cjs

@@ -0,0 +1,582 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Engine: () => Engine,
+  TanStack: () => TanStack_exports,
+  make: () => make,
+  source: () => source,
+  traits: () => toStateTraitSpec
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/Query.ts
+var Logix4 = __toESM(require("@logixjs/core"), 1);
+var import_effect5 = require("effect");
+
+// src/internal/logics/auto-trigger.ts
+var Logix = __toESM(require("@logixjs/core"), 1);
+var import_effect3 = require("effect");
+
+// src/Engine.ts
+var import_effect2 = require("effect");
+
+// src/internal/middleware/middleware.ts
+var import_effect = require("effect");
+var middleware = (config) => /* @__PURE__ */ (() => {
+  let cachedEngine;
+  return (op) => {
+    if (op.kind !== "service" && op.kind !== "trait-source" || !op.meta?.resourceId || !op.meta.keyHash) {
+      return op.effect;
+    }
+    const resourceId = op.meta.resourceId;
+    if (config?.useFor && !config.useFor(resourceId)) {
+      return op.effect;
+    }
+    const keyHash = op.meta.keyHash;
+    if (cachedEngine) {
+      if (cachedEngine.fetchFast) {
+        return cachedEngine.fetchFast(resourceId, keyHash, op.effect);
+      }
+      return cachedEngine.fetch({ resourceId, keyHash, effect: op.effect });
+    }
+    return import_effect.Effect.serviceOption(Engine).pipe(
+      import_effect.Effect.flatMap((engineOpt) => {
+        if (import_effect.Option.isNone(engineOpt)) {
+          return import_effect.Effect.fail(
+            new Error(
+              `[Query.Engine.middleware] Missing Query.Engine in the Runtime scope; please provide Query.Engine.layer(Query.TanStack.engine(new QueryClient())) (recommended) or Query.Engine.layer(customEngine).`
+            )
+          );
+        }
+        cachedEngine = engineOpt.value;
+        if (cachedEngine.fetchFast) {
+          return cachedEngine.fetchFast(resourceId, keyHash, op.effect);
+        }
+        return cachedEngine.fetch({ resourceId, keyHash, effect: op.effect });
+      })
+    );
+  };
+})();
+
+// src/Engine.ts
+var EngineTagImpl = class extends import_effect2.Context.Tag("@logixjs/query/Engine")() {
+};
+var Engine = Object.assign(EngineTagImpl, {
+  layer: (engine2) => import_effect2.Layer.succeed(EngineTagImpl, engine2),
+  middleware: (config) => middleware(config)
+});
+
+// src/internal/logics/auto-trigger.ts
+var defaultTriggers = ["onMount", "onKeyChange"];
+var getTriggers = (triggers) => triggers ?? defaultTriggers;
+var isManualOnly = (triggers) => triggers.length === 1 && triggers[0] === "manual";
+var getSnapshotKeyHash = (snapshot) => {
+  if (!snapshot || typeof snapshot !== "object") return void 0;
+  const keyHash = snapshot.keyHash;
+  return typeof keyHash === "string" ? keyHash : void 0;
+};
+var getSnapshotStatus = (snapshot) => {
+  if (!snapshot || typeof snapshot !== "object") return void 0;
+  const status = snapshot.status;
+  return typeof status === "string" ? status : void 0;
+};
+var autoTrigger = (module2, config) => module2.logic(($) => {
+  const pending = /* @__PURE__ */ new Map();
+  const lastKeyHash = /* @__PURE__ */ new Map();
+  const hydrateFromFreshCache = (name, q, keyHash) => import_effect3.Effect.gen(function* () {
+    const engineOpt = yield* import_effect3.Effect.serviceOption(Engine);
+    if (engineOpt._tag === "None") return false;
+    const engine2 = engineOpt.value;
+    if (!engine2.peekFresh) return false;
+    const dataOpt = yield* engine2.peekFresh({
+      resourceId: q.resource.id,
+      keyHash
+    });
+    if (dataOpt._tag === "None") return false;
+    const snapshot = Logix.Resource.Snapshot.success({
+      keyHash,
+      data: dataOpt.value
+    });
+    yield* $.state.mutate((draft) => {
+      ;
+      draft.queries[name] = snapshot;
+    });
+    return true;
+  });
+  const cancelPending = (name) => import_effect3.Effect.gen(function* () {
+    const prev = pending.get(name);
+    if (!prev) return;
+    pending.delete(name);
+    yield* import_effect3.Fiber.interruptFork(prev);
+  });
+  const sourcePathOf = (name) => `queries.${name}`;
+  const refresh = (name, options) => $.traits.source.refresh(sourcePathOf(name), options);
+  const scheduleDebounced = (name, ms) => import_effect3.Effect.gen(function* () {
+    yield* cancelPending(name);
+    const fiber = yield* import_effect3.Effect.forkScoped(
+      import_effect3.Effect.sleep(import_effect3.Duration.millis(ms)).pipe(
+        import_effect3.Effect.zipRight(refresh(name)),
+        import_effect3.Effect.ensuring(import_effect3.Effect.sync(() => pending.delete(name))),
+        import_effect3.Effect.catchAllCause(() => import_effect3.Effect.void)
+      )
+    );
+    pending.set(name, fiber);
+  });
+  const computeKeyHash = (state, q) => {
+    const getAtPath = (root, path) => {
+      const parts = path.split(".");
+      let cur = root;
+      for (const p of parts) {
+        if (cur == null) return void 0;
+        cur = cur[p];
+      }
+      return cur;
+    };
+    try {
+      const keyState = { params: state.params, ui: state.ui };
+      const args = q.deps.map((dep) => getAtPath(keyState, dep));
+      const key = q.key(...args);
+      if (key === void 0) return void 0;
+      return Logix.Resource.keyHash(key);
+    } catch {
+      return void 0;
+    }
+  };
+  const maybeAutoRefresh = (phase, stateOverride) => import_effect3.Effect.gen(function* () {
+    const state = stateOverride ?? (yield* $.state.read);
+    for (const [name, q] of Object.entries(config.queries)) {
+      const queryName = name;
+      const triggers = getTriggers(q.triggers);
+      if (isManualOnly(triggers)) {
+        continue;
+      }
+      if (phase === "mount" && !triggers.includes("onMount")) {
+        continue;
+      }
+      if (phase === "keyChange" && !triggers.includes("onKeyChange")) {
+        continue;
+      }
+      const keyHash = computeKeyHash(state, q);
+      const snapshot = state?.queries?.[queryName];
+      const snapshotKeyHash = getSnapshotKeyHash(snapshot);
+      const snapshotStatus = getSnapshotStatus(snapshot);
+      if (keyHash === void 0) {
+        lastKeyHash.set(queryName, void 0);
+        continue;
+      }
+      const last = lastKeyHash.get(queryName);
+      if (snapshotStatus && snapshotStatus !== "idle" && snapshotKeyHash === keyHash && last === keyHash) {
+        continue;
+      }
+      if (snapshotStatus && snapshotStatus !== "idle" && snapshotKeyHash === keyHash) {
+        lastKeyHash.set(queryName, keyHash);
+        continue;
+      }
+      lastKeyHash.set(queryName, keyHash);
+      const hydrated = yield* hydrateFromFreshCache(queryName, q, keyHash);
+      if (hydrated) {
+        yield* cancelPending(queryName);
+        continue;
+      }
+      const debounceMs = q.debounceMs ?? 0;
+      if (phase === "keyChange" && debounceMs > 0) {
+        yield* scheduleDebounced(queryName, debounceMs);
+      } else {
+        yield* cancelPending(queryName);
+        yield* refresh(queryName);
+      }
+    }
+  });
+  const refreshAll = (options) => import_effect3.Effect.forEach(
+    Object.keys(config.queries),
+    (name) => cancelPending(name).pipe(import_effect3.Effect.zipRight(refresh(name, options)))
+  ).pipe(import_effect3.Effect.asVoid);
+  const setup = $.lifecycle.onStart(maybeAutoRefresh("mount"));
+  const run = import_effect3.Effect.suspend(
+    () => import_effect3.Effect.all(
+      [
+        // params/ui changes: handled by Query's default logic, avoiding scattered UI-side useEffect triggers.
+        $.onAction("setParams").runFork(
+          (action) => import_effect3.Effect.gen(function* () {
+            const state = yield* $.state.read;
+            const next = { ...state, params: action.payload };
+            yield* maybeAutoRefresh("keyChange", next);
+          })
+        ),
+        $.onAction("setUi").runFork(
+          (action) => import_effect3.Effect.gen(function* () {
+            const state = yield* $.state.read;
+            const next = { ...state, ui: action.payload };
+            yield* maybeAutoRefresh("keyChange", next);
+          })
+        ),
+        // Manual refresh: not restricted by triggers (manual-only still allows explicit refresh).
+        $.onAction("refresh").runFork(
+          (action) => import_effect3.Effect.gen(function* () {
+            const target = action.payload;
+            if (typeof target === "string" && target.length > 0) {
+              yield* cancelPending(target);
+              yield* refresh(target, { force: true });
+            } else {
+              yield* refreshAll({ force: true });
+            }
+          })
+        )
+      ],
+      { concurrency: "unbounded" }
+    ).pipe(import_effect3.Effect.asVoid)
+  );
+  return { setup, run };
+});
+
+// src/internal/logics/invalidate.ts
+var Logix2 = __toESM(require("@logixjs/core"), 1);
+var import_effect4 = require("effect");
+var toInvalidateTargets = (request, queries) => {
+  if (request.kind === "byResource") {
+    return Object.entries(queries).filter(([, q]) => q.resource.id === request.resourceId).map(([name, q]) => ({ name, resourceId: q.resource.id }));
+  }
+  if (request.kind === "byParams") {
+    return Object.entries(queries).filter(([, q]) => q.resource.id === request.resourceId).map(([name, q]) => ({ name, resourceId: q.resource.id }));
+  }
+  const entries = Object.entries(queries);
+  const tagged = entries.filter(([, q]) => Array.isArray(q.tags) && q.tags.includes(request.tag));
+  const selected = tagged.length > 0 ? tagged : entries;
+  return selected.map(([name, q]) => ({ name, resourceId: q.resource.id }));
+};
+var invalidate = (module2, config) => module2.logic(
+  ($) => import_effect4.Effect.gen(function* () {
+    yield* $.onAction("invalidate").runFork(
+      (action) => import_effect4.Effect.gen(function* () {
+        const request = action.payload;
+        yield* Logix2.TraitLifecycle.scopedExecute($, {
+          kind: "query:invalidate",
+          request
+        });
+        const engineOpt = yield* import_effect4.Effect.serviceOption(Engine);
+        if (engineOpt._tag !== "None") {
+          yield* engineOpt.value.invalidate(request);
+        }
+        const targets = toInvalidateTargets(request, config.queries);
+        const sourcePathOf = (name) => `queries.${name}`;
+        yield* import_effect4.Effect.forEach(
+          targets,
+          (t) => $.traits.source.refresh(sourcePathOf(t.name), { force: true })
+        ).pipe(import_effect4.Effect.asVoid);
+      })
+    );
+  })
+);
+
+// src/Traits.ts
+var Logix3 = __toESM(require("@logixjs/core"), 1);
+var source = (config) => config;
+var toStateTraitSpec = (input) => {
+  const out = {};
+  for (const [name, q] of Object.entries(input.queries)) {
+    const triggers = q.triggers ?? ["onMount", "onKeyChange"];
+    if (triggers.includes("manual") && triggers.length > 1) {
+      throw new Error(
+        `[Query.traits] "manual" must be exclusive, but got triggers=[${triggers.join(", ")}] for query "${name}".`
+      );
+    }
+    out[`queries.${name}`] = Logix3.StateTrait.source({
+      // deps: used for graph building/diagnostics/future reverse-closure; Query also reuses deps to converge triggers.
+      deps: q.deps,
+      resource: q.resource.id,
+      triggers,
+      debounceMs: q.debounceMs,
+      concurrency: q.concurrency === "exhaust" ? "exhaust-trailing" : q.concurrency,
+      key: (...depsValues) => q.key(...depsValues)
+    });
+  }
+  return out;
+};
+
+// src/Query.ts
+var InvalidateRequestSchema = import_effect5.Schema.Union(
+  import_effect5.Schema.Struct({
+    kind: import_effect5.Schema.Literal("byResource"),
+    resourceId: import_effect5.Schema.String
+  }),
+  import_effect5.Schema.Struct({
+    kind: import_effect5.Schema.Literal("byParams"),
+    resourceId: import_effect5.Schema.String,
+    keyHash: import_effect5.Schema.String
+  }),
+  import_effect5.Schema.Struct({
+    kind: import_effect5.Schema.Literal("byTag"),
+    tag: import_effect5.Schema.String
+  })
+);
+var assertQueryName = (name) => {
+  if (!name) {
+    throw new Error(`[Query.make] query name must be non-empty`);
+  }
+  if (name.includes(".")) {
+    throw new Error(`[Query.make] query name must not include "."; got "${name}"`);
+  }
+  if (name === "params" || name === "ui" || name === "queries") {
+    throw new Error(`[Query.make] query name "${name}" is reserved`);
+  }
+};
+var make = (id, config) => {
+  const queryBuilder = {
+    source: (q) => q
+  };
+  const queries = (() => {
+    const raw = config.queries;
+    if (!raw) return {};
+    return raw(queryBuilder);
+  })();
+  const queriesForTraits = queries;
+  for (const name of Object.keys(queries)) {
+    assertQueryName(name);
+  }
+  const RefreshTargetSchema = (() => {
+    const names = Object.keys(queries);
+    if (names.length === 0) return import_effect5.Schema.Never;
+    if (names.length === 1) {
+      return import_effect5.Schema.Literal(names[0]);
+    }
+    const asUnionMembers = (items) => {
+      if (items.length < 2) {
+        throw new Error(`[Query.make] internal error: expected at least 2 query names for union`);
+      }
+      return items;
+    };
+    const members = names.map((n) => import_effect5.Schema.Literal(n));
+    return import_effect5.Schema.Union(...asUnionMembers(members));
+  })();
+  const UiSchema = import_effect5.Schema.Unknown;
+  const QueriesSchema = import_effect5.Schema.Struct(
+    Object.fromEntries(Object.keys(queries).map((k) => [k, import_effect5.Schema.Unknown]))
+  );
+  const StateSchema = import_effect5.Schema.Struct({
+    params: config.params,
+    ui: UiSchema,
+    queries: QueriesSchema
+  });
+  const Actions = {
+    setParams: config.params,
+    setUi: UiSchema,
+    refresh: import_effect5.Schema.UndefinedOr(RefreshTargetSchema),
+    invalidate: InvalidateRequestSchema
+  };
+  const reducers = {
+    setParams: (state, action, sink) => {
+      sink?.("params");
+      return { ...state, params: action.payload ?? state.params };
+    },
+    setUi: (state, action, sink) => {
+      sink?.("ui");
+      return { ...state, ui: action.payload ?? state.ui };
+    },
+    refresh: (state) => state,
+    invalidate: (state) => state
+  };
+  const queryTraits = Object.keys(queriesForTraits).length > 0 ? toStateTraitSpec({ queries: queriesForTraits }) : void 0;
+  const traits = queryTraits || config.traits ? {
+    ...queryTraits,
+    ...config.traits
+  } : void 0;
+  const module2 = Logix4.Module.make(id, {
+    state: StateSchema,
+    actions: Actions,
+    reducers,
+    traits
+  });
+  const logics = [
+    autoTrigger(module2.tag, { queries: queriesForTraits }),
+    invalidate(module2.tag, { queries: queriesForTraits })
+  ];
+  const initial = (params) => ({
+    params: params ?? config.initialParams,
+    ui: config.ui ?? {},
+    queries: Object.fromEntries(
+      Object.keys(queries).map((k) => [k, Logix4.Resource.Snapshot.idle()])
+    )
+  });
+  const controller = {
+    make: (runtime) => {
+      const dispatch = runtime.dispatch;
+      const actions = module2.actions;
+      return {
+        runtime,
+        getState: runtime.getState,
+        dispatch,
+        controller: {
+          setParams: (params) => dispatch(actions.setParams(params)),
+          setUi: (ui) => dispatch(actions.setUi(ui)),
+          refresh: (target) => dispatch(actions.refresh(target)),
+          invalidate: (request) => dispatch(actions.invalidate(request))
+        }
+      };
+    }
+  };
+  module2.controller = controller;
+  const EXTEND_HANDLE = /* @__PURE__ */ Symbol.for("logix.module.handle.extend");
+  module2.tag[EXTEND_HANDLE] = (runtime, base) => {
+    const c = controller.make(runtime);
+    return {
+      ...base,
+      controller: c.controller
+    };
+  };
+  return module2.implement({
+    initial: initial(),
+    logics: [...logics]
+  });
+};
+
+// src/TanStack.ts
+var TanStack_exports = {};
+__export(TanStack_exports, {
+  engine: () => engine,
+  observe: () => observe
+});
+
+// src/internal/engine/tanstack.ts
+var import_effect6 = require("effect");
+var makeQueryKey = (resourceId, keyHash) => [resourceId, keyHash];
+var engine = (queryClient, config) => {
+  const byResourceId = /* @__PURE__ */ new Map();
+  const maxEntriesPerResource = config?.maxEntriesPerResource ?? 2e3;
+  try {
+    const queryCache = queryClient.getQueryCache?.();
+    if (queryCache && typeof queryCache.clear === "function") {
+      const original = queryCache.clear.bind(queryCache);
+      queryCache.clear = () => {
+        byResourceId.clear();
+        return original();
+      };
+    }
+  } catch {
+  }
+  const ensureBucket = (resourceId) => {
+    let bucket = byResourceId.get(resourceId);
+    if (!bucket) {
+      bucket = /* @__PURE__ */ new Map();
+      byResourceId.set(resourceId, bucket);
+    }
+    return bucket;
+  };
+  const evictIfNeeded = (bucket) => {
+    if (maxEntriesPerResource === Infinity) return;
+    if (!Number.isFinite(maxEntriesPerResource) || maxEntriesPerResource <= 0) return;
+    while (bucket.size > maxEntriesPerResource) {
+      const firstKey = bucket.keys().next().value;
+      if (firstKey === void 0) return;
+      bucket.delete(firstKey);
+    }
+  };
+  const fetchFast = (resourceId, keyHash, effect) => import_effect6.Effect.suspend(() => {
+    const hit = byResourceId.get(resourceId)?.get(keyHash);
+    if (hit !== void 0) {
+      return import_effect6.Effect.succeed(hit);
+    }
+    return import_effect6.Effect.map(effect, (out) => {
+      if (out !== void 0) {
+        const bucket = ensureBucket(resourceId);
+        bucket.set(keyHash, out);
+        evictIfNeeded(bucket);
+      }
+      return out;
+    });
+  });
+  return {
+    fetch: ({ resourceId, keyHash, effect }) => fetchFast(resourceId, keyHash, effect),
+    fetchFast,
+    invalidate: (request) => import_effect6.Effect.gen(function* () {
+      yield* import_effect6.Effect.sync(() => {
+        if (request.kind === "byParams") {
+          const bucket = byResourceId.get(request.resourceId);
+          if (!bucket) return;
+          bucket.delete(request.keyHash);
+          if (bucket.size === 0) {
+            byResourceId.delete(request.resourceId);
+          }
+          return;
+        }
+        if (request.kind === "byResource") {
+          byResourceId.delete(request.resourceId);
+          return;
+        }
+        byResourceId.clear();
+      });
+      yield* import_effect6.Effect.tryPromise({
+        try: () => {
+          if (request.kind === "byResource") {
+            return queryClient.invalidateQueries({
+              queryKey: [request.resourceId]
+            });
+          }
+          if (request.kind === "byParams") {
+            return queryClient.invalidateQueries({
+              queryKey: makeQueryKey(request.resourceId, request.keyHash)
+            });
+          }
+          return queryClient.invalidateQueries({
+            predicate: (q) => {
+              const tags = q.meta?.tags;
+              return Array.isArray(tags) && tags.includes(request.tag);
+            }
+          });
+        },
+        catch: (e) => e
+      }).pipe(import_effect6.Effect.asVoid);
+    }),
+    peekFresh: ({ resourceId, keyHash }) => import_effect6.Effect.sync(() => {
+      const hit = byResourceId.get(resourceId)?.get(keyHash);
+      return hit === void 0 ? import_effect6.Option.none() : import_effect6.Option.some(hit);
+    })
+  };
+};
+
+// src/internal/tanstack/observer.ts
+var import_effect7 = require("effect");
+var import_query_core = require("@tanstack/query-core");
+var observe = (params) => import_effect7.Effect.gen(function* () {
+  const observer = new import_query_core.QueryObserver(params.queryClient, params.options);
+  const unsubscribe = observer.subscribe(params.onResult);
+  yield* import_effect7.Effect.addFinalizer(() => import_effect7.Effect.sync(() => unsubscribe()));
+  return observer;
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Engine,
+  TanStack,
+  make,
+  source,
+  traits
+});
+//# sourceMappingURL=index.cjs.map