@chelone/core 0.6.0 → 0.9.0

package/dist/data/undoable.js

@@ -1,196 +1,212 @@
-import { partialMatchKey } from "@tanstack/query-core";
 import { removeRecordsFromCache, updateRecordsInCache } from "./cache-ops.js";
-const pendingUndoables = /* @__PURE__ */ new Set();
-const settledListeners = /* @__PURE__ */ new Set();
-let inFlightCommits = 0;
+import { partialMatchKey } from "@tanstack/query-core";
+// src/data/undoable.ts
+/**
+* Module-level registry of still-undoable mutations (those neither committed
+* nor undone). Drives the adapter's `beforeunload` guard: if any remain
+* pending when the page unloads, commit them so the server is not left behind
+* the optimistic cache.
+*/
+var pendingUndoables = /* @__PURE__ */ new Set();
+var settledListeners = /* @__PURE__ */ new Set();
+/** Committed undoables whose deferred server call has not settled yet. */
+var inFlightCommits = 0;
+/** Calls the listeners once no undoable is pending: after an undo, or after a commit's server call settles. */
 function notifySettled() {
-  if (hasUnsettledUndoables()) return;
-  for (const listener of [...settledListeners]) listener();
-}
-const openUndoables = /* @__PURE__ */ new WeakMap();
+	if (hasUnsettledUndoables()) return;
+	for (const listener of [...settledListeners]) listener();
+}
+/**
+* Per client, the undoables in start order that are pending, mid-commit, or
+* committed behind an earlier one that has not settled. Handles snapshot the
+* whole resource, so a rollback must replay the later ones over its own
+* restore instead of overwriting their changes.
+*/
+var openUndoables = /* @__PURE__ */ new WeakMap();
 function takeSnapshot(queryClient, queryKeys) {
-  return queryKeys.reduce(
-    (acc, queryKey) => acc.concat(queryClient.getQueriesData({ queryKey })),
-    []
-  );
+	return queryKeys.reduce((acc, queryKey) => acc.concat(queryClient.getQueriesData({ queryKey })), []);
 }
 function restore(queryClient, snapshot) {
-  for (const [key, value] of snapshot) {
-    queryClient.setQueryData(key, value);
-  }
+	for (const [key, value] of snapshot) queryClient.setQueryData(key, value);
 }
+/** Query-key partial matching is one-way, so overlap is a prefix match either way round. */
 function keysOverlap(a, b) {
-  return a.some(
-    (x) => b.some((y) => partialMatchKey(x, y) || partialMatchKey(y, x))
-  );
-}
-function entriesToReplay(later2, entry) {
-  const affectedKeys = [...entry.queryKeys];
-  const affected = [];
-  for (const other of later2) {
-    if (!keysOverlap(affectedKeys, other.queryKeys)) continue;
-    affected.push(other);
-    affectedKeys.push(...other.queryKeys);
-  }
-  return affected;
-}
+	return a.some((x) => b.some((y) => partialMatchKey(x, y) || partialMatchKey(y, x)));
+}
+/**
+* The later entries a rollback of `entry` must unwind and replay: those whose
+* keys overlap `entry`'s, or those of an earlier included entry. Others never
+* saw its change, and restoring their snapshot would revert unrelated cache.
+*/
+function entriesToReplay(later, entry) {
+	const affectedKeys = [...entry.queryKeys];
+	const affected = [];
+	for (const other of later) {
+		if (!keysOverlap(affectedKeys, other.queryKeys)) continue;
+		affected.push(other);
+		affectedKeys.push(...other.queryKeys);
+	}
+	return affected;
+}
+/** Drops committed entries from the front: nothing earlier can roll back over them any more. */
 function dropSettledPrefix(order) {
-  while (order[0]?.committed) order.shift();
+	while (order[0]?.committed) order.shift();
 }
