@dee-wan/cache 1.0.1 → 2.0.0

package/dist/chunk-M4UOCIDQ.js

@@ -0,0 +1,557 @@
+import { PLANNER_VERSION, CONFIG_FORMAT, MAX_LOCK_MS, MAX_LEASE_MS, MAX_VALUE_BYTES, MAX_GENERATION_LENGTH, GLOBAL_FENCE, writeFence, modelFence, entityFence, TTL_JITTER_RATIO, MAX_SHAPE_TTL_SECONDS } from './chunk-OQRNVGQE.js';
+import { sha256Hex, stableStringify, decode, encode } from './chunk-ZCMZJKGN.js';
+
+// src/core/pk.ts
+function isPlainRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function encodePk(parts) {
+  return parts.map((part) => encodeURIComponent(String(part))).join(":");
+}
+function unwrapEquals(value) {
+  return isPlainRecord(value) && "equals" in value ? value.equals : value;
+}
+function isScalarPk(value) {
+  return typeof value === "string" || typeof value === "number" && Number.isFinite(value);
+}
+function pkFromWhere(where, pkFields, compoundName) {
+  if (!isPlainRecord(where)) return null;
+  const compound = where[compoundName ?? pkFields.join("_")];
+  const source = pkFields.length > 1 && isPlainRecord(compound) ? compound : where;
+  const parts = [];
+  for (const field of pkFields) {
+    const value = source === where ? unwrapEquals(where[field]) : source[field];
+    if (!isScalarPk(value)) return null;
+    parts.push(value);
+  }
+  return encodePk(parts);
+}
+function pkFromRow(row, pkFields) {
+  if (!isPlainRecord(row)) return null;
+  const parts = [];
+  for (const field of pkFields) {
+    const value = row[field];
+    if (!isScalarPk(value)) return null;
+    parts.push(value);
+  }
+  return encodePk(parts);
+}
+
+// src/core/plan.ts
+var MAX_NESTED_WRITE_DEPTH = 5;
+var MAX_ENTITY_FENCES_PER_MODEL = 100;
+var READ_OPERATIONS = /* @__PURE__ */ new Set(["aggregate", "count", "findFirst", "findFirstOrThrow", "findMany", "findUnique", "findUniqueOrThrow", "groupBy"]);
+var WRITE_OPERATIONS = /* @__PURE__ */ new Set([
+  "create",
+  "createMany",
+  "createManyAndReturn",
+  "delete",
+  "deleteMany",
+  "update",
+  "updateMany",
+  "updateManyAndReturn",
+  "upsert"
+]);
+var pkFieldsOf = (config, model) => config.primaryKeyFieldsByModel[model] ?? ["id"];
+function touch(plan, model) {
+  const existing = plan.touched.get(model);
+  if (existing) return existing;
+  const created = { pks: /* @__PURE__ */ new Set(), wide: false };
+  plan.touched.set(model, created);
+  return created;
+}
+var touchWrite = (ctx, model) => void touch(ctx.plan, model);
+var touchWide = (ctx, model) => void (touch(ctx.plan, model).wide = true);
+function touchEntity(ctx, model, where) {
+  const pk = pkFromWhere(where, pkFieldsOf(ctx.config, model), ctx.config.primaryKeyNameByModel[model]);
+  if (pk === null) touchWide(ctx, model);
+  else touch(ctx.plan, model).pks.add(pk);
+}
+function referencedFields(config, model) {
+  const fields = /* @__PURE__ */ new Set();
+  for (const relations of Object.values(config.relationGraph)) {
+    for (const relation of relations) {
+      if (relation.targetModel === model && relation.localFields.length > 0) {
+        for (const field of relation.foreignFields) fields.add(field);
+      }
+    }
+  }
+  return fields;
+}
+function touchReferencing(ctx, model, seen = /* @__PURE__ */ new Set()) {
+  if (seen.has(model)) return;
+  seen.add(model);
+  for (const [owner, relations] of Object.entries(ctx.config.relationGraph)) {
+    const references = relations.some((relation) => relation.targetModel === model && relation.localFields.length > 0);
+    if (!references) continue;
+    touchWide(ctx, owner);
+    touchReferencing(ctx, owner, seen);
+  }
+}
+function touchReferencingIfKeyChanges(ctx, model, data) {
+  if (!isPlainRecord(data)) return;
+  const referenced = referencedFields(ctx.config, model);
+  if (Object.keys(data).some((field) => referenced.has(field))) touchReferencing(ctx, model);
+}
+var asItems = (value) => Array.isArray(value) ? value : [value];
+var ONE_TO_ONE_REPARENTING_OPS = /* @__PURE__ */ new Set(["connect", "connectOrCreate", "create", "upsert"]);
+var FOREIGN_KEY_CHANGING_OPS = /* @__PURE__ */ new Set(["connect", "connectOrCreate", "create", "delete", "disconnect", "set", "upsert"]);
+var overlaps = (fields, referenced) => fields.some((field) => referenced.has(field));
+function widenIfForeignKeyReferenced(ctx, model, relation) {
+  if (overlaps(relation.localFields, referencedFields(ctx.config, model))) touchReferencing(ctx, model);
+  const opposite = (ctx.config.relationGraph[relation.targetModel] ?? []).find(
+    (candidate) => candidate !== relation && candidate.relationName !== void 0 && candidate.relationName === relation.relationName
+  );
+  if (opposite && overlaps(opposite.localFields, referencedFields(ctx.config, relation.targetModel))) {
+    touchReferencing(ctx, relation.targetModel);
+  }
+}
+function nestedWrites(ctx, model, data, depth) {
+  if (!isPlainRecord(data)) return;
+  for (const relation of ctx.config.relationGraph[model] ?? []) {
+    const ops = data[relation.fieldName];
+    if (!isPlainRecord(ops)) continue;
+    const target = relation.targetModel;
+    if (depth >= MAX_NESTED_WRITE_DEPTH) {
+      ctx.plan.all = true;
+      return;
+    }
+    touchWrite(ctx, target);
+    const recurse = (value) => nestedWrites(ctx, target, value, depth + 1);
+    for (const [op, value] of Object.entries(ops)) {
+      const items = asItems(value);
+      if (relation.oneToOne === true && ONE_TO_ONE_REPARENTING_OPS.has(op)) {
+        touchWide(ctx, target);
+        touchWide(ctx, model);
+      }
+      if (FOREIGN_KEY_CHANGING_OPS.has(op)) widenIfForeignKeyReferenced(ctx, model, relation);
+      switch (op) {
+        case "create":
+          items.forEach(recurse);
+          break;
+        case "createMany":
+          break;
+        case "connect":
+          items.forEach((item) => touchEntity(ctx, target, item));
+          break;
+        case "connectOrCreate":
+          for (const item of items) {
+            touchEntity(ctx, target, isPlainRecord(item) ? item.where : void 0);
+            if (isPlainRecord(item)) recurse(item.create);
+          }
+          break;
+        case "disconnect":
+          items.forEach((item) => isPlainRecord(item) ? touchEntity(ctx, target, item) : touchWide(ctx, target));
+          break;
+        case "delete":
+          items.forEach((item) => isPlainRecord(item) ? touchEntity(ctx, target, item) : touchWide(ctx, target));
+          touchReferencing(ctx, target);
+          break;
+        case "deleteMany":
+          touchWide(ctx, target);
+          touchReferencing(ctx, target);
+          break;
+        case "update":
+        case "upsert":
+          for (const item of items) {
+            const hasWhere = isPlainRecord(item) && "where" in item;
+            if (hasWhere) touchEntity(ctx, target, item.where);
+            else touchWide(ctx, target);
+            const payloads = isPlainRecord(item) ? [item.data, item.create, item.update, hasWhere ? void 0 : item] : [];
+            for (const payload of payloads) {
+              touchReferencingIfKeyChanges(ctx, target, payload);
+              recurse(payload);
+            }
+          }
+          break;
+        default:
+          touchWide(ctx, target);
+          for (const item of items) if (isPlainRecord(item)) touchReferencingIfKeyChanges(ctx, target, item.data);
+      }
+    }
+  }
+}
+function planWrite(config, model, operation, args) {
+  const ctx = { config, plan: { all: false, touched: /* @__PURE__ */ new Map() } };
+  const input = isPlainRecord(args) ? args : {};
+  touchWrite(ctx, model);
+  switch (operation) {
+    case "create":
+      nestedWrites(ctx, model, input.data, 0);
+      break;
+    case "createMany":
+    case "createManyAndReturn":
+      break;
+    case "update":
+      touchEntity(ctx, model, input.where);
+      touchReferencingIfKeyChanges(ctx, model, input.data);
+      nestedWrites(ctx, model, input.data, 0);
+      break;
+    case "upsert":
+      touchEntity(ctx, model, input.where);
+      touchReferencingIfKeyChanges(ctx, model, input.update);
+      nestedWrites(ctx, model, input.create, 0);
+      nestedWrites(ctx, model, input.update, 0);
+      break;
+    case "delete":
+      touchEntity(ctx, model, input.where);
+      touchReferencing(ctx, model);
+      break;
+    case "deleteMany":
+      touchWide(ctx, model);
+      touchReferencing(ctx, model);
+      break;
+    default:
+      touchWide(ctx, model);
+      touchReferencingIfKeyChanges(ctx, model, input.data);
+  }
+  return ctx.plan;
+}
+function planFences(plan) {
+  if (plan.all) return [GLOBAL_FENCE];
+  const fences = [];
+  for (const [model, { pks, wide }] of plan.touched) {
+    fences.push(writeFence(model));
+    if (wide || pks.size > MAX_ENTITY_FENCES_PER_MODEL) fences.push(modelFence(model));
+    else for (const pk of pks) fences.push(entityFence(model, pk));
+  }
+  return fences;
+}
+function rawWritePlanFences(config, target) {
+  if ("all" in target) return [GLOBAL_FENCE];
+  const ctx = { config, plan: { all: false, touched: /* @__PURE__ */ new Map() } };
+  const known = new Set(config.modelNames);
+  const models = "models" in target ? target.models : target.entities.map(({ model }) => model);
+  const unknown = models.filter((model) => !known.has(model));
+  if (unknown.length > 0) throw new TypeError(`cache invalidation: unknown models ${unknown.join(", ")}`);
+  if ("models" in target) target.models.forEach((model) => touchWide(ctx, model));
+  else {
+    for (const { model, pk } of target.entities) {
+      const fields = pkFieldsOf(config, model);
+      const encoded = pk.length === fields.length ? pkFromRow(Object.fromEntries(fields.map((field, i) => [field, pk[i]])), fields) : null;
+      if (encoded === null) touchWide(ctx, model);
+      else touch(ctx.plan, model).pks.add(encoded);
+    }
+  }
+  models.forEach((model) => touchReferencing(ctx, model));
+  return planFences(ctx.plan);
+}
+
+// src/core/shape.ts
+var DEFAULT_SHAPE = { freshTtlSeconds: 3600, negativeTtlSeconds: 600, softTtlRatio: 0.8 };
+function validate(label, shape) {
+  if (!shape) return;
+  for (const field of ["freshTtlSeconds", "negativeTtlSeconds"]) {
+    const value = shape[field];
+    if (value !== void 0 && !(Number.isFinite(value) && value > 0 && value <= MAX_SHAPE_TTL_SECONDS)) {
+      throw new TypeError(`cache shape ${label}: ${field} must be in (0, ${MAX_SHAPE_TTL_SECONDS}]`);
+    }
+  }
+  const ratio = shape.softTtlRatio;
+  if (ratio !== void 0 && !(Number.isFinite(ratio) && ratio > 0 && ratio <= 1)) {
+    throw new TypeError(`cache shape ${label}: softTtlRatio must be in (0, 1]`);
+  }
+}
+function validateShapes(shape) {
+  validate("default", shape?.default);
+  for (const [model, value] of Object.entries(shape?.byModel ?? {})) validate(`byModel.${model}`, value);
+}
+function resolveShape(shape, model) {
+  const pick = (field) => shape?.byModel?.[model]?.[field] ?? shape?.default?.[field] ?? DEFAULT_SHAPE[field];
+  return { freshTtlSeconds: pick("freshTtlSeconds"), negativeTtlSeconds: pick("negativeTtlSeconds"), softTtlRatio: pick("softTtlRatio") };
+}
+
+// src/core/targets.ts
+var MAX_RELATION_DEPTH = 10;
+var RELATION_FILTER_KEYS = ["some", "every", "none", "is", "isNot"];
+var LOGICAL_KEYS = /* @__PURE__ */ new Set(["AND", "OR", "NOT"]);
+function relationsOf(graph, model) {
+  return new Map((graph[model] ?? []).map((relation) => [relation.fieldName, relation]));
+}
+function reach(walk, relation) {
+  walk.out.models.add(relation.targetModel);
+  walk.out.relational = true;
+}
+function walkFilter(walk, model, value, depth) {
+  if (depth > MAX_RELATION_DEPTH) return false;
+  if (Array.isArray(value)) return value.every((item) => walkFilter(walk, model, item, depth + 1));
+  if (!isPlainRecord(value)) return true;
+  const relations = relationsOf(walk.graph, model);
+  for (const [key, nested] of Object.entries(value)) {
+    if (LOGICAL_KEYS.has(key)) {
+      if (!walkFilter(walk, model, nested, depth + 1)) return false;
+      continue;
+    }
+    const relation = relations.get(key);
+    if (!relation) continue;
+    reach(walk, relation);
+    if (!isPlainRecord(nested)) continue;
+    const wrapped = RELATION_FILTER_KEYS.filter((wrapper) => wrapper in nested);
+    const inner = wrapped.length > 0 ? wrapped.map((wrapper) => nested[wrapper]) : [nested];
+    if (!inner.every((item) => walkFilter(walk, relation.targetModel, item, depth + 1))) return false;
+  }
+  return true;
+}
+function walkCount(walk, model, count, depth) {
+  if (count === void 0) return true;
+  const select = isPlainRecord(count) && isPlainRecord(count.select) ? count.select : null;
+  for (const relation of walk.graph[model] ?? []) {
+    const selected = select ? select[relation.fieldName] : count;
+    if (!selected) continue;
+    reach(walk, relation);
+    if (isPlainRecord(selected) && !walkFilter(walk, relation.targetModel, selected.where, depth + 1)) return false;
+  }
+  return true;
+}
+function walkArgs(walk, model, args, depth) {
+  walk.out.models.add(model);
+  if (!isPlainRecord(args)) return true;
+  for (const filter of [args.where, args.orderBy, args.cursor]) {
+    if (!walkFilter(walk, model, filter, depth)) return false;
+  }
+  for (const projection of [args.include, args.select]) {
+    if (!isPlainRecord(projection)) continue;
+    if (!walkCount(walk, model, projection._count, depth)) return false;
+    for (const relation of walk.graph[model] ?? []) {
+      const nested = projection[relation.fieldName];
+      if (!nested) continue;
+      reach(walk, relation);
+      if (!walkArgs(walk, relation.targetModel, nested, depth + 1)) return false;
+    }
+  }
+  return true;
+}
+function readTargets(graph, model, args) {
+  const walk = { graph, out: { models: /* @__PURE__ */ new Set(), relational: false } };
+  return walkArgs(walk, model, args, 0) ? walk.out : null;
+}
+
+// src/core/extension.ts
+var CacheUnavailableError = class extends Error {
+  constructor(cause) {
+    super("cache coordinator unavailable; the write was not executed", { cause });
+    this.name = "CacheUnavailableError";
+  }
+};
+var DEFAULT_FILL_POLL_DELAYS_MS = [20, 40, 80, 160, 320, 640];
+var DEFAULT_LOCK_MS = 3e4;
+var DEFAULT_LEASE_MS = 6e4;
+var DEFAULT_MAX_VALUE_BYTES = 15e5;
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var pickEpochs = (epochs, fences) => Object.fromEntries(fences.map((fence) => [fence, epochs[fence] ?? 0]));
+var isNegative = (value) => value === null || Array.isArray(value) && value.length === 0;
+var sum = (values) => values.reduce((total, value) => total + value, 0);
+function internalParams(params) {
+  const internal = isPlainRecord(params.__internalParams) ? params.__internalParams : {};
+  const transaction = internal.transaction;
+  return {
+    dataPath: Array.isArray(internal.dataPath) ? internal.dataPath : [],
+    inBatch: isPlainRecord(transaction) && transaction.kind === "batch"
+  };
+}
+function validateOptions(options) {
+  if (options.config.configFormat !== CONFIG_FORMAT) {
+    throw new TypeError(
+      `cache extension: generated config format ${String(options.config.configFormat)} does not match ${CONFIG_FORMAT}; run prisma generate`
+    );
+  }
+  const inRange = (value, max) => value === void 0 || Number.isFinite(value) && value > 0 && value <= max;
+  const problems = [
+    !inRange(options.lockMs, MAX_LOCK_MS) && `lockMs must be in (0, ${MAX_LOCK_MS}]`,
+    !inRange(options.leaseMs, MAX_LEASE_MS) && `leaseMs must be in (0, ${MAX_LEASE_MS}]`,
+    !inRange(options.maxValueBytes, MAX_VALUE_BYTES) && `maxValueBytes must be in (0, ${MAX_VALUE_BYTES}]`,
+    options.fillPollDelaysMs?.some((delay) => !(Number.isFinite(delay) && delay >= 0)) && "fillPollDelaysMs must be non-negative",
+    options.excludeModels?.some((model) => !options.config.modelNames.includes(model)) && "excludeModels names an unknown model",
+    options.config.hasDecimalFields && !options.decimal && "decimal is required because the schema has Decimal fields (pass Prisma.Decimal)",
+    options.generation !== void 0 && !(options.generation.length > 0 && options.generation.length <= MAX_GENERATION_LENGTH) && `generation must be 1..${MAX_GENERATION_LENGTH} characters`,
+    options.coordinationGeneration !== void 0 && !(options.coordinationGeneration.length > 0 && options.coordinationGeneration.length <= MAX_GENERATION_LENGTH) && `coordinationGeneration must be 1..${MAX_GENERATION_LENGTH} characters`
+  ].filter((problem) => typeof problem === "string");
+  if (problems.length > 0) throw new TypeError(`cache extension: ${problems.join("; ")}`);
+  validateShapes(options.shape);
+}
+function createCacheExtension(options) {
+  validateOptions(options);
+  const { config, store, unsafeTestHooks: hooks } = options;
+  const enabled = options.enabled ?? true;
+  const excluded = new Set(options.excludeModels ?? []);
+  const scope = options.scope ?? "";
+  const generation = options.coordinationGeneration ?? `${PLANNER_VERSION}/${config.cacheVersion}/${options.generation ?? ""}`;
+  const pollDelays = options.fillPollDelaysMs ?? DEFAULT_FILL_POLL_DELAYS_MS;
+  const lockMs = options.lockMs ?? DEFAULT_LOCK_MS;
+  const leaseMs = options.leaseMs ?? DEFAULT_LEASE_MS;
+  const maxValueBytes = options.maxValueBytes ?? DEFAULT_MAX_VALUE_BYTES;
+  const report = (error, context) => options.onError?.(error, context);
+  const isCacheable = (model) => enabled && config.cacheableByModel[model] === true && !excluded.has(model);
+  function readContext(model, operation, args, query, key) {
+    const targets = readTargets(config.relationGraph, model, args);
+    if (!targets || [...targets.models].some((target) => !isCacheable(target))) return null;
+    const rootPk = operation.startsWith("findUnique") ? pkFromWhere(
+      isPlainRecord(args) ? args.where : void 0,
+      config.primaryKeyFieldsByModel[model] ?? ["id"],
+      config.primaryKeyNameByModel[model]
+    ) : null;
+    const base = [GLOBAL_FENCE, modelFence(model)];
+    const entity = rootPk === null ? null : entityFence(model, rootPk);
+    const fences = [...base, ...[...targets.models].map(writeFence), ...entity ? [entity] : []];
+    const entityFences = entity && !targets.relational ? [...base, entity] : null;
+    return { args, entityFences, fences, key, model, operation, query };
+  }
+  const release = (key, lockToken) => store.release({ key, lockToken }).catch((error) => report(error, "release"));
+  function serialize(value) {
+    try {
+      const serialized = JSON.stringify(encode(value));
+      if (new TextEncoder().encode(serialized).byteLength <= maxValueBytes) return serialized;
+      report(new Error(`cache value exceeds ${maxValueBytes} bytes`), "serialize");
+    } catch (error) {
+      report(error, "serialize");
+    }
+    return null;
+  }
+  async function fill(ctx, lockToken, epochs) {
+    let value;
+    let cached;
+    try {
+      const loaded = options.sessionCache ? await options.sessionCache.fill(() => ctx.query(ctx.args)) : { value: await ctx.query(ctx.args), cached: void 0 };
+      value = loaded.value;
+      cached = options.sessionCache ? loaded.cached : value;
+      await hooks?.afterFillQuery?.();
+    } catch (error) {
+      await release(ctx.key, lockToken);
+      throw error;
+    }
+    const serialized = serialize(cached);
+    if (serialized === null) {
+      await release(ctx.key, lockToken);
+      return value;
+    }
+    const shape = resolveShape(options.shape, ctx.model);
+    const baseTtl = ctx.operation !== "count" && isNegative(value) ? shape.negativeTtlSeconds : shape.freshTtlSeconds;
+    const ttlMs = Math.round(baseTtl * 1e3 * (1 + Math.random() * TTL_JITTER_RATIO));
+    const snapshotFences = ctx.entityFences && isPlainRecord(value) ? ctx.entityFences : ctx.fences;
+    try {
+      const result = await store.write({
+        key: ctx.key,
+        lockToken,
+        snapshot: pickEpochs(epochs, snapshotFences),
+        softTtlMs: Math.round(ttlMs * shape.softTtlRatio),
+        ttlMs,
+        value: serialized
+      });
+      if (!result.ok) report(new Error(`cache write rejected: ${result.reason}`), "write");
+    } catch (error) {
+      report(error, "write");
+      await release(ctx.key, lockToken);
+    }
+    return value;
+  }
+  async function scheduleRefresh(ctx, response) {
+    const token = response.refreshToken;
+    if (!token) return;
+    if (!options.waitUntil) return release(ctx.key, token);
+    try {
+      const refresh = () => fill(ctx, token, response.epochs).then(() => void 0);
+      options.waitUntil((options.sessionCache?.background ? options.sessionCache.background(refresh) : refresh()).catch((error) => report(error, "refresh")));
+    } catch (error) {
+      report(error, "waitUntil");
+      await release(ctx.key, token);
+    }
+  }
+  async function handleRead(model, operation, args, query, dataPath) {
+    let key;
+    try {
+      const identity = [PLANNER_VERSION, config.cacheVersion, scope, ...options.sessionCache ? [options.sessionCache.key()] : [], model, operation, dataPath, (options.keyArgs ? options.keyArgs(args) : args) ?? null];
+      key = `${model}:${await sha256Hex(stableStringify(identity))}`;
+    } catch (error) {
+      report(error, "key");
+      return query(args);
+    }
+    const ctx = readContext(model, operation, args, query, key);
+    if (!ctx) return query(args);
+    for (let attempt = 0; ; attempt++) {
+      let response;
+      try {
+        response = await store.read({ fences: ctx.fences, generation, key, lockMs, refresh: !!options.waitUntil });
+      } catch (error) {
+        report(error, "read");
+        return query(args);
+      }
+      if (response.kind === "hit") {
+        let value;
+        try {
+          value = decode(JSON.parse(response.value), options.decimal);
+          if (options.sessionCache) {
+            const cached = options.sessionCache.read(value);
+            if (!cached) {
+              if (response.refreshToken) await release(key, response.refreshToken);
+              return (await options.sessionCache.fill(() => query(args))).value;
+            }
+            value = cached.value;
+          }
+        } catch (error) {
+          report(error, "decode");
+          if (response.refreshToken) await release(key, response.refreshToken);
+          return query(args);
+        }
+        await scheduleRefresh(ctx, response);
+        return value;
+      }
+      if (response.lockToken) return fill(ctx, response.lockToken, response.epochs);
+      const delay = pollDelays[attempt];
+      const holderTooSlow = response.lockHeldForMs !== null && response.lockHeldForMs > sum(pollDelays);
+      if (response.pending || delay === void 0 || holderTooSlow) return query(args);
+      await sleep(delay);
+    }
+  }
+  async function withLease(fences, run) {
+    const token = crypto.randomUUID();
+    try {
+      await store.beginWrite({ fences, generation, leaseMs, token });
+    } catch (error) {
+      report(error, "beginWrite");
+      await endWrite(token, fences);
+      throw new CacheUnavailableError(error);
+    }
+    try {
+      await hooks?.afterBeginWrite?.();
+      return await run();
+    } finally {
+      if (!hooks?.skipEndWrite?.()) await endWrite(token, fences);
+    }
+  }
+  async function endWrite(token, fences) {
+    await store.endWrite({ fences, token }).catch((error) => report(error, "endWrite"));
+  }
+  const targetFences = (target) => rawWritePlanFences(config, target);
+  return {
+    client: {
+      async $cacheInvalidate(target) {
+        await store.invalidate(targetFences(target));
+      },
+      async $cacheRawWrite(target, run) {
+        const fences = targetFences(target);
+        return enabled ? withLease(fences, run) : run();
+      }
+    },
+    name: "dee-wan-cache",
+    query: {
+      $allModels: {
+        $allOperations(params) {
+          const { args, model, operation, query } = params;
+          if (!model) return query(args);
+          const { dataPath, inBatch } = internalParams(params);
+          if (READ_OPERATIONS.has(operation) && isCacheable(model) && !inBatch) {
+            return handleRead(model, operation, args, query, dataPath);
+          }
+          if (WRITE_OPERATIONS.has(operation) && enabled) {
+            return withLease(planFences(planWrite(config, model, operation, args)), () => query(args));
+          }
+          return query(args);
+        }
+      }
+    }
+  };
+}
+
+export { CacheUnavailableError, createCacheExtension, readTargets };
+//# sourceMappingURL=chunk-M4UOCIDQ.js.map
+//# sourceMappingURL=chunk-M4UOCIDQ.js.map