[middleware] Remove didSetRow

Author: jamesgpearce

site/guides/04_using_middleware.md

@@ -33,7 +33,7 @@ console.log(store.getValue('shopName'));
 
 ## Available Callbacks
 
-A Middleware object supports 15 different callbacks that you can register. Each
+A Middleware object supports 14 different callbacks that you can register. Each
 callback is passed relevant parameters for the operation, and can return a
 value. The meaning of this return value depends on the type of callback:
 
@@ -42,9 +42,6 @@ value. The meaning of this return value depends on the type of callback:
   If the function returns undefined (or void), the operation is cancelled.
 * For `willDel*` callbacks, the return value is a boolean that indicates whether
   the delete operation should proceed (true) or be cancelled (false).
-* For `didSetRow`, the return value is the final Row state to apply. Return
-  `newRow` to accept, a different `Row` to replace, `oldRow` to revert, or an
-  empty object to delete. See below for more details.
 
 The full list of `willSet*` callbacks you can register is as follows:
 
@@ -59,15 +56,6 @@ The full list of `willSet*` callbacks you can register is as follows:
 | willSetValue     | valueId, value               | When setValue is called.     | Value or undefined   |
 | willApplyChanges | changes                      | When applyChanges is called. | Changes or undefined |
 
-There is also one special `did*` callback that is called at the end of the
-transaction - after all `will*` callbacks have settled and before any listeners
-are called. This gives you a chance to inspect or validate the final state of a
-Row for a specific table:
-
-| Callback  | Parameters                     | Called                                         | Return |
-| --------- | ------------------------------ | ---------------------------------------------- | ------ |
-| didSetRow | tableId, rowId, oldRow, newRow | After all row changes settle in a transaction. | Row    |
-
 Finally, the full list of `willDel*` callbacks you can register is as follows:
 
 | Callback      | Parameters             | Called                    | Return  |
@@ -199,55 +187,6 @@ console.log(store.getCell('pets', 'fido', 'slug'));
 In the example above, both the original `setCell` call and the listener's
 `setCell` call pass through the uppercase middleware.
 
-## Post-Transaction Row Callback
-
-The `will*` callbacks fire synchronously as each write happens. Sometimes you
-want to inspect or validate a Row *after* all the dust has settled — after every
-cell change in a transaction has been applied and the Row is in its final state.
-That's what `didSetRow` is for.
-
-`addDidSetRowCallback` is **table-scoped**: you register it for a specific
-table, so there is zero overhead for tables you don't care about.
-
-```js
-const store2 = createStore();
-const middleware2 = createMiddleware(store2);
-
-middleware2.addDidSetRowCallback('pets', (tableId, rowId, oldRow, newRow) => {
-  // Require 'species' — revert rows that don't have it
-  return 'species' in newRow ? newRow : oldRow;
-});
-
-store2.setRow('pets', 'fido', {species: 'dog', name: 'Fido'});
-console.log(store2.getRow('pets', 'fido'));
-// -> {species: 'dog', name: 'Fido'}
-
-store2.setRow('pets', 'nemo', {name: 'Nemo'});
-console.log(store2.getRow('pets', 'nemo'));
-// -> {}
-```
-
-The callback receives `oldRow` (the Row as it was at the start of the
-transaction), and `newRow` (the Row as it is now, after all cell writes).
-
-The callback needs to return the Row that should be the final state of the Row
-after any corrections. Return:
-
-- `newRow` to accept the changes.
-- a different `Row` to replace the final state.
-- `oldRow` to revert all changes to the Row.
-- an empty object to delete the Row.
-
-Unlike `willSet*` callbacks, the `didSetRow` chain never short-circuits: all
-registered callbacks for the table always run, each receiving the Row returned
-by the previous one.
-
-Because `didSetRow` fires *after* mutating listeners, `newRow` reflects the
-truly final state of the Row — including any writes those listeners made.
-
-Also note that multiple cell changes to the same Row within one transaction
-produce only one `didSetRow` call, not one per cell.
-
 ## Middleware And Schemas
 
 The callbacks are called after the schema has been applied to the data. So, for

src/@types/middleware/docs.js

@@ -262,43 +262,6 @@
  * @since v8.0.0
  */
 /// WillApplyChangesCallback