+/**
+* Start an undoable mutation: snapshot the affected cache, cancel outgoing
+* refetches, apply the optimistic change, and return a handle whose `undo()` /
+* `commit()` settle it. React/Vue-free — pure query-core.
+*/
 function startUndoableMutation(config) {
-  const { queryClient, queryKeys, applyOptimistic, commit } = config;
-  const entry = {
-    queryKeys,
-    applyOptimistic,
-    snapshot: takeSnapshot(queryClient, queryKeys),
-    committed: false
-  };
-  for (const queryKey of queryKeys) {
-    void queryClient.cancelQueries({ queryKey });
-  }
-  applyOptimistic();
-  let order = openUndoables.get(queryClient);
-  if (!order) {
-    order = [];
-    openUndoables.set(queryClient, order);
-  }
-  order.push(entry);
-  let state = "pending";
-  let commitPromise;
-  const rollback = () => {
-    const open = order;
-    const index = open.indexOf(entry);
-    const later2 = entriesToReplay(open.slice(index + 1), entry);
-    open.splice(index, 1);
-    for (const other of [...later2].reverse())
-      restore(queryClient, other.snapshot);
-    restore(queryClient, entry.snapshot);
-    for (const other of later2) {
-      other.snapshot = takeSnapshot(queryClient, other.queryKeys);
-      other.applyOptimistic();
-    }
-    dropSettledPrefix(open);
-  };
-  const handle = {
-    get isPending() {
-      return state === "pending";
-    },
-    undo() {
-      if (state !== "pending") return;
-      state = "undone";
-      pendingUndoables.delete(handle);
-      rollback();
-      notifySettled();
-    },
-    commit() {
-      if (state === "committed") {
-        return commitPromise;
-      }
-      if (state === "undone") return Promise.resolve(void 0);
-      state = "committed";
-      pendingUndoables.delete(handle);
-      inFlightCommits += 1;
-      commitPromise = commit().then(
-        (result) => {
-          entry.committed = true;
-          dropSettledPrefix(order);
-          return result;
-        },
-        (error) => {
-          rollback();
-          throw error;
-        }
-      );
-      const settle = () => {
-        inFlightCommits -= 1;
-        notifySettled();
-      };
-      commitPromise.then(settle, settle);
-      return commitPromise;
-    }
-  };
-  pendingUndoables.add(handle);
-  return handle;
-}
+	const { queryClient, queryKeys, applyOptimistic, commit } = config;
+	const entry = {
+		queryKeys,
+		applyOptimistic,
+		snapshot: takeSnapshot(queryClient, queryKeys),
+		committed: false
+	};
+	for (const queryKey of queryKeys) queryClient.cancelQueries({ queryKey });
+	applyOptimistic();
+	let order = openUndoables.get(queryClient);
+	if (!order) {
+		order = [];
+		openUndoables.set(queryClient, order);
+	}
+	order.push(entry);
+	let state = "pending";
+	let commitPromise;
+	const rollback = () => {
+		const open = order;
+		const index = open.indexOf(entry);
+		const later = entriesToReplay(open.slice(index + 1), entry);
+		open.splice(index, 1);
+		for (const other of [...later].reverse()) restore(queryClient, other.snapshot);
+		restore(queryClient, entry.snapshot);
+		for (const other of later) {
+			other.snapshot = takeSnapshot(queryClient, other.queryKeys);
+			other.applyOptimistic();
+		}
+		dropSettledPrefix(open);
+	};
+	const handle = {
+		get isPending() {
+			return state === "pending";
+		},
+		undo() {
+			if (state !== "pending") return;
+			state = "undone";
+			pendingUndoables.delete(handle);
+			rollback();
+			notifySettled();
+		},
+		commit() {
+			if (commitPromise) return commitPromise;
+			if (state !== "pending") return Promise.resolve(void 0);
+			state = "committed";
+			pendingUndoables.delete(handle);
+			inFlightCommits += 1;
+			commitPromise = commit().then((result) => {
+				entry.committed = true;
+				dropSettledPrefix(order);
+				return result;
+			}, (error) => {
+				rollback();
+				throw error;
+			});
+			const settle = () => {
+				inFlightCommits -= 1;
+				notifySettled();
+			};
+			commitPromise.then(settle, settle);
+			return commitPromise;
+		}
+	};
+	pendingUndoables.add(handle);
+	return handle;
+}
+/** Runs `run` after the current microtasks; a throw is logged, not raised. */
 function later(run) {
-  setTimeout(() => {
-    try {
-      run();
-    } catch (error) {
-      console.error(error);
-    }
-  }, 0);
-}
+	setTimeout(() => {
+		try {
+			run();
+		} catch (error) {
+			console.error(error);
+		}
+	}, 0);
+}
+/**
+* Bind an undoable `mutate`'s callbacks to its `params`. The wrapped commit
+* rethrows a failure, so the handle still rolls back and the adapter still
+* notifies; the callbacks wait a macrotask to run after both.
+*/
 function undoableCallbacks(params, callbacks = {}) {
-  const { onSuccess, onError, onSettled } = callbacks;
-  return {
-    success: (data) => onSuccess?.(data, params),
-    // The callbacks run in a timer, never inside the commit's promise: one that
-    // throws must not read as a failed commit and roll the cache back.
-    commit: (commit) => async () => {
-      let result;
-      try {
-        result = await commit();
-      } catch (error) {
-        later(() => {
-          onError?.(error, params);
-          onSettled?.(params);
-        });
-        throw error;
-      }
-      later(() => onSettled?.(params));
-      return result;
-    }
-  };
-}
+	const { onSuccess, onError, onSettled } = callbacks;
+	return {
+		success: (data) => onSuccess?.(data, params),
+		commit: (commit) => async () => {
+			let result;
+			try {
+				result = await commit();
+			} catch (error) {
+				later(() => {
+					onError?.(error, params);
+					onSettled?.(params);
+				});
+				throw error;
+			}
+			later(() => onSettled?.(params));
+			return result;
+		}
+	};
+}
+/** Patch `ids` in the `resource` caches now; the notification reads "updated". */
 function undoableUpdateOptions(queryClient, resource, ids, data) {
-  return {
-    queryKeys: [[resource]],
-    applyOptimistic: () => updateRecordsInCache(
-      queryClient,
-      resource,
-      ids,
-      data
-    ),
-    message: "chelone.notification.updated",
-    messageArgs: { smart_count: ids.length }
-  };
-}
+	return {
+		queryKeys: [[resource]],
+		applyOptimistic: () => updateRecordsInCache(queryClient, resource, ids, data),
+		message: "chelone.notification.updated",
+		messageArgs: { smart_count: ids.length }
+	};
+}
+/** Remove `ids` from the `resource` caches now; the notification reads "deleted". */
 function undoableDeleteOptions(queryClient, resource, ids) {
-  return {
-    queryKeys: [[resource]],
-    applyOptimistic: () => removeRecordsFromCache(queryClient, resource, ids),
-    message: "chelone.notification.deleted",
-    messageArgs: { smart_count: ids.length }
-  };
-}
+	return {
+		queryKeys: [[resource]],
+		applyOptimistic: () => removeRecordsFromCache(queryClient, resource, ids),
+		message: "chelone.notification.deleted",
+		messageArgs: { smart_count: ids.length }
+	};
+}
+/** The record an undoable update shows at once: the previous one with the patch on top. */
 function patchedRecord(params) {
-  return { ...params.previousData, ...params.data, id: params.id };
+	return {
+		...params.previousData,
+		...params.data,
+		id: params.id
+	};
 }
