@chelone/core 0.5.0 → 0.7.0

package/dist/data/keys.js

@@ -1,55 +1,69 @@
+// src/data/keys.ts
+/** Root key for a resource — invalidation scope for everything under it. */
 function resourceKey(resource) {
-  return [resource];
+	return [resource];
 }
 function listKey(resource, params = {}) {
-  return [resource, "getList", params];
+	return [
+		resource,
+		"getList",
+		params
+	];
 }
 function infiniteListKey(resource, params) {
-  return [resource, "getInfiniteList", params];
+	return [
+		resource,
+		"getInfiniteList",
+		params
+	];
 }
+/** Partial-match key covering every `getInfiniteList` cache variant of a resource. */
 function infiniteListKeyPrefix(resource) {
-  return [resource, "getInfiniteList"];
+	return [resource, "getInfiniteList"];
 }
 function oneKey(resource, params) {
-  return [
-    resource,
-    "getOne",
-    params.meta === void 0 ? { id: String(params.id) } : { id: String(params.id), meta: params.meta }
-  ];
+	return [
+		resource,
+		"getOne",
+		params.meta === void 0 ? { id: String(params.id) } : {
+			id: String(params.id),
+			meta: params.meta
+		}
+	];
 }
 function manyKey(resource, params) {
-  const ids = params.ids.map(String).sort();
-  return [
-    resource,
-    "getMany",
-    params.meta === void 0 ? { ids } : { ids, meta: params.meta }
-  ];
+	const ids = params.ids.map(String).sort();
+	return [
+		resource,
+		"getMany",
+		params.meta === void 0 ? { ids } : {
+			ids,
+			meta: params.meta
+		}
+	];
 }
+/** Partial-match key covering every `getMany` cache variant of a resource. */
 function manyKeyPrefix(resource) {
-  return [resource, "getMany"];
+	return [resource, "getMany"];
 }
 function manyReferenceKey(resource, params) {
-  return [resource, "getManyReference", params];
+	return [
+		resource,
+		"getManyReference",
+		params
+	];
 }
 function lockKey(resource, params) {
-  return [
-    resource,
-    "getLock",
-    params.meta === void 0 ? { id: String(params.id) } : { id: String(params.id), meta: params.meta }
-  ];
+	return [
+		resource,
+		"getLock",
+		params.meta === void 0 ? { id: String(params.id) } : {
+			id: String(params.id),
+			meta: params.meta
+		}
+	];
 }
 function locksKey(resource) {
-  return [resource, "getLocks"];
-}
-export {
-  infiniteListKey,
-  infiniteListKeyPrefix,
-  listKey,
-  lockKey,
-  locksKey,
-  manyKey,
-  manyKeyPrefix,
-  manyReferenceKey,
-  oneKey,
-  resourceKey
-};
+	return [resource, "getLocks"];
+}
+export { infiniteListKey, infiniteListKeyPrefix, listKey, lockKey, locksKey, manyKey, manyKeyPrefix, manyReferenceKey, oneKey, resourceKey };

package/dist/data/mutation-options.d.ts

@@ -1,3 +1,5 @@
+import type { QueryKey } from "@tanstack/query-core";
+import type { ResourceRecord } from "../resource/record.js";
 import type { RecordOf, ResourceMap } from "../resource/registry.js";
 import type { DataContext } from "./query-options.js";
 import type { CreateParams, DeleteParams, UpdateParams } from "./types.js";
@@ -11,11 +13,14 @@ export type MutationMode = "pessimistic" | "optimistic" | "undoable";
 export interface MutationModeOptions {
     mutationMode?: MutationMode;
 }
