akanjs 3.0.0-beta.2 → 3.0.0-beta.20

package/document/dataLoader.ts

@@ -1,3 +1,4 @@
+import { toError } from "akanjs/common";
 import type { QueryOf } from "akanjs/constant";
 
 type LoaderItem = Record<string, unknown>;
@@ -11,7 +12,8 @@ type BatchLoadFn<Key, Value> = (
 ) => PromiseLike<ReadonlyArray<Value | Error>> | ReadonlyArray<Value | Error>;
 
 interface DataLoaderOptions<Key, CacheKey> {
-  cache?: boolean;
+  /** `false` (default) keeps nothing past its batch, a number keeps a key that many ms, `true` for its whole life. */
+  cache?: boolean | number;
   cacheKeyFn?: (key: Key) => CacheKey;
   batch?: boolean;
   batchScheduleFn?: (callback: () => void) => void;
@@ -25,22 +27,28 @@ interface BatchItem<Key, Value> {
   reject: (reason: unknown) => void;
 }
 
-/** Minimal DataLoader-compatible batch loader used by Akan document resolvers. */
 export class DataLoader<Key, Value, CacheKey = Key> {
+  static readonly #minSweepSize = 1024;
   readonly name?: string;
   readonly #batchLoadFn: BatchLoadFn<Key, Value>;
-  readonly #cache: boolean;
+  readonly #ttl: number;
   readonly #cacheKeyFn: (key: Key) => CacheKey;
   readonly #batch: boolean;
   readonly #batchScheduleFn: (callback: () => void) => void;
   readonly #maxBatchSize: number;
-  readonly #promiseCache = new Map<CacheKey, Promise<Value>>();
+  readonly #promiseCache = new Map<CacheKey, { promise: Promise<Value>; expiresAt: number }>();
+  #sweepAt = DataLoader.#minSweepSize;
   #queue: BatchItem<Key, Value>[] = [];
   #scheduled = false;
 
   constructor(batchLoadFn: BatchLoadFn<Key, Value>, options: DataLoaderOptions<Key, CacheKey> = {}) {
     this.#batchLoadFn = batchLoadFn;
-    this.#cache = options.cache !== false;
+    this.#ttl =
+      options.cache === true
+        ? Number.POSITIVE_INFINITY
+        : typeof options.cache === "number" && options.cache > 0
+          ? options.cache
+          : 0;
     this.#cacheKeyFn = options.cacheKeyFn ?? ((key) => key as unknown as CacheKey);
     this.#batch = options.batch !== false;
     this.#batchScheduleFn = options.batchScheduleFn ?? ((callback) => queueMicrotask(callback));
@@ -50,17 +58,21 @@ export class DataLoader<Key, Value, CacheKey = Key> {
 
   load(key: Key): Promise<Value> {
     const cacheKey = this.#cacheKeyFn(key);
-    if (this.#cache) {
-      const cached = this.#promiseCache.get(cacheKey);
-      if (cached) return cached;
-    }
+    const cached = this.#cached(cacheKey);
+    if (cached) return cached;
 
     const promise = new Promise<Value>((resolve, reject) => {
       this.#queue.push({ key, resolve, reject });
       if (this.#batch) this.#schedule();
       else this.#dispatch();
     });
-    if (this.#cache) this.#promiseCache.set(cacheKey, promise);
+    if (this.#ttl > 0) {
+      this.#remember(cacheKey, promise);
+      
+      promise.catch(() => {
+        if (this.#promiseCache.get(cacheKey)?.promise === promise) this.#promiseCache.delete(cacheKey);
+      });
+    }
     return promise;
   }
 
@@ -80,13 +92,30 @@ export class DataLoader<Key, Value, CacheKey = Key> {
   }
 
   prime(key: Key, value: Value | Error): this {
-    if (!this.#cache) return this;
+    if (this.#ttl <= 0) return this;
     const cacheKey = this.#cacheKeyFn(key);
-    if (this.#promiseCache.has(cacheKey)) return this;
-    this.#promiseCache.set(cacheKey, value instanceof Error ? Promise.reject(value) : Promise.resolve(value));
+    if (this.#cached(cacheKey)) return this;
+    this.#remember(cacheKey, value instanceof Error ? Promise.reject(value) : Promise.resolve(value));
     return this;
   }
 
+  #cached(cacheKey: CacheKey): Promise<Value> | undefined {
+    if (this.#ttl <= 0) return undefined;
+    const entry = this.#promiseCache.get(cacheKey);
+    if (!entry) return undefined;
+    if (entry.expiresAt > Date.now()) return entry.promise;
+    this.#promiseCache.delete(cacheKey);
+    return undefined;
+  }
+
+  #remember(cacheKey: CacheKey, promise: Promise<Value>) {
+    this.#promiseCache.set(cacheKey, { promise, expiresAt: Date.now() + this.#ttl });
+    if (this.#promiseCache.size < this.#sweepAt) return;
+    const now = Date.now();
+    for (const [key, entry] of this.#promiseCache) if (entry.expiresAt <= now) this.#promiseCache.delete(key);
+    this.#sweepAt = Math.max(DataLoader.#minSweepSize, this.#promiseCache.size * 2);
+  }
+
   #schedule() {
     if (this.#scheduled) return;
     this.#scheduled = true;
@@ -103,9 +132,7 @@ export class DataLoader<Key, Value, CacheKey = Key> {
       (values) => {
         if (values.length !== batch.length) {
           const error = new Error(`DataLoader expected ${batch.length} values, received ${values.length}`);
-          batch.forEach(({ reject }) => {
-            reject(error);
-          });
+          for (const { reject } of batch) reject(error);
           return;
         }
         values.forEach((value, index) => {
@@ -114,27 +141,18 @@ export class DataLoader<Key, Value, CacheKey = Key> {
         });
       },
       (error) => {
-        batch.forEach(({ reject }) => {
-          reject(error);
-        });
+        for (const { reject } of batch) reject(error);
       },
     );
   }
 }
 
-function toError(reason: unknown): Error {
-  return reason instanceof Error ? reason : new Error(String(reason));
-}
-
-function keyBy<T>(items: T[], keyOrGetter: keyof T | ((item: T) => unknown)): Record<string, T> {
-  const entries = items.map((item) => {
-    const key = typeof keyOrGetter === "function" ? keyOrGetter(item) : item[keyOrGetter];
-    return [String(key), item] as const;
-  });
-  return Object.fromEntries(entries);
-}
+const keyBy = <T>(items: T[], keyOrGetter: keyof T | ((item: T) => unknown)): Record<string, T> =>
+  Object.fromEntries(
+    items.map((item) => [String(typeof keyOrGetter === "function" ? keyOrGetter(item) : item[keyOrGetter]), item]),
+  );
 
-function groupBy<T>(items: T[], getKey: (item: T) => unknown): Record<string, T[]> {
+const groupBy = <T>(items: T[], getKey: (item: T) => unknown): Record<string, T[]> => {
   const groups: Record<string, T[]> = {};
   for (const item of items) {
     const key = String(getKey(item));
@@ -142,80 +160,61 @@ function groupBy<T>(items: T[], getKey: (item: T) => unknown): Record<string, T[
     groups[key].push(item);
   }
   return groups;
-}
-
-const setQueryOperator = (query: QueryOf<unknown>, fieldName: string, op: "oneOf" | "has", value: unknown) => {
-  (query as QueryRecord)[fieldName] = { kind: "op", op, value };
 };
 
-export const createLoader = <Key, Value>(model: LoaderModel, fieldName = "id", defaultQuery: QueryOf<unknown> = {}) => {
-  return new DataLoader<Key, Value>(
-    (fields) => {
-      const query: QueryOf<unknown> = { ...defaultQuery };
-      setQueryOperator(query, fieldName, "oneOf", fields);
-      const data = Promise.resolve(model.find(query)).then((list) => {
+const findWhere = (model: LoaderModel, query: QueryOf<unknown>, field: string, op: "oneOf" | "has", value: unknown) =>
+  Promise.resolve(model.find({ ...query, [field]: { kind: "op", op, value } }));
+
+export const createLoader = <Key, Value>(model: LoaderModel, fieldName = "id", defaultQuery: QueryOf<unknown> = {}) =>
+  new DataLoader<Key, Value>(
+    (fields) =>
+      findWhere(model, defaultQuery, fieldName, "oneOf", fields).then((list) => {
         const listByKey = keyBy(list, fieldName);
         return fields.map((id: unknown) => listByKey[String(id)] ?? null);
-      });
-      return data as unknown as Promise<Value[]>;
-    },
-    { name: "dataloader", cache: false },
+      }) as unknown as Promise<Value[]>,
+    { name: "dataloader" },
+  );
+export const createArrayLoader = <K, V>(model: LoaderModel, fieldName = "id", defaultQuery: QueryOf<unknown> = {}) =>
+  new DataLoader<K, V>(
+    (fields) =>
+      findWhere(model, defaultQuery, fieldName, "has", fields).then((list) =>
+        fields.map((field) => list.filter((item) => field === item[fieldName])),
+      ) as unknown as Promise<V[]>,
   );
-};
-export const createArrayLoader = <K, V>(model: LoaderModel, fieldName = "id", defaultQuery: QueryOf<unknown> = {}) => {
-  return new DataLoader<K, V>((fields) => {
-    const query: QueryOf<unknown> = { ...defaultQuery };
-    setQueryOperator(query, fieldName, "has", fields);
-    const data = Promise.resolve(model.find(query)).then((list) => {
-      return fields.map((field) => list.filter((item) => field === item[fieldName]));
-    });
-    return data as unknown as Promise<V[]>;
-  });
-};
 export const createArrayElementLoader = <K, V>(
   model: LoaderModel,
   fieldName = "id",
   defaultQuery: QueryOf<unknown> = {},
-) => {
-  return new DataLoader<K, V>(
-    (fields) => {
-      const query: QueryOf<unknown> = { ...defaultQuery };
-      setQueryOperator(query, fieldName, "oneOf", fields);
-      const data = Promise.resolve(model.find(query)).then((list) => {
+) =>
+  new DataLoader<K, V>(
+    (fields) =>
+      findWhere(model, defaultQuery, fieldName, "oneOf", fields).then((list) => {
         const flat: ArrayElementLoaderItem[] = list.flatMap((datum) => {
           const values = Array.isArray(datum[fieldName]) ? datum[fieldName] : [];
-          return values.map((datField: unknown) => ({
-            ...datum,
-            key: datField,
-          }));
+          return values.map((datField: unknown) => ({ ...datum, key: datField }));
         });
         const listByKey = groupBy(flat, (dat) => dat.key);
         return fields.map((id) => listByKey[String(id)] ?? null);
-      });
-      return data as unknown as Promise<V[]>;
-    },
-    { name: "dataloader", cache: false },
+      }) as unknown as Promise<V[]>,
+    { name: "dataloader" },
   );
-};
 
 export const createQueryLoader = <Key, Value>(
   model: LoaderModel,
   queryKeys: string[],
   defaultQuery: QueryOf<unknown> = {},
-) => {
-  return new DataLoader<Key, Value, Key>(
+) =>
+  new DataLoader<Key, Value, Key>(
     (queries) => {
       const query = { kind: "all", queries: [{ kind: "any", queries }, defaultQuery] } as QueryOf<unknown>;
       const getQueryKey = (query: QueryOf<unknown>) =>
         queryKeys.map((key) => String((query as QueryRecord)[key])).join("");
-      const data = Promise.resolve(model.find(query)).then((list) => {
+      return Promise.resolve(model.find(query)).then((list) => {
         const listByKey = keyBy(list, getQueryKey);
         return queries.map((query: QueryOf<unknown>) => listByKey[getQueryKey(query)] ?? null);
-      });
-      return data as unknown as Promise<Value[]>;
+      }) as unknown as Promise<Value[]>;
     },
-    { name: "dataloader", cache: false },
+    { name: "dataloader" },
   );
-};
 
 export type Loader<Field, Value> = DataLoader<Field, Value | null>;

package/document/database.ts

@@ -1,11 +1,11 @@
-import type { MergedValues, PromiseOrObject } from "akanjs/base";
+import type { MergedValues } from "akanjs/base";
 import { Logger } from "akanjs/common";
 import type { DocumentModel, QueryOf } from "akanjs/constant";
-import type { CacheAdaptor, CacheSetOptions } from "akanjs/service";
+import type { CacheAdaptor, CacheSetOptions, CacheValue } from "akanjs/service";
 import type { DataLoader } from "./dataLoader";
 import type { DocumentUpdateInput } from "./documentQuery";
 import type { ExtractQuery, ExtractSort, FilterInstance } from "./filterMeta";
-import type { CRUDEventType, Mdl, SaveEventType, UpdateResult } from "./into";
+import type { Mdl, SaveEventListener, SaveEventType, UpdateResult } from "./into";
 import type { DataInputOf, FindQueryOption, ListQueryOption } from "./types";
 
 export class CacheDatabase<T = unknown> {
@@ -16,21 +16,53 @@ export class CacheDatabase<T = unknown> {
   ) {
     this.logger = new Logger(`${refName}Cache`);
   }
-  async set(topic: string, key: string, value: string | number | Buffer, option: CacheSetOptions = {}) {
+  async set(topic: string, key: string, value: CacheValue, option: CacheSetOptions = {}) {
     await this.cache.set(this.refName, `${topic}:${key}`, value, option);
   }
-  async get<T extends string | number | Buffer>(topic: string, key: string): Promise<T | undefined> {
+  async get<T extends CacheValue = CacheValue>(topic: string, key: string): Promise<T | undefined> {
     return await this.cache.get<T>(this.refName, `${topic}:${key}`);
   }
   async delete(topic: string, key: string) {
     await this.cache.delete(this.refName, `${topic}:${key}`);
   }
+  async getDel<T extends CacheValue = CacheValue>(topic: string, key: string): Promise<T | undefined> {
+    return await this.cache.getDel<T>(this.refName, `${topic}:${key}`);
+  }
+  async setIfAbsent(topic: string, key: string, value: CacheValue, option: CacheSetOptions = {}) {
+    return await this.cache.setIfAbsent(this.refName, `${topic}:${key}`, value, option);
+  }
+  async incr(topic: string, key: string, by = 1, option: CacheSetOptions = {}) {
+    return await this.cache.incr(this.refName, `${topic}:${key}`, by, option);
+  }
+  async hset(topic: string, key: string, subKey: string, value: CacheValue, option: CacheSetOptions = {}) {
+    await this.cache.hset(this.refName, `${topic}:${key}`, subKey, value, option);
+  }
+  async hget<T extends CacheValue = CacheValue>(topic: string, key: string, subKey: string): Promise<T | undefined> {
+    return await this.cache.hget<T>(this.refName, `${topic}:${key}`, subKey);
+  }
+  async hdelete(topic: string, key: string, subKey: string) {
+    await this.cache.hdelete(this.refName, `${topic}:${key}`, subKey);
+  }
+  async hkeys(topic: string, key: string) {
+    return await this.cache.hkeys(this.refName, `${topic}:${key}`);
+  }
+  async hentries<T extends CacheValue = CacheValue>(topic: string, key: string): Promise<[string, T][]> {
+    return await this.cache.hentries<T>(this.refName, `${topic}:${key}`);
+  }
+  async hclear(topic: string, key: string) {
+    await this.cache.hclear(this.refName, `${topic}:${key}`);
+  }
+  async hgetDel<T extends CacheValue = CacheValue>(topic: string, key: string, subKey: string): Promise<T | undefined> {
+    return await this.cache.hgetDel<T>(this.refName, `${topic}:${key}`, subKey);
+  }
+  async hsetIfAbsent(topic: string, key: string, subKey: string, value: CacheValue, option: CacheSetOptions = {}) {
+    return await this.cache.hsetIfAbsent(this.refName, `${topic}:${key}`, subKey, value, option);
+  }
+  async hincr(topic: string, key: string, subKey: string, by = 1, option: CacheSetOptions = {}) {
+    return await this.cache.hincr(this.refName, `${topic}:${key}`, subKey, by, option);
+  }
 }
-/**
- * What `update<Filter>` returns. The patch cannot be a trailing parameter — a filter's own args may be optional,
- * and no tuple type puts a required element after those — and leading it reads backwards. So it lands here, on a
- * terminal `.set()` that mirrors the `UPDATE … SET …` it compiles to.
- */
+/** What `update<Filter>` returns: the patch cannot trail a filter's optional args, so it lands on `.set()`. */
 export interface UpdateChain<Doc = any> {
   set(update: DocumentUpdateInput<Doc>): Promise<UpdateResult>;
 }
@@ -98,14 +130,14 @@ export type QueryMethodPart<
   _ListQueryOption = ListQueryOption<Sort, Obj>,
   _QueryOfDoc = QueryOf<Doc>,
 > = MergedValues<QueryMethodMap<Query, Doc, Insight, _FindQueryOption, _ListQueryOption, _QueryOfDoc>>;
-type DatabaseModelWithQuerySort<
-  T extends string,
-  Input,
-  Doc,
-  Obj,
-  Insight,
-  Query,
-  Sort,
+export type DatabaseInstanceWithQuerySort<
+  T extends string = string,
+  Input = any,
+  Doc = any,
+  Obj = any,
+  Insight = any,
+  Query = ExtractQuery<FilterInstance>,
+  Sort = ExtractSort<FilterInstance>,
   _CapitalizedRefName extends string = Capitalize<T>,
   _QueryOfDoc = QueryOf<Doc>,
   _DocumentObj = DocumentModel<Obj>,
@@ -137,14 +169,8 @@ type DatabaseModelWithQuerySort<
   __count(query: _QueryOfDoc): Promise<number>;
   __insight(query: _QueryOfDoc): Promise<Insight>;
   clone(data: _DataInput & { id: string }): Promise<Doc>;
-  listenPre: (
-    type: SaveEventType,
-    listener: (doc: Doc, type: CRUDEventType, previous?: Doc) => PromiseOrObject<void>,
-  ) => () => void;
-  listenPost: (
-    type: SaveEventType,
-    listener: (doc: Doc, type: CRUDEventType, previous?: Doc) => PromiseOrObject<void>,
-  ) => () => void;
+  listenPre: (type: SaveEventType, listener: SaveEventListener<Doc>) => () => void;
+  listenPost: (type: SaveEventType, listener: SaveEventListener<Doc>) => () => void;
 } & {
   [key in _CapitalizedRefName]: Mdl<Doc, Obj, _DocumentObj>;
 } & {
@@ -165,36 +191,6 @@ type DatabaseModelWithQuerySort<
   [K in `remove${_CapitalizedRefName}`]: (id: string) => Promise<Doc>;
 } & QueryMethodPart<Query, Sort, Obj, Doc, Insight, _FindQueryOption, _ListQueryOption, _QueryOfDoc>;
 
-export type DatabaseInstanceWithQuerySort<
-  T extends string = string,
-  Input = any,
-  Doc = any,
-  Obj = any,
-  Insight = any,
-  Query = ExtractQuery<FilterInstance>,
-  Sort = ExtractSort<FilterInstance>,
-  _CapitalizedRefName extends string = Capitalize<T>,
-  _QueryOfDoc = QueryOf<Doc>,
-  _DocumentObj = DocumentModel<Obj>,
-  _DataInput = DataInputOf<Input, _DocumentObj>,
-  _FindQueryOption = FindQueryOption<Sort, Obj>,
-  _ListQueryOption = ListQueryOption<Sort, Obj>,
-> = DatabaseModelWithQuerySort<
-  T,
-  Input,
-  Doc,
-  Obj,
-  Insight,
-  Query,
-  Sort,
-  _CapitalizedRefName,
-  _QueryOfDoc,
-  _DocumentObj,
-  _DataInput,
-  _FindQueryOption,
-  _ListQueryOption
->;
-
 export type DatabaseInstance<
   T extends string = string,
   Input = any,

package/document/documentQuery.ts

@@ -1,4 +1,5 @@
 import { type Dayjs, dayjs } from "akanjs/base";
+import { isValidDate } from "akanjs/common";
 
 export type DocumentId = string & { readonly __brand: "DocumentId" };
 
@@ -43,24 +44,7 @@ export type DocumentQueryNode =
 /** The four real SQL columns. Everything else lives inside `_doc`, which is what makes the two compile differently. */
 export const baseDocumentColumns = new Set(["id", "createdAt", "updatedAt", "removedAt"]);
 
-export type DocumentQueryOperator =
-  | "eq"
-  | "ne"
-  | "oneOf"
-  | "notOneOf"
-  | "gt"
-  | "gte"
-  | "lt"
-  | "lte"
-  | "between"
-  | "exists"
-  | "missing"
-  | "empty"
-  | "has"
-  | "contains";
-
-/** The operator-object shorthand's keys: `{ status: { oneOf: [...] } }` reaches the same operators as `q.oneOf`. */
-export const queryOperatorKeys = new Set<string>([
+const documentQueryOperators = [
   "eq",
   "ne",
   "oneOf",
@@ -75,7 +59,11 @@ export const queryOperatorKeys = new Set<string>([
   "empty",
   "has",
   "contains",
-]);
+] as const;
+export type DocumentQueryOperator = (typeof documentQueryOperators)[number];
+
+/** The operator-object shorthand's keys: `{ status: { oneOf: [...] } }` reaches the same operators as `q.oneOf`. */
+export const queryOperatorKeys = new Set<string>(documentQueryOperators);
 
 export type DocumentQueryValue =
   | DocumentPrimitive
@@ -157,16 +145,16 @@ export interface SqlFragment {
 }
 
 const op = (op: DocumentQueryOperator, value?: unknown): DocumentQueryNode => ({ kind: "op", op, value });
+const group =
+  (kind: "all" | "any") =>
+  (...queries: (DocumentQuery | null | undefined | false)[]): DocumentQueryNode => ({
+    kind,
+    queries: queries.filter(Boolean) as DocumentQuery[],
+  });
 
 export const createDocumentQueryHelper = () => ({
-  all: (...queries: (DocumentQuery | null | undefined | false)[]): DocumentQueryNode => ({
-    kind: "all",
-    queries: queries.filter(Boolean) as DocumentQuery[],
-  }),
-  any: (...queries: (DocumentQuery | null | undefined | false)[]): DocumentQueryNode => ({
-    kind: "any",
-    queries: queries.filter(Boolean) as DocumentQuery[],
-  }),
+  all: group("all"),
+  any: group("any"),
   not: (query: DocumentQuery): DocumentQueryNode => ({ kind: "not", query }),
   eq: (value: unknown) => op("eq", value),
   ne: (value: unknown) => op("ne", value),
@@ -184,7 +172,7 @@ export const createDocumentQueryHelper = () => ({
   has: (value: unknown) => op("has", value),
   contains: (value: unknown) => op("contains", value),
   raw: (sql: string, params: unknown[] = []): DocumentQueryNode => ({ kind: "raw", sql, params }),
-
+  
   search: (text: string, options: DocumentSearchOptions = {}): DocumentQueryNode => ({
     kind: "search",
     text,
@@ -198,8 +186,7 @@ export type DocumentQueryHelper = ReturnType<typeof createDocumentQueryHelper>;
 export const documentQueryHelper = createDocumentQueryHelper();
 
 export const encodeDocumentValue = (value: unknown): unknown => {
-  if (value === undefined) return undefined;
-  if (value === null) return null;
+  if (value === undefined || value === null) return value;
   if (dayjs.isDayjs(value)) return value.valueOf();
   if (value instanceof Date) return value.getTime();
   if (Array.isArray(value)) return value.map(encodeDocumentValue);
@@ -208,8 +195,7 @@ export const encodeDocumentValue = (value: unknown): unknown => {
 };
 
 export const sanitizeJson = (value: unknown): unknown => {
-  if (value === undefined) return undefined;
-  if (value === null) return null;
+  if (value === undefined || value === null) return value;
   if (dayjs.isDayjs(value)) return value.valueOf();
   if (value instanceof Date) return value.getTime();
   if (value instanceof Map)
@@ -225,3 +211,17 @@ export const sanitizeJson = (value: unknown): unknown => {
   });
   return Object.fromEntries(entries);
 };
+
+const convertOperatorValue = (value: unknown): unknown => {
+  if (Array.isArray(value)) return value.map((v) => convertOperatorValue(v));
+  if (!value) return value;
+  if (isValidDate(value as Date)) return dayjs(value as Date).valueOf();
+  if (typeof value !== "object" || value.constructor !== Object) return value;
+  return Object.fromEntries(
+    Object.entries(value as Record<string, unknown>).map(([key, value]) => [key, convertOperatorValue(value)]),
+  );
+};
+export const convertAggregateMatch = (query: unknown) =>
+  Object.fromEntries(
+    Object.entries(query as Record<string, unknown>).map(([key, value]) => [key, convertOperatorValue(value)]),
+  );

package/document/documentSchema.ts

@@ -20,13 +20,7 @@ export interface DocumentIndexBuilder<Schema> {
   done(): Schema;
 }
 
-/**
- * `previous` is the document as it was before this write, and is absent on a create.
- *
- * A hook that has to answer "did this leave the set it was in" cannot do it from the new value alone — a soft
- * delete and a field edit that moves a row out of a filter both look like an ordinary document afterwards. It is a
- * trailing optional parameter, so a listener that ignores it is unaffected.
- */
+/** `previous` is the document before this write (absent on a create), for a hook asking whether it left a set. */
 export type DocumentSaveHook<Doc = unknown> = (
   this: Doc,
   next?: () => void,
@@ -40,35 +34,34 @@ export class DocumentSchema<Doc = unknown> {
   readonly indexes: DocumentIndexDescriptor[] = [];
 
   pre<HookDoc = Doc>(type: SaveEventType, hook: DocumentSaveHook<HookDoc>) {
-    const hooks = this.preHooks.get(type) ?? [];
-    hooks.push(hook as unknown as DocumentSaveHook<Doc>);
-    this.preHooks.set(type, hooks);
-    return this;
+    return this.#add(this.preHooks, type, hook);
   }
 
   post<HookDoc = Doc>(type: SaveEventType, hook: DocumentSaveHook<HookDoc>) {
-    const hooks = this.postHooks.get(type) ?? [];
-    hooks.push(hook as unknown as DocumentSaveHook<Doc>);
-    this.postHooks.set(type, hooks);
-    return this;
+    return this.#add(this.postHooks, type, hook);
   }
 
   removePre<HookDoc = Doc>(type: SaveEventType, hook: DocumentSaveHook<HookDoc>) {
-    const hooks = this.preHooks.get(type);
-    if (hooks)
-      this.preHooks.set(
-        type,
-        hooks.filter((registered) => registered !== (hook as unknown)),
-      );
-    return this;
+    return this.#remove(this.preHooks, type, hook);
   }
 
   removePost<HookDoc = Doc>(type: SaveEventType, hook: DocumentSaveHook<HookDoc>) {
-    const hooks = this.postHooks.get(type);
-    if (hooks)
-      this.postHooks.set(
+    return this.#remove(this.postHooks, type, hook);
+  }
+
+  #add(hooks: Map<SaveEventType, DocumentSaveHook<Doc>[]>, type: SaveEventType, hook: unknown) {
+    const list = hooks.get(type) ?? [];
+    list.push(hook as DocumentSaveHook<Doc>);
+    hooks.set(type, list);
+    return this;
+  }
+
+  #remove(hooks: Map<SaveEventType, DocumentSaveHook<Doc>[]>, type: SaveEventType, hook: unknown) {
+    const list = hooks.get(type);
+    if (list)
+      hooks.set(
         type,
-        hooks.filter((registered) => registered !== (hook as unknown)),
+        list.filter((registered) => registered !== hook),
       );
     return this;
   }
@@ -111,3 +104,5 @@ export class DocumentSchema<Doc = unknown> {
 }
 
 export type SchemaOf<Mdl = unknown, Doc = unknown> = DocumentSchema<Doc> & { readonly __model?: Mdl };
+
+export const getDefaultSchemaOptions = <TSchema, TDocument>() => new DocumentSchema<TDocument>();