+/** True while at least one undoable mutation is still awaiting commit/undo. */
 function hasPendingUndoables() {
-  return pendingUndoables.size > 0;
+	return pendingUndoables.size > 0;
 }
+/** True while an undoable is pending or its committed server call is still in flight. */
 function hasUnsettledUndoables() {
-  return pendingUndoables.size > 0 || inFlightCommits > 0;
+	return pendingUndoables.size > 0 || inFlightCommits > 0;
 }
+/** Runs `listener` each time the last pending undoable mutation settles. */
 function onUndoablesSettled(listener) {
-  settledListeners.add(listener);
-  return () => {
-    settledListeners.delete(listener);
-  };
-}
+	settledListeners.add(listener);
+	return () => {
+		settledListeners.delete(listener);
+	};
+}
+/**
+* Commit every still-pending undoable mutation (the `beforeunload` guard).
+* Never rejects — individual commit failures are swallowed here (each already
+* rolled its own cache back); it only guarantees the server calls are fired.
+*/
 async function commitAllUndoables() {
-  const handles = [...pendingUndoables];
-  await Promise.allSettled(handles.map((handle) => handle.commit()));
-}
-export {
-  commitAllUndoables,
-  hasPendingUndoables,
-  hasUnsettledUndoables,
-  onUndoablesSettled,
-  patchedRecord,
-  startUndoableMutation,
-  undoableCallbacks,
-  undoableDeleteOptions,
-  undoableUpdateOptions
-};
+	const handles = [...pendingUndoables];
+	await Promise.allSettled(handles.map((handle) => handle.commit()));
+}
+export { commitAllUndoables, hasPendingUndoables, hasUnsettledUndoables, onUndoablesSettled, patchedRecord, startUndoableMutation, undoableCallbacks, undoableDeleteOptions, undoableUpdateOptions };