-/**
- * The DidSetRowCallback type describes a function called after a Row is changed
- * during a transaction, and after mutator listeners have fired.
- *
- * Unlike the `willSet*` callbacks, which intercept writes as they happen,
- * `didSetRow` fires once per touched Row after all cell writes in the
- * transaction have completed. This means multiple cell changes to the same Row
- * within a single transaction result in just one `didSetRow` call, with the
- * full before-transaction and after-transaction Row states.
- *
- * The callback receives the Table Id, Row Id, the Row as it was at the start of
- * the transaction (`oldRow`), and the Row as it is now (`newRow`). It must
- * return a Row:
- *
- * - `newRow` to accept the changes.
- * - a different `Row` to replace the final state.
- * - `oldRow` to revert all changes to the Row.
- * - an empty object to delete the Row.
- *
- * Multiple DidSetRowCallback functions can be registered for the same table and
- * they will be called sequentially, each receiving the Row returned by the
- * previous callback. The chain never short-circuits: all registered callbacks
- * always run.
- *
- * Note that `addDidSetRowCallback` is table-scoped: you must specify the table
- * Id when registering. Callbacks are only invoked for rows in the specified
- * table, keeping overhead to zero for other tables.
- * @param tableId The Id of the Table containing the changed Row.
- * @param rowId The Id of the Row that was changed.
- * @param oldRow The Row as it was at the start of the transaction.
- * @param newRow The Row as it is now, after all cell writes including those
- * made by mutating listeners.
- * @returns The Row to use as the final state.
- * @category Callback
- * @since v8.0.0
- */
-/// DidSetRowCallback
 /**
  * A Middleware object lets you intercept and validate writes to a Store.
  *
@@ -975,86 +938,6 @@
    * @since v8.0.0
    */
   /// Middleware.addWillApplyChangesCallback