-type ManySnapshot = Array<[readonly unknown[], unknown]>;
-interface OptimisticContext {
-    previous?: unknown;
-    key?: readonly unknown[];
-    manySnapshot?: ManySnapshot;
+type ManySnapshot<TRecord extends ResourceRecord> = Array<[
+    QueryKey,
+    TRecord[] | undefined
+]>;
+interface OptimisticContext<TRecord extends ResourceRecord> {
+    previous?: TRecord;
+    key?: QueryKey;
+    manySnapshot?: ManySnapshot<TRecord>;
     rollbackLists?: () => void;
 }
 export declare function createMutationOptions<TResources extends ResourceMap, TName extends keyof TResources & string>(ctx: DataContext<TResources>, resource: TName): {
@@ -39,10 +44,10 @@ export declare function updateMutationOptions<TResources extends ResourceMap, TN
             id: string;
             meta: {} | null;
         }];
-        manySnapshot: ManySnapshot;
+        manySnapshot: ManySnapshot<RecordOf<TResources, TName>>;
         rollbackLists: () => void;
     }>;
-    onError: (_error: unknown, _params: UpdateParams<RecordOf<TResources, TName>>, context: OptimisticContext | undefined) => void;
+    onError: (_error: Error, _params: UpdateParams<RecordOf<TResources, TName>>, context: OptimisticContext<RecordOf<TResources, TName>> | undefined) => void;
     onSettled: () => Promise<void> | undefined;
 };
 export declare function deleteMutationOptions<TResources extends ResourceMap, TName extends keyof TResources & string>(ctx: DataContext<TResources>, resource: TName, options?: MutationModeOptions): {
@@ -60,9 +65,9 @@ export declare function deleteMutationOptions<TResources extends ResourceMap, TN
             id: string;
             meta: {} | null;
         }];
-        manySnapshot: ManySnapshot;
+        manySnapshot: ManySnapshot<RecordOf<TResources, TName>>;
     }>;
-    onError: (_error: unknown, _params: DeleteParams<RecordOf<TResources, TName>>, context: OptimisticContext | undefined) => void;
+    onError: (_error: Error, _params: DeleteParams<RecordOf<TResources, TName>>, context: OptimisticContext<RecordOf<TResources, TName>> | undefined) => void;
     onSettled: () => Promise<void>;
 };
 export {};

package/dist/data/mutation-options.js

@@ -1,125 +1,109 @@
-import { removeManyEntries, patchManyEntries, patchListEntries } from "./cache-ops.js";
-import { oneKey, resourceKey, manyKeyPrefix } from "./keys.js";
+import { patchListEntries, patchManyEntries, removeManyEntries } from "./cache-ops.js";
+import { manyKeyPrefix, oneKey, resourceKey } from "./keys.js";
+// src/data/mutation-options.ts
 function invalidateResource(ctx, resource) {
-  return ctx.queryClient.invalidateQueries({ queryKey: resourceKey(resource) });
+	return ctx.queryClient.invalidateQueries({ queryKey: resourceKey(resource) });
 }
-const unsettledUpdates = /* @__PURE__ */ new WeakMap();
+/**
+* Optimistic updates that have started and not yet settled, per client and
+* resource. `isMutating` cannot stand in: TanStack runs `onSettled` before it
+* marks the mutation done, so two updates answered in the same tick each count
+* the other as pending and both would skip the refetch.
+*/
+var unsettledUpdates = /* @__PURE__ */ new WeakMap();
 function countUpdate(queryClient, resource, by) {
-  const counts = unsettledUpdates.get(queryClient) ?? /* @__PURE__ */ new Map();
-  unsettledUpdates.set(queryClient, counts);
-  const next = (counts.get(resource) ?? 0) + by;
-  counts.set(resource, next);
-  return next;
+	const counts = unsettledUpdates.get(queryClient) ?? /* @__PURE__ */ new Map();
+	unsettledUpdates.set(queryClient, counts);
+	const next = (counts.get(resource) ?? 0) + by;
+	counts.set(resource, next);
+	return next;
 }
+/** Cancels in-flight list fetches (`getList`, `getManyReference`, `getInfiniteList`) so they cannot overwrite a patch. */
 function cancelListQueries(ctx, resource) {
-  return ctx.queryClient.cancelQueries({
-    queryKey: resourceKey(resource),
-    predicate: ({ queryKey }) => queryKey[1] === "getList" || queryKey[1] === "getManyReference" || queryKey[1] === "getInfiniteList"
-  });
+	return ctx.queryClient.cancelQueries({
+		queryKey: resourceKey(resource),
+		predicate: ({ queryKey }) => queryKey[1] === "getList" || queryKey[1] === "getManyReference" || queryKey[1] === "getInfiniteList"
+	});
 }