package/dist/data/with-lifecycle-callbacks.d.ts

@@ -1,17 +1,28 @@
-import type { LooseRecord } from "../resource/record.js";
+import type { ResourceRecord } from "../resource/record.js";
 import type { RecordOf, ResourceMap } from "../resource/registry.js";
 import type { CreateParams, CreateResult, DataProvider, DeleteManyParams, DeleteManyResult, DeleteParams, DeleteResult, GetListParams, GetListResult, GetManyParams, GetManyReferenceParams, GetManyReferenceResult, GetManyResult, GetOneParams, GetOneResult, UpdateManyParams, UpdateManyResult, UpdateParams, UpdateResult } from "./types.js";
 type MaybePromise<T> = T | Promise<T>;
+/**
+ * The hooks that do not depend on a record type, so a named handler and the
+ * `"*"` handler declare them once.
+ */
+interface RecordFreeCallbacks<TResources extends ResourceMap> {
+    beforeGetList?(params: GetListParams, dataProvider: DataProvider<TResources>): MaybePromise<GetListParams>;
+    beforeGetOne?(params: GetOneParams, dataProvider: DataProvider<TResources>): MaybePromise<GetOneParams>;
+    beforeGetMany?(params: GetManyParams, dataProvider: DataProvider<TResources>): MaybePromise<GetManyParams>;
+    beforeGetManyReference?(params: GetManyReferenceParams, dataProvider: DataProvider<TResources>): MaybePromise<GetManyReferenceParams>;
+    beforeDeleteMany?(params: DeleteManyParams, dataProvider: DataProvider<TResources>): MaybePromise<DeleteManyParams>;
+    afterUpdateMany?(result: UpdateManyResult, dataProvider: DataProvider<TResources>): MaybePromise<UpdateManyResult>;
+    afterDeleteMany?(result: DeleteManyResult, dataProvider: DataProvider<TResources>): MaybePromise<DeleteManyResult>;
+}
 /**
  * The optional hooks of one handler, typed for records of type `TRecord`.
  * Every callback must return the value: `undefined` is not "unchanged".
  * `dataProvider` is the provider passed to `withLifecycleCallbacks`, so
  * calling it never re-enters the callbacks.
  */