-  /**
-   * The addDidSetRowCallback method registers a DidSetRowCallback for a
-   * specific table that will be called after any Row in that table is changed
-   * during a transaction, after mutator listeners have fired.
-   *
-   * Unlike `willSetRow`, which fires synchronously during each write, this
-   * callback fires once per changed Row after all cell writes in the
-   * transaction have landed. Multiple cell changes to the same Row within a
-   * transaction produce a single callback with the full before/after Row
-   * states.
-   *
-   * The callback receives `oldRow` (the Row at the start of the transaction)
-   * and `newRow` (the Row after all writes). Return `newRow` to accept, a
-   * different `Row` to replace, `oldRow` to revert, or an empty object to
-   * delete.
-   * @param tableId The Id of the Table to watch.
-   * @param callback The DidSetRowCallback to register.
-   * @returns A reference to the Middleware object, for chaining.
-   * @example
-   * This example registers a callback that validates the 'pets' table,
-   * reverting any row that ends up without a required 'species' cell.
-   *
-   * ```js
-   * import {createMiddleware, createStore} from 'tinybase';
-   *
-   * const store = createStore();
-   * const middleware = createMiddleware(store);
-   *
-   * middleware.addDidSetRowCallback(
-   *   'pets',
-   *   (_tableId, _rowId, oldRow, newRow) =>
-   *     'species' in newRow ? newRow : oldRow,
-   * );
-   *
-   * store.setRow('pets', 'fido', {species: 'dog', name: 'Fido'});
-   * console.log(store.getRow('pets', 'fido'));
-   * // -> {species: 'dog', name: 'Fido'}
-   *
-   * store.setRow('pets', 'nemo', {name: 'Nemo'});
-   * console.log(store.getRow('pets', 'nemo'));
-   * // -> {}
-   *
-   * middleware.destroy();
-   * ```
-   * @example
-   * This example shows that multiple cell changes in one transaction result in
-   * a single didSetRow callback with the full before/after row states.
-   *
-   * ```js
-   * import {createMiddleware, createStore} from 'tinybase';
-   *
-   * const store = createStore();
-   * const middleware = createMiddleware(store);
-   *
-   * const seen = [];
-   * middleware.addDidSetRowCallback(
-   *   'pets',
-   *   (_tableId, rowId, oldRow, newRow) => {
-   *     seen.push({rowId, oldRow: {...oldRow}, newRow: {...newRow}});
-   *     return newRow;
-   *   },
-   * );
-   *
-   * store.transaction(() => {
-   *   store.setCell('pets', 'fido', 'name', 'Fido');
-   *   store.setCell('pets', 'fido', 'species', 'dog');
-   * });
-   * console.log(seen.length);
-   * // -> 1
-   * console.log(seen[0].rowId);
-   * // -> 'fido'
-   * console.log(seen[0].newRow);
-   * // -> {name: 'Fido', species: 'dog'}
-   *
-   * middleware.destroy();
-   * ```
-   * @category Configuration
-   * @since v8.0.0
-   */
-  /// Middleware.addDidSetRowCallback
   /**
    * The destroy method should be called when this Middleware object is no
    * longer used. It removes all hooks and listeners from the Store, and

src/@types/middleware/index.d.ts

@@ -77,14 +77,6 @@ export type WillApplyChangesCallback = (
   changes: Changes,
 ) => Changes | undefined;
 
-/// DidSetRowCallback
-export type DidSetRowCallback = (
-  tableId: Id,
-  rowId: Id,
-  oldRow: Row,
-  newRow: Row,
-) => Row;
-
 /// Middleware
 export interface Middleware {
   /// Middleware.getStore
@@ -132,9 +124,6 @@ export interface Middleware {
   /// Middleware.addWillApplyChangesCallback
   addWillApplyChangesCallback(callback: WillApplyChangesCallback): Middleware;
 
-  /// Middleware.addDidSetRowCallback
-  addDidSetRowCallback(tableId: Id, callback: DidSetRowCallback): Middleware;
-
   /// Middleware.destroy
   destroy(): void;
 }

src/@types/middleware/with-schemas/index.d.ts

@@ -149,17 +149,6 @@ export type WillApplyChangesCallback<Schemas extends OptionalSchemas> = (
   changes: Changes<Schemas>,
 ) => Changes<Schemas> | undefined;
 
-/// DidSetRowCallback
-export type DidSetRowCallback<
-  Schema extends OptionalTablesSchema,
-  TableId extends TableIdFromSchema<Schema>,
-> = (
-  tableId: TableId,
-  rowId: Id,
-  oldRow: Row<Schema, TableId>,
-  newRow: Row<Schema, TableId>,
-) => Row<Schema, TableId>;
-
 /// Middleware
 export interface Middleware<in out Schemas extends OptionalSchemas> {
   /// Middleware.getStore
@@ -235,12 +224,6 @@ export interface Middleware<in out Schemas extends OptionalSchemas> {
     callback: WillApplyChangesCallback<Schemas>,
   ): Middleware<Schemas>;
 
-  /// Middleware.addDidSetRowCallback
-  addDidSetRowCallback<TableId extends TableIdFromSchema<Schemas[0]>>(
-    tableId: TableId,
-    callback: DidSetRowCallback<Schemas[0], TableId>,
-  ): Middleware<Schemas>;
-
   /// Middleware.destroy
   destroy(): void;
 }

src/middleware/index.ts

@@ -1,6 +1,5 @@
 import type {Id} from '../@types/common/index.d.ts';
 import type {
-  DidSetRowCallback,
   Middleware,
   WillApplyChangesCallback,
   WillDelCellCallback,
@@ -33,9 +32,8 @@ import type {
 } from '../@types/store/index.d.ts';
 import {arrayEvery, arrayPush, arrayReduce} from '../common/array.ts';
 import {getCreateFunction} from '../common/definable.ts';
-import {IdMap, mapEnsure, mapGet, mapNew} from '../common/map.ts';
 import {objFreeze} from '../common/obj.ts';
-import {ifNotUndefined, isUndefined} from '../common/other.ts';
+import {isUndefined} from '../common/other.ts';
 import {ProtectedStore} from '../store/index.ts';
 
 const reduceCallbacks = (
@@ -81,7 +79,6 @@ export const createMiddleware = getCreateFunction(
     const willDelValuesCallbacks: WillDelValuesCallback[] = [];
     const willDelValueCallbacks: WillDelValueCallback[] = [];
     const willApplyChangesCallbacks: WillApplyChangesCallback[] = [];
-    const didSetRowCallbacksMap: IdMap<DidSetRowCallback[]> = mapNew();
 
     const willSetContent = (content: Content): Content | undefined =>
       reduceCallbacks(willSetContentCallbacks, content);
@@ -128,19 +125,6 @@ export const createMiddleware = getCreateFunction(
     const willApplyChanges = (changes: Changes): Changes | undefined =>
       reduceCallbacks(willApplyChangesCallbacks, changes);
 
-    const didSetRow = (tableId: Id, rowId: Id, oldRow: Row, newRow: Row): Row =>
-      ifNotUndefined(
-        mapGet(didSetRowCallbacksMap, tableId),
-        (callbacks) =>
-          arrayReduce(
-            callbacks,
-            (current: Row, callback) =>
-              callback(tableId, rowId, oldRow, current),
-            newRow,
-          ),
-        () => newRow,
-      ) as Row;
-
     const getStore = (): Store => store;
 
     const addWillSetContentCallback = addCallback(willSetContentCallbacks);
@@ -158,17 +142,6 @@ export const createMiddleware = getCreateFunction(
     const addWillDelValueCallback = addCallback(willDelValueCallbacks);
     const addWillApplyChangesCallback = addCallback(willApplyChangesCallbacks);
 
-    const addDidSetRowCallback = (
-      tableId: Id,
-      callback: DidSetRowCallback,
-    ): Middleware =>
-      fluent(() =>
-        arrayPush(
-          mapEnsure(didSetRowCallbacksMap, tableId, () => []),
-          callback,
-        ),
-      );
-
     const destroy = (): void => {};
 
     const middleware: Middleware = objFreeze({
@@ -187,7 +160,6 @@ export const createMiddleware = getCreateFunction(
       addWillDelValuesCallback,
       addWillDelValueCallback,
       addWillApplyChangesCallback,
-      addDidSetRowCallback,
       destroy,
     } as Middleware);
 
@@ -206,7 +178,6 @@ export const createMiddleware = getCreateFunction(
       willDelValues,
       willDelValue,
       willApplyChanges,
-      didSetRow,
     );
 
     return middleware;