+/** Cancels in-flight `getMany` fetches so they cannot overwrite the patch, then snapshots the entries. */
 async function snapshotManyEntries(ctx, resource) {
-  await ctx.queryClient.cancelQueries({ queryKey: manyKeyPrefix(resource) });
-  return ctx.queryClient.getQueriesData({ queryKey: manyKeyPrefix(resource) });
+	await ctx.queryClient.cancelQueries({ queryKey: manyKeyPrefix(resource) });
+	return ctx.queryClient.getQueriesData({ queryKey: manyKeyPrefix(resource) });
 }
 function restoreManyEntries(ctx, snapshot) {
-  for (const [key, value] of snapshot ?? []) {
-    ctx.queryClient.setQueryData(key, value);
-  }
+	for (const [key, value] of snapshot ?? []) ctx.queryClient.setQueryData(key, value);
 }
 function createMutationOptions(ctx, resource) {
-  return {
-    mutationFn: async (params) => {
-      const result = await ctx.dataProvider.create(resource, params);
-      return result.data;
-    },
-    onSettled: () => invalidateResource(ctx, resource)
-  };
+	return {
+		mutationFn: async (params) => {
+			return (await ctx.dataProvider.create(resource, params)).data;
+		},
+		onSettled: () => invalidateResource(ctx, resource)
+	};
 }
 function updateMutationOptions(ctx, resource, options = {}) {
-  const mode = options.mutationMode ?? "pessimistic";
-  const mutationKey = [resource, "update"];
-  return {
-    mutationKey,
-    mutationFn: async (params) => {
-      const result = await ctx.dataProvider.update(resource, params);
-      return result.data;
-    },
-    onMutate: async (params) => {
-      if (mode !== "optimistic") return {};
-      countUpdate(ctx.queryClient, resource, 1);
-      const key = oneKey(resource, { id: params.id });
-      await ctx.queryClient.cancelQueries({ queryKey: key });
-      const previous = ctx.queryClient.getQueryData(key);
-      if (previous !== void 0) {
-        const merged = Object.assign(
-          structuredClone(previous),
-          structuredClone(params.data)
-        );
-        ctx.queryClient.setQueryData(key, merged);
-      }
-      const manySnapshot = await snapshotManyEntries(ctx, resource);
-      patchManyEntries(
-        ctx.queryClient,
-        resource,
-        /* @__PURE__ */ new Set([String(params.id)]),
-        structuredClone(params.data)
-      );
-      await cancelListQueries(ctx, resource);
-      const rollbackLists = patchListEntries(
-        ctx.queryClient,
-        resource,
-        /* @__PURE__ */ new Set([String(params.id)]),
-        structuredClone(params.data)
-      );
-      return { previous, key, manySnapshot, rollbackLists };
-    },
-    onError: (_error, _params, context) => {
-      if (context?.key && context.previous !== void 0) {
-        ctx.queryClient.setQueryData(context.key, context.previous);
-      }
-      restoreManyEntries(ctx, context?.manySnapshot);
-      context?.rollbackLists?.();
-    },
-    onSettled: () => {
-      if (mode === "optimistic" && countUpdate(ctx.queryClient, resource, -1) > 0) {
-        return;
-      }
-      return invalidateResource(ctx, resource);
-    }
-  };
+	const mode = options.mutationMode ?? "pessimistic";
+	return {
+		mutationKey: [resource, "update"],
+		mutationFn: async (params) => {
+			return (await ctx.dataProvider.update(resource, params)).data;
+		},
+		onMutate: async (params) => {
+			if (mode !== "optimistic") return {};
+			countUpdate(ctx.queryClient, resource, 1);
+			const key = oneKey(resource, { id: params.id });
+			await ctx.queryClient.cancelQueries({ queryKey: key });
+			const previous = ctx.queryClient.getQueryData(key);
+			if (previous !== void 0) {
+				const merged = Object.assign(structuredClone(previous), structuredClone(params.data));
+				ctx.queryClient.setQueryData(key, merged);
+			}
+			const manySnapshot = await snapshotManyEntries(ctx, resource);
+			patchManyEntries(ctx.queryClient, resource, /* @__PURE__ */ new Set([String(params.id)]), structuredClone(params.data));
+			await cancelListQueries(ctx, resource);
+			return {
+				previous,
+				key,
+				manySnapshot,
+				rollbackLists: patchListEntries(ctx.queryClient, resource, /* @__PURE__ */ new Set([String(params.id)]), structuredClone(params.data))
+			};
+		},
+		onError: (_error, _params, context) => {
+			if (context?.key && context.previous !== void 0) ctx.queryClient.setQueryData(context.key, context.previous);
+			restoreManyEntries(ctx, context?.manySnapshot);
+			context?.rollbackLists?.();
+		},
+		onSettled: () => {
+			if (mode === "optimistic" && countUpdate(ctx.queryClient, resource, -1) > 0) return;
+			return invalidateResource(ctx, resource);
+		}
+	};
 }
 function deleteMutationOptions(ctx, resource, options = {}) {
-  const mode = options.mutationMode ?? "pessimistic";
-  return {
-    mutationFn: async (params) => {
-      const result = await ctx.dataProvider.delete(resource, params);
-      return result.data;
-    },
-    onMutate: async (params) => {
-      if (mode !== "optimistic") return {};
-      const key = oneKey(resource, { id: params.id });
-      await ctx.queryClient.cancelQueries({ queryKey: key });
-      const previous = ctx.queryClient.getQueryData(key);
-      ctx.queryClient.removeQueries({ queryKey: key });
-      const manySnapshot = await snapshotManyEntries(ctx, resource);
-      removeManyEntries(
-        ctx.queryClient,
-        resource,
-        /* @__PURE__ */ new Set([String(params.id)])
-      );
-      return { previous, key, manySnapshot };
-    },
-    onError: (_error, _params, context) => {
-      if (context?.key && context.previous !== void 0) {
-        ctx.queryClient.setQueryData(context.key, context.previous);
-      }
-      restoreManyEntries(ctx, context?.manySnapshot);
-    },
-    onSettled: () => invalidateResource(ctx, resource)
-  };
+	const mode = options.mutationMode ?? "pessimistic";
+	return {
+		mutationFn: async (params) => {
+			return (await ctx.dataProvider.delete(resource, params)).data;
+		},
+		onMutate: async (params) => {
+			if (mode !== "optimistic") return {};
+			const key = oneKey(resource, { id: params.id });
+			await ctx.queryClient.cancelQueries({ queryKey: key });
+			const previous = ctx.queryClient.getQueryData(key);
+			ctx.queryClient.removeQueries({ queryKey: key });
+			const manySnapshot = await snapshotManyEntries(ctx, resource);
+			removeManyEntries(ctx.queryClient, resource, /* @__PURE__ */ new Set([String(params.id)]));
+			return {
+				previous,
+				key,
+				manySnapshot
+			};
+		},
+		onError: (_error, _params, context) => {
+			if (context?.key && context.previous !== void 0) ctx.queryClient.setQueryData(context.key, context.previous);
+			restoreManyEntries(ctx, context?.manySnapshot);
+		},
+		onSettled: () => invalidateResource(ctx, resource)
+	};
 }
-export {
-  createMutationOptions,
-  deleteMutationOptions,
-  updateMutationOptions
-};
+export { createMutationOptions, deleteMutationOptions, updateMutationOptions };

package/dist/data/query-options.js

@@ -1,81 +1,86 @@
 import { infiniteListKey, listKey, manyKey, manyReferenceKey, oneKey } from "./keys.js";
+// src/data/query-options.ts
 function seedRecords(queryClient, resource, records) {
-  for (const record of records) {
-    queryClient.setQueryData(oneKey(resource, { id: record.id }), record);
-  }
+	for (const record of records) queryClient.setQueryData(oneKey(resource, { id: record.id }), record);
 }
+/** Plain option objects — consumable by any framework's useQuery AND server-side prefetchQuery. */
 function getListOptions(ctx, resource, params = {}) {
-  return {
-    queryKey: listKey(resource, params),
-    queryFn: async () => {
-      const result = await ctx.dataProvider.getList(resource, params);
-      seedRecords(ctx.queryClient, resource, result.data);
-      return result;
-    }
-  };
+	return {
+		queryKey: listKey(resource, params),
+		queryFn: async () => {
+			const result = await ctx.dataProvider.getList(resource, params);
+			seedRecords(ctx.queryClient, resource, result.data);
+			return result;
+		}
+	};
 }