-export interface LifecycleCallbacks<TResources extends ResourceMap, TRecord extends LooseRecord> {
-    beforeGetList?(params: GetListParams, dataProvider: DataProvider<TResources>): MaybePromise<GetListParams>;
+export interface LifecycleCallbacks<TResources extends ResourceMap, TRecord extends ResourceRecord> extends RecordFreeCallbacks<TResources> {
     afterGetList?(result: GetListResult<TRecord>, dataProvider: DataProvider<TResources>): MaybePromise<GetListResult<TRecord>>;
-    beforeGetOne?(params: GetOneParams, dataProvider: DataProvider<TResources>): MaybePromise<GetOneParams>;
     afterGetOne?(result: GetOneResult<TRecord>, dataProvider: DataProvider<TResources>): MaybePromise<GetOneResult<TRecord>>;
     beforeCreate?(params: CreateParams<TRecord>, dataProvider: DataProvider<TResources>): MaybePromise<CreateParams<TRecord>>;
     afterCreate?(result: CreateResult<TRecord>, dataProvider: DataProvider<TResources>): MaybePromise<CreateResult<TRecord>>;
@@ -19,26 +30,43 @@ export interface LifecycleCallbacks<TResources extends ResourceMap, TRecord exte
     afterUpdate?(result: UpdateResult<TRecord>, dataProvider: DataProvider<TResources>): MaybePromise<UpdateResult<TRecord>>;
     beforeDelete?(params: DeleteParams<TRecord>, dataProvider: DataProvider<TResources>): MaybePromise<DeleteParams<TRecord>>;
     afterDelete?(result: DeleteResult<TRecord>, dataProvider: DataProvider<TResources>): MaybePromise<DeleteResult<TRecord>>;
-    beforeGetMany?(params: GetManyParams, dataProvider: DataProvider<TResources>): MaybePromise<GetManyParams>;
     afterGetMany?(result: GetManyResult<TRecord>, dataProvider: DataProvider<TResources>): MaybePromise<GetManyResult<TRecord>>;
-    beforeGetManyReference?(params: GetManyReferenceParams, dataProvider: DataProvider<TResources>): MaybePromise<GetManyReferenceParams>;
     afterGetManyReference?(result: GetManyReferenceResult<TRecord>, dataProvider: DataProvider<TResources>): MaybePromise<GetManyReferenceResult<TRecord>>;
     beforeUpdateMany?(params: UpdateManyParams<TRecord>, dataProvider: DataProvider<TResources>): MaybePromise<UpdateManyParams<TRecord>>;
-    afterUpdateMany?(result: UpdateManyResult, dataProvider: DataProvider<TResources>): MaybePromise<UpdateManyResult>;
-    beforeDeleteMany?(params: DeleteManyParams, dataProvider: DataProvider<TResources>): MaybePromise<DeleteManyParams>;
-    afterDeleteMany?(result: DeleteManyResult, dataProvider: DataProvider<TResources>): MaybePromise<DeleteManyResult>;
 }
 /**
- * A handler: the callbacks for one registry resource, typed with that
- * resource's record, or for `"*"` (every resource), typed with `LooseRecord`.
+ * The hooks of the `"*"` handler. Each one is generic over the record, so it
+ * hands back the record type it received: the callback runs for every
+ * resource and cannot name one.
  */
-export type LifecycleHandler<TResources extends ResourceMap = ResourceMap> = {
-    [TName in keyof TResources & string]: {
-        resource: TName;
-    } & LifecycleCallbacks<TResources, RecordOf<TResources, TName>>;
-}[keyof TResources & string] | ({
+export interface WildcardCallbacks<TResources extends ResourceMap> extends RecordFreeCallbacks<TResources> {
+    afterGetList?<TRecord extends ResourceRecord>(result: GetListResult<TRecord>, dataProvider: DataProvider<TResources>): MaybePromise<GetListResult<TRecord>>;
+    afterGetOne?<TRecord extends ResourceRecord>(result: GetOneResult<TRecord>, dataProvider: DataProvider<TResources>): MaybePromise<GetOneResult<TRecord>>;
+    beforeCreate?<TRecord extends ResourceRecord>(params: CreateParams<TRecord>, dataProvider: DataProvider<TResources>): MaybePromise<CreateParams<TRecord>>;
+    afterCreate?<TRecord extends ResourceRecord>(result: CreateResult<TRecord>, dataProvider: DataProvider<TResources>): MaybePromise<CreateResult<TRecord>>;
+    beforeUpdate?<TRecord extends ResourceRecord>(params: UpdateParams<TRecord>, dataProvider: DataProvider<TResources>): MaybePromise<UpdateParams<TRecord>>;
+    afterUpdate?<TRecord extends ResourceRecord>(result: UpdateResult<TRecord>, dataProvider: DataProvider<TResources>): MaybePromise<UpdateResult<TRecord>>;
+    beforeDelete?<TRecord extends ResourceRecord>(params: DeleteParams<TRecord>, dataProvider: DataProvider<TResources>): MaybePromise<DeleteParams<TRecord>>;
+    afterDelete?<TRecord extends ResourceRecord>(result: DeleteResult<TRecord>, dataProvider: DataProvider<TResources>): MaybePromise<DeleteResult<TRecord>>;
+    afterGetMany?<TRecord extends ResourceRecord>(result: GetManyResult<TRecord>, dataProvider: DataProvider<TResources>): MaybePromise<GetManyResult<TRecord>>;
+    afterGetManyReference?<TRecord extends ResourceRecord>(result: GetManyReferenceResult<TRecord>, dataProvider: DataProvider<TResources>): MaybePromise<GetManyReferenceResult<TRecord>>;
+    beforeUpdateMany?<TRecord extends ResourceRecord>(params: UpdateManyParams<TRecord>, dataProvider: DataProvider<TResources>): MaybePromise<UpdateManyParams<TRecord>>;
+}
+/** One handler per registry resource, typed with that resource's record. */
+type HandlerMap<TResources extends ResourceMap> = {
+    [N in keyof TResources & string]: {
+        resource: N;
+    } & LifecycleCallbacks<TResources, RecordOf<TResources, N>>;
+};
+type WildcardHandler<TResources extends ResourceMap> = {
     resource: "*";
-} & LifecycleCallbacks<TResources, LooseRecord>);
+} & WildcardCallbacks<TResources>;
+/**
+ * A handler: the callbacks for one registry resource, typed with that
+ * resource's record, or for `"*"` (every resource), which hands back the
+ * record type it receives.
+ */
+export type LifecycleHandler<TResources extends ResourceMap = ResourceMap> = HandlerMap<TResources>[keyof TResources & string] | WildcardHandler<TResources>;
 /**
  * Wraps `dataProvider` with before/after hooks per resource, without touching
  * it. For a call on resource `r`, the handlers whose `resource` is `r` or

package/dist/data/with-lifecycle-callbacks.js

@@ -1,54 +1,68 @@
-const VERBS = [
-  "getList",
-  "getOne",
-  "create",
-  "update",
-  "delete",
-  "getMany",
-  "getManyReference",
-  "updateMany",
-  "deleteMany"
-];
-const capitalize = (verb) => verb.charAt(0).toUpperCase() + verb.slice(1);
+// src/data/with-lifecycle-callbacks.ts
+/**
+* Runs `befores` over `params` in order, calls the provider with the result,
+* then runs `afters` over the provider's result. A rejecting `call` skips the
+* `afters`. With no hooks at all the provider is called directly.
+*/
+function runChain(befores, call, afters, params) {
+	if (befores.length === 0 && afters.length === 0) return call(params);
+	return (async () => {
+		let nextParams = params;
+		for (const before of befores) nextParams = await before(nextParams);
+		let result = await call(nextParams);
+		for (const after of afters) result = await after(result);
+		return result;
+	})();
+}
+/**
+* Wraps `dataProvider` with before/after hooks per resource, without touching
+* it. For a call on resource `r`, the handlers whose `resource` is `r` or
+* `"*"` run in array order: the `before` chain feeds the provider and the
+* `after` chain feeds the caller. A rejecting provider skips the `after`
+* callbacks. A verb with no matching callback calls the provider directly.
+*/
 function withLifecycleCallbacks(dataProvider, handlers) {
-  const loose = handlers;
-  const wrapped = { ...dataProvider };
-  for (const verb of VERBS) {
-    const beforeName = `before${capitalize(verb)}`;
-    const afterName = `after${capitalize(verb)}`;
-    const withBefore = loose.filter((h) => typeof h[beforeName] === "function");
-    const withAfter = loose.filter((h) => typeof h[afterName] === "function");
-    const callProvider = (resource, params) => dataProvider[verb](resource, params);
-    wrapped[verb] = (resource, params) => {
-      const applies = (h) => h.resource === resource || h.resource === "*";
-      const befores = withBefore.filter(applies);
-      const afters = withAfter.filter(applies);
-      if (befores.length === 0 && afters.length === 0) {
-        return callProvider(resource, params);
-      }
-      return (async () => {
-        let nextParams = params;
-        for (const handler of befores) {
-          nextParams = await handler[beforeName].call(
-            handler,
-            nextParams,
-            dataProvider
-          );
-        }
-        let result = await callProvider(resource, nextParams);
-        for (const handler of afters) {
-          result = await handler[afterName].call(
-            handler,
-            result,
-            dataProvider
-          );
-        }
-        return result;
-      })();
-    };
-  }
-  return wrapped;
+	const snapshot = [...handlers];
+	const handlersFor = (resource) => snapshot.filter((h) => h.resource === resource || h.resource === "*");
+	const hook = (handler, callback) => callback ? [(value) => callback.call(handler, value, dataProvider)] : [];
+	return {
+		...dataProvider,
+		getList: (resource, params) => {
+			const matching = handlersFor(resource);
+			return runChain(matching.flatMap((h) => hook(h, h.beforeGetList)), (nextParams) => dataProvider.getList(resource, nextParams), matching.flatMap((h) => hook(h, h.afterGetList)), params);
+		},
+		getOne: (resource, params) => {
+			const matching = handlersFor(resource);
+			return runChain(matching.flatMap((h) => hook(h, h.beforeGetOne)), (nextParams) => dataProvider.getOne(resource, nextParams), matching.flatMap((h) => hook(h, h.afterGetOne)), params);
+		},
+		create: (resource, params) => {
+			const matching = handlersFor(resource);
+			return runChain(matching.flatMap((h) => hook(h, h.beforeCreate)), (nextParams) => dataProvider.create(resource, nextParams), matching.flatMap((h) => hook(h, h.afterCreate)), params);
+		},
+		update: (resource, params) => {
+			const matching = handlersFor(resource);
+			return runChain(matching.flatMap((h) => hook(h, h.beforeUpdate)), (nextParams) => dataProvider.update(resource, nextParams), matching.flatMap((h) => hook(h, h.afterUpdate)), params);
+		},
+		delete: (resource, params) => {
+			const matching = handlersFor(resource);
+			return runChain(matching.flatMap((h) => hook(h, h.beforeDelete)), (nextParams) => dataProvider.delete(resource, nextParams), matching.flatMap((h) => hook(h, h.afterDelete)), params);
+		},
+		getMany: (resource, params) => {
+			const matching = handlersFor(resource);
+			return runChain(matching.flatMap((h) => hook(h, h.beforeGetMany)), (nextParams) => dataProvider.getMany(resource, nextParams), matching.flatMap((h) => hook(h, h.afterGetMany)), params);
+		},
+		getManyReference: (resource, params) => {
+			const matching = handlersFor(resource);
+			return runChain(matching.flatMap((h) => hook(h, h.beforeGetManyReference)), (nextParams) => dataProvider.getManyReference(resource, nextParams), matching.flatMap((h) => hook(h, h.afterGetManyReference)), params);
+		},
+		updateMany: (resource, params) => {
+			const matching = handlersFor(resource);
+			return runChain(matching.flatMap((h) => hook(h, h.beforeUpdateMany)), (nextParams) => dataProvider.updateMany(resource, nextParams), matching.flatMap((h) => hook(h, h.afterUpdateMany)), params);
+		},
+		deleteMany: (resource, params) => {
+			const matching = handlersFor(resource);
+			return runChain(matching.flatMap((h) => hook(h, h.beforeDeleteMany)), (nextParams) => dataProvider.deleteMany(resource, nextParams), matching.flatMap((h) => hook(h, h.afterDeleteMany)), params);
+		}
+	};
 }
-export {
-  withLifecycleCallbacks
-};
+export { withLifecycleCallbacks };