+/**
+* One query that gathers pages: an infinite observer or `fetchInfiniteQuery`
+* consumes it. The page param is the page number; rows are seeded into
+* `oneKey` like `getListOptions` does.
+*/
 function getInfiniteListOptions(ctx, resource, params) {
-  const { page, perPage } = params.pagination;
-  return {
-    queryKey: infiniteListKey(resource, params),
-    queryFn: async ({ pageParam }) => {
-      const result = await ctx.dataProvider.getList(resource, {
-        ...params,
-        pagination: { page: pageParam, perPage }
-      });
-      seedRecords(ctx.queryClient, resource, result.data);
-      return result;
-    },
-    initialPageParam: page,
-    getNextPageParam: (lastPage, allPages, lastPageParam, allPageParams) => {
-      const { pageInfo, total } = lastPage;
-      if (pageInfo?.hasNextPage !== void 0) {
-        return pageInfo.hasNextPage ? lastPageParam + 1 : void 0;
-      }
-      if (total != null) {
-        const skipped = Math.max(0, ((allPageParams[0] ?? page) - 1) * perPage);
-        const loaded = allPages.reduce((n, p) => n + p.data.length, skipped);
-        return loaded < total ? lastPageParam + 1 : void 0;
-      }
-      const { length } = lastPage.data;
-      return length > 0 && length >= perPage ? lastPageParam + 1 : void 0;
-    },
-    getPreviousPageParam: (_firstPage, _allPages, firstPageParam, _allPageParams) => firstPageParam > 1 ? firstPageParam - 1 : void 0
-  };
+	const { page, perPage } = params.pagination;
+	return {
+		queryKey: infiniteListKey(resource, params),
+		queryFn: async ({ pageParam }) => {
+			const result = await ctx.dataProvider.getList(resource, {
+				...params,
+				pagination: {
+					page: pageParam,
+					perPage
+				}
+			});
+			seedRecords(ctx.queryClient, resource, result.data);
+			return result;
+		},
+		initialPageParam: page,
+		getNextPageParam: (lastPage, allPages, lastPageParam, allPageParams) => {
+			const { pageInfo, total } = lastPage;
+			if (pageInfo?.hasNextPage !== void 0) return pageInfo.hasNextPage ? lastPageParam + 1 : void 0;
+			if (total != null) {
+				const skipped = Math.max(0, ((allPageParams[0] ?? page) - 1) * perPage);
+				return allPages.reduce((n, p) => n + p.data.length, skipped) < total ? lastPageParam + 1 : void 0;
+			}
+			const { length } = lastPage.data;
+			return length > 0 && length >= perPage ? lastPageParam + 1 : void 0;
+		},
+		getPreviousPageParam: (_firstPage, _allPages, firstPageParam, _allPageParams) => firstPageParam > 1 ? firstPageParam - 1 : void 0
+	};
 }
+/** One record by id, cached under `oneKey`. */
 function getOneOptions(ctx, resource, params) {
-  return {
-    queryKey: oneKey(resource, params),
-    queryFn: async () => {
-      const result = await ctx.dataProvider.getOne(resource, params);
-      return result.data;
-    }
-  };
+	return {
+		queryKey: oneKey(resource, params),
+		queryFn: async () => {
+			return (await ctx.dataProvider.getOne(resource, params)).data;
+		}
+	};
 }
+/** Records for an array of ids, seeded into `oneKey`. Resolves to the rows only. */
 function getManyOptions(ctx, resource, params) {
-  return {
-    queryKey: manyKey(resource, params),
-    queryFn: async () => {
-      const result = await ctx.dataProvider.getMany(resource, params);
-      seedRecords(ctx.queryClient, resource, result.data);
-      return result.data;
-    }
-  };
+	return {
+		queryKey: manyKey(resource, params),
+		queryFn: async () => {
+			const result = await ctx.dataProvider.getMany(resource, params);
+			seedRecords(ctx.queryClient, resource, result.data);
+			return result.data;
+		}
+	};
 }
+/**
+* Records whose `params.target` field equals `params.id` (the FK on the
+* referenced-FROM side). Keeps the whole `GetManyReferenceResult` (rows and
+* `total`) and seeds each row into the `oneKey` cache.
+*/
 function getManyReferenceOptions(ctx, resource, params) {
-  return {
-    queryKey: manyReferenceKey(resource, params),
-    queryFn: async () => {
-      const result = await ctx.dataProvider.getManyReference(resource, params);
-      seedRecords(ctx.queryClient, resource, result.data);
-      return result;
-    }
-  };
+	return {
+		queryKey: manyReferenceKey(resource, params),
+		queryFn: async () => {
+			const result = await ctx.dataProvider.getManyReference(resource, params);
+			seedRecords(ctx.queryClient, resource, result.data);
+			return result;
+		}
+	};
 }
-export {
-  getInfiniteListOptions,
-  getListOptions,
-  getManyOptions,
-  getManyReferenceOptions,
-  getOneOptions
-};
+export { getInfiniteListOptions, getListOptions, getManyOptions, getManyReferenceOptions, getOneOptions };

package/dist/data/remove-empty.d.ts

@@ -0,0 +1,3 @@
+import type { FilterPayload } from "./types.js";
+/** Strips `''`, `null` and `undefined` values. Always returns a FRESH object. */
+export declare function removeEmpty(filter: FilterPayload): FilterPayload;

package/dist/data/remove-empty.js

@@ -0,0 +1,11 @@
+// src/data/remove-empty.ts
+/** Strips `''`, `null` and `undefined` values. Always returns a FRESH object. */
+function removeEmpty(filter) {
+	const result = {};
+	for (const [key, value] of Object.entries(filter)) {
+		if (value === "" || value === null || value === void 0) continue;
+		result[key] = value;
+	}
+	return result;
+}
+export { removeEmpty };

package/dist/data/undoable.d.ts

@@ -1,6 +1,6 @@
 import { type QueryClient, type QueryKey } from "@tanstack/query-core";
 import type { Identifier } from "../resource/identifier.js";
-import type { ResourceRecord } from "../resource/record.js";
+import type { LooseRecord, ResourceRecord } from "../resource/record.js";
 import type { DeleteParams, UpdateManyParams, UpdateParams } from "./types.js";
 /**
  * A snapshot of the query cache taken BEFORE an optimistic apply: an array of
@@ -102,7 +102,7 @@ export interface UndoableCacheOptions {
     };
 }
 /** Patch `ids` in the `resource` caches now; the notification reads "updated". */
-export declare function undoableUpdateOptions(queryClient: QueryClient, resource: string, ids: Identifier[], data: object): UndoableCacheOptions;
+export declare function undoableUpdateOptions<TRecord extends ResourceRecord = LooseRecord>(queryClient: QueryClient, resource: string, ids: Identifier[], data: Partial<NoInfer<TRecord>>): UndoableCacheOptions;
 /** Remove `ids` from the `resource` caches now; the notification reads "deleted". */
 export declare function undoableDeleteOptions(queryClient: QueryClient, resource: string, ids: Identifier[]): UndoableCacheOptions;
 /** The record an undoable update shows at once: the previous one with the patch on top. */