tinybase 1.0.4 → 1.0.5

package/lib/checkpoints.d.ts

@@ -33,6 +33,20 @@ import {Store} from './store.d';
  */
 export type CheckpointIds = [Ids, Id | undefined, Ids];
 
+/**
+ * The CheckpointCallback type describes a function that takes a Checkpoint's
+ * Id.
+ *
+ * A CheckpointCallback is provided when using the forEachCheckpoint method,
+ * so that you can do something based on every Checkpoint in the Checkpoints
+ * object. See that method for specific examples.
+ *
+ * @param checkpointId The Id of the Checkpoint that the callback can operate
+ * on.
+ * @category Callback
+ */
+export type CheckpointCallback = (checkpointId: Id, label?: string) => void;
+
 /**
  * The CheckpointIdsListener type describes a function that is used to listen to
  * changes to the checkpoint Ids in a Checkpoints object.
@@ -353,6 +367,36 @@ export interface Checkpoints {
    */
   getCheckpointIds(): CheckpointIds;
 
+  /**
+   * The forEachCheckpoint method takes a function that it will then call for
+   * each Checkpoint in a specified Checkpoints object.
+   *
+   * This method is useful for iterating over the structure of the Checkpoints
+   * object in a functional style. The `checkpointCallback` parameter is a
+   * CheckpointCallback function that will be called with the Id of each
+   * Checkpoint.
+   *
+   * @param checkpointCallback The function that should be called for every
+   * Checkpoint.
+   * @example
+   * This example iterates over each Checkpoint in a Checkpoints object.
+   *
+   * ```js
+   * const store = createStore().setTables({pets: {fido: {sold: false}}});
+   * const checkpoints = createCheckpoints(store);
+   * store.setCell('pets', 'fido', 'sold', true);
+   * checkpoints.addCheckpoint('sale');
+   *
+   * checkpoints.forEachCheckpoint((checkpointId, label) => {
+   *   console.log(`${checkpointId}:${label}`);
+   * });
+   * // -> '0:'
+   * // -> '1:sale'
+   * ```
+   * @category Iterator
+   */
+  forEachCheckpoint(checkpointCallback: CheckpointCallback): void;
+
   /**
    * The hasCheckpoint method returns a boolean indicating whether a given
    * Checkpoint exists in the Checkpoints object.

package/lib/checkpoints.js

@@ -1 +1 @@
-const e=(e,t)=>e.includes(t),t=(e,t)=>e.forEach(t),n=e=>e.length,s=e=>0==n(e),o=e=>e.slice(1),r=e=>null==e,l=(e,t,n)=>r(e)?n?.():t(e),c=(e,t)=>e?.has(t)??!1,i=e=>r(e)||0==(e=>e.size)(e),d=(e,t)=>e?.forEach(t),a=(e,t)=>e?.delete(t),p=e=>new Map(e),h=(e,t)=>e?.get(t),u=(e,t,n)=>r(n)?(a(e,t),e):e?.set(t,n),g=(e,t,n,s)=>(c(e,t)||(s?.(n),e.set(t,n)),h(e,t)),C=e=>new Set(e),k=(e,t,r)=>n(r)<2?((e,t)=>e?.add(t))(s(r)?e:g(e,r[0],C()),t):k(g(e,r[0],p()),t,o(r)),f=e=>{const n=(r,c,...i)=>l(r,(r=>s(i)?e(r,c):t([i[0],null],(e=>n(h(r,e),c,...o(i))))));return n},L=Object.freeze,w=(e=>{const t=new WeakMap;return n=>(t.has(n)||t.set(n,e(n)),t.get(n))})((o=>{let w,v,S,z=100,E=p(),I=1;const M=C(),b=p(),[j,x,y]=(e=>{let s,o=0;const c=[],i=p();return[(t,n,r=[])=>{s??=e();const l=c.pop()??""+o++;return u(i,l,[t,n,r]),k(n,l,r),l},(e,t=[],...n)=>f(d)(e,(e=>l(h(i,e),(([e])=>e(s,...t,...n)))),...t),e=>l(h(i,e),(([,t,s])=>(f(a)(t,e,...s),u(i,e),n(c)<1e3&&c.push(e),s)),(()=>[])),(e,o,c)=>l(h(i,e),(([e,,l])=>{const i=(...d)=>{const a=n(d);a==n(l)?e(s,...d,...c(d)):r(l[a])?t(o[a](...d),(e=>i(...d,e))):i(...d,l[a])};i()}))]})((()=>R)),B=p(),F=p(),O=[],T=[],W=(e,t)=>{I=0,o.transaction((()=>d(h(B,t),((t,n)=>d(t,((t,s)=>d(t,((t,l)=>r(t[e])?o.delCell(n,s,l,!0):o.setCell(n,s,l,t[e]))))))))),I=1},m=e=>{u(B,e),u(F,e),x(b,[e])},q=(e,s)=>t(((e,t)=>e.splice(0,t))(e,s??n(e)),m),A=()=>q(O,n(O)-z),D=o.addCellListener(null,null,null,((e,t,n,s,o,r)=>{if(I){l(w,(()=>{O.push(w),A(),q(T),w=void 0,S=1}));const e=g(E,t,p()),c=g(e,n,p()),d=g(c,s,[void 0,void 0],(e=>e[0]=r));d[1]=o,d[0]===d[1]&&i(u(c,s))&&i(u(e,n))&&i(u(E,t))&&(w=O.pop(),S=1),K()}})),G=(e="")=>(r(w)&&(w=""+v++,u(B,w,E),P(w,e),E=p(),S=1),w),H=()=>{s(O)||(T.unshift(G()),W(0,w),w=O.pop(),S=1)},J=()=>{s(T)||(O.push(w),w=T.shift(),W(1,w),S=1)},K=()=>{S&&(x(M),S=0)},N=e=>{const t=G(e);return K(),t},P=(e,t)=>(Q(e)&&h(F,e)!==t&&(u(F,e,t),x(b,[e])),R),Q=e=>c(B,e),R={setSize:e=>(z=e,A(),R),addCheckpoint:N,setCheckpoint:P,getStore:()=>o,getCheckpointIds:()=>[[...O],w,[...T]],hasCheckpoint:Q,getCheckpoint:e=>h(F,e),goBackward:()=>(H(),K(),R),goForward:()=>(J(),K(),R),goTo:t=>{const n=e(O,t)?H:e(T,t)?J:null;for(;!r(n)&&t!=w;)n();return K(),R},addCheckpointIdsListener:e=>j(e,M),addCheckpointListener:(e,t)=>j(t,b,[e]),delListener:e=>(y(e),R),clear:()=>(q(O),q(T),r(w)||m(w),w=void 0,v=0,N(),R),destroy:()=>{o.delListener(D)},getListenerStats:()=>({})};return L(R.clear())}));export{w as createCheckpoints};
+const e=(e,t)=>e.includes(t),t=(e,t)=>e.forEach(t),n=e=>e.length,s=e=>0==n(e),o=e=>e.slice(1),r=e=>null==e,c=(e,t,n)=>r(e)?n?.():t(e),l=(e,t)=>e?.has(t)??!1,i=e=>r(e)||0==(e=>e.size)(e),d=(e,t)=>e?.forEach(t),a=(e,t)=>e?.delete(t),p=e=>new Map(e),h=(e,t)=>e?.get(t),u=(e,t,n)=>r(n)?(a(e,t),e):e?.set(t,n),C=(e,t,n,s)=>(l(e,t)||(s?.(n),e.set(t,n)),h(e,t)),g=e=>new Set(e),k=(e,t,r)=>n(r)<2?((e,t)=>e?.add(t))(s(r)?e:C(e,r[0],g()),t):k(C(e,r[0],p()),t,o(r)),f=e=>{const n=(r,l,...i)=>c(r,(r=>s(i)?e(r,l):t([i[0],null],(e=>n(h(r,e),l,...o(i))))));return n},L=Object.freeze,v=(e=>{const t=new WeakMap;return n=>(t.has(n)||t.set(n,e(n)),t.get(n))})((o=>{let v,w,S,z=100,E=p(),I=1;const M=g(),b=p(),[j,x,y]=(e=>{let s,o=0;const l=[],i=p();return[(t,n,r=[])=>{s??=e();const c=l.pop()??""+o++;return u(i,c,[t,n,r]),k(n,c,r),c},(e,t=[],...n)=>f(d)(e,(e=>c(h(i,e),(([e])=>e(s,...t,...n)))),...t),e=>c(h(i,e),(([,t,s])=>(f(a)(t,e,...s),u(i,e),n(l)<1e3&&l.push(e),s)),(()=>[])),(e,o,l)=>c(h(i,e),(([e,,c])=>{const i=(...d)=>{const a=n(d);a==n(c)?e(s,...d,...l(d)):r(c[a])?t(o[a](...d),(e=>i(...d,e))):i(...d,c[a])};i()}))]})((()=>R)),B=p(),F=p(),O=[],T=[],W=(e,t)=>{I=0,o.transaction((()=>d(h(B,t),((t,n)=>d(t,((t,s)=>d(t,((t,c)=>r(t[e])?o.delCell(n,s,c,!0):o.setCell(n,s,c,t[e]))))))))),I=1},m=e=>{u(B,e),u(F,e),x(b,[e])},q=(e,s)=>t(((e,t)=>e.splice(0,t))(e,s??n(e)),m),A=()=>q(O,n(O)-z),D=o.addCellListener(null,null,null,((e,t,n,s,o,r)=>{if(I){c(v,(()=>{O.push(v),A(),q(T),v=void 0,S=1}));const e=C(E,t,p()),l=C(e,n,p()),d=C(l,s,[void 0,void 0],(e=>e[0]=r));d[1]=o,d[0]===d[1]&&i(u(l,s))&&i(u(e,n))&&i(u(E,t))&&(v=O.pop(),S=1),K()}})),G=(e="")=>(r(v)&&(v=""+w++,u(B,v,E),P(v,e),E=p(),S=1),v),H=()=>{s(O)||(T.unshift(G()),W(0,v),v=O.pop(),S=1)},J=()=>{s(T)||(O.push(v),v=T.shift(),W(1,v),S=1)},K=()=>{S&&(x(M),S=0)},N=e=>{const t=G(e);return K(),t},P=(e,t)=>(Q(e)&&h(F,e)!==t&&(u(F,e,t),x(b,[e])),R),Q=e=>l(B,e),R={setSize:e=>(z=e,A(),R),addCheckpoint:N,setCheckpoint:P,getStore:()=>o,getCheckpointIds:()=>[[...O],v,[...T]],forEachCheckpoint:e=>{return t=e,d(F,((e,n)=>t(n,e)));var t},hasCheckpoint:Q,getCheckpoint:e=>h(F,e),goBackward:()=>(H(),K(),R),goForward:()=>(J(),K(),R),goTo:t=>{const n=e(O,t)?H:e(T,t)?J:null;for(;!r(n)&&t!=v;)n();return K(),R},addCheckpointIdsListener:e=>j(e,M),addCheckpointListener:(e,t)=>j(t,b,[e]),delListener:e=>(y(e),R),clear:()=>(q(O),q(T),r(v)||m(v),v=void 0,w=0,N(),R),destroy:()=>{o.delListener(D)},getListenerStats:()=>({})};return L(R.clear())}));export{v as createCheckpoints};

package/lib/debug/checkpoints.d.ts

@@ -33,6 +33,20 @@ import {Store} from './store.d';
  */
 export type CheckpointIds = [Ids, Id | undefined, Ids];
 
+/**
+ * The CheckpointCallback type describes a function that takes a Checkpoint's
+ * Id.
+ *
+ * A CheckpointCallback is provided when using the forEachCheckpoint method,
+ * so that you can do something based on every Checkpoint in the Checkpoints
+ * object. See that method for specific examples.
+ *
+ * @param checkpointId The Id of the Checkpoint that the callback can operate
+ * on.
+ * @category Callback
+ */
+export type CheckpointCallback = (checkpointId: Id, label?: string) => void;
+
 /**
  * The CheckpointIdsListener type describes a function that is used to listen to
  * changes to the checkpoint Ids in a Checkpoints object.
@@ -353,6 +367,36 @@ export interface Checkpoints {
    */
   getCheckpointIds(): CheckpointIds;
 
+  /**
+   * The forEachCheckpoint method takes a function that it will then call for
+   * each Checkpoint in a specified Checkpoints object.
+   *
+   * This method is useful for iterating over the structure of the Checkpoints
+   * object in a functional style. The `checkpointCallback` parameter is a
+   * CheckpointCallback function that will be called with the Id of each
+   * Checkpoint.
+   *
+   * @param checkpointCallback The function that should be called for every
+   * Checkpoint.
+   * @example
+   * This example iterates over each Checkpoint in a Checkpoints object.
+   *
+   * ```js
+   * const store = createStore().setTables({pets: {fido: {sold: false}}});
+   * const checkpoints = createCheckpoints(store);
+   * store.setCell('pets', 'fido', 'sold', true);
+   * checkpoints.addCheckpoint('sale');
+   *
+   * checkpoints.forEachCheckpoint((checkpointId, label) => {
+   *   console.log(`${checkpointId}:${label}`);
+   * });
+   * // -> '0:'
+   * // -> '1:sale'
+   * ```
+   * @category Iterator
+   */
+  forEachCheckpoint(checkpointCallback: CheckpointCallback): void;
+
   /**
    * The hasCheckpoint method returns a boolean indicating whether a given
    * Checkpoint exists in the Checkpoints object.

package/lib/debug/checkpoints.js

@@ -22,6 +22,8 @@ const collDel = (coll, keyOrValue) => coll?.delete(keyOrValue);
 
 const mapNew = (entries) => new Map(entries);
 const mapGet = (map, key) => map?.get(key);
+const mapForEach = (map, cb) =>
+  collForEach(map, (value, key) => cb(key, value));
 const mapSet = (map, key, value) =>
   isUndefined(value) ? (collDel(map, key), map) : map?.set(key, value);
 const mapEnsure = (map, key, defaultValue, onWillAdd) => {
@@ -251,6 +253,8 @@ const createCheckpoints = getCreateFunction((store) => {
   };
   const getStore = () => store;
   const getCheckpointIds = () => [[...backwardIds], currentId, [...forwardIds]];
+  const forEachCheckpoint = (checkpointCallback) =>
+    mapForEach(labels, checkpointCallback);
   const hasCheckpoint = (checkpointId) => collHas(deltas, checkpointId);
   const getCheckpoint = (checkpointId) => mapGet(labels, checkpointId);
   const goBackward = () => {
@@ -307,6 +311,7 @@ const createCheckpoints = getCreateFunction((store) => {
     setCheckpoint,
     getStore,
     getCheckpointIds,
+    forEachCheckpoint,
     hasCheckpoint,
     getCheckpoint,
     goBackward,

package/lib/debug/indexes.d.ts

@@ -11,7 +11,7 @@
  * @module indexes
  */
 
-import {GetCell, Store} from './store.d';
+import {GetCell, RowCallback, Store} from './store.d';
 import {Id, IdOrNull, Ids, SortKey} from './common.d';
 
 /**
@@ -43,6 +43,42 @@ export type Index = {[sliceId: Id]: Slice};
  */
 export type Slice = Ids;
 
+/**
+ * The IndexCallback type describes a function that takes an Index's Id and a
+ * callback to loop over each Slice within it.
+ *
+ * A IndexCallback is provided when using the forEachIndex method, so that you
+ * can do something based on every Index in the Indexes object. See that method
+ * for specific examples.
+ *
+ * @param indexId The Id of the Index that the callback can operate on.
+ * @param forEachRow A function that will let you iterate over the Slice objects
+ * in this Index.
+ * @category Callback
+ */
+export type IndexCallback = (
+  indexId: Id,
+  forEachSlice: (sliceCallback: SliceCallback) => void,
+) => void;
+
+/**
+ * The SliceCallback type describes a function that takes a Slice's Id and a
+ * callback to loop over each Row within it.
+ *
+ * A SliceCallback is provided when using the forEachSlice method, so that you
+ * can do something based on every Slice in an Index. See that method for
+ * specific examples.
+ *
+ * @param sliceId The Id of the Slice that the callback can operate on.
+ * @param forEachRow A function that will let you iterate over the Row objects
+ * in this Slice.
+ * @category Callback
+ */
+export type SliceCallback = (
+  sliceId: Id,
+  forEachRow: (rowCallback: RowCallback) => void,
+) => void;
+
 /**
  * The SliceIdsListener type describes a function that is used to listen to
  * changes to the Slice Ids in an Index.
@@ -362,6 +398,83 @@ export interface Indexes {
    */
   getIndexIds(): Ids;
 
+  /**
+   * The forEachIndex method takes a function that it will then call for each
+   * Index in a specified Indexes object.
+   *
+   * This method is useful for iterating over the structure of the Indexes
+   * object in a functional style. The `indexCallback` parameter is a
+   * IndexCallback function that will be called with the Id of each Index, and
+   * with a function that can then be used to iterate over each Slice of the
+   * Index, should you wish.
+   *
+   * @param indexCallback The function that should be called for every Index.
+   * @example
+   * This example iterates over each Index in an Indexes object, and lists each
+   * Slice Id within them.
+   *
+   * ```js
+   * const store = createStore().setTable('pets', {
+   *   fido: {species: 'dog', color: 'brown'},
+   *   felix: {species: 'cat', color: 'black'},
+   *   cujo: {species: 'dog', color: 'black'},
+   * });
+   * const indexes = createIndexes(store)
+   *   .setIndexDefinition('bySpecies', 'pets', 'species')
+   *   .setIndexDefinition('byColor', 'pets', 'color');
+   *
+   * indexes.forEachIndex((indexId, forEachSlice) => {
+   *   console.log(indexId);
+   *   forEachSlice((sliceId) => console.log(`- ${sliceId}`));
+   * });
+   * // -> 'bySpecies'
+   * // -> '- dog'
+   * // -> '- cat'
+   * // -> 'byColor'
+   * // -> '- brown'
+   * // -> '- black'
+   * ```
+   * @category Iterator
+   */
+  forEachIndex(indexCallback: IndexCallback): void;
+
+  /**
+   * The forEachSlice method takes a function that it will then call for each
+   * Slice in a specified Index.
+   *
+   * This method is useful for iterating over the Slice structure of the Index
+   * in a functional style. The `rowCallback` parameter is a RowCallback
+   * function that will be called with the Id and value of each Row in the
+   * Slice.
+   *
+   * @param indexId The Id of the Index to iterate over.
+   * @param sliceCallback The function that should be called for every Slice.
+   * @example
+   * This example iterates over each Row in a Slice, and lists its Id.
+   *
+   * ```js
+   * const store = createStore().setTable('pets', {
+   *   fido: {species: 'dog'},
+   *   felix: {species: 'cat'},
+   *   cujo: {species: 'dog'},
+   * });
+   * const indexes = createIndexes(store);
+   * indexes.setIndexDefinition('bySpecies', 'pets', 'species');
+   *
+   * indexes.forEachSlice('bySpecies', (sliceId, forEachRow) => {
+   *   console.log(sliceId);
+   *   forEachRow((rowId) => console.log(`- ${rowId}`));
+   * });
+   * // -> 'dog'
+   * // -> '- fido'
+   * // -> '- cujo'
+   * // -> 'cat'
+   * // -> '- felix'
+   * ```
+   * @category Iterator
+   */
+  forEachSlice(indexId: Id, sliceCallback: SliceCallback): void;
+
   /**
    * The hasIndex method returns a boolean indicating whether a given Index
    * exists in the Indexes object.

package/lib/debug/indexes.js

@@ -57,6 +57,7 @@ const getDefinableFunctions = (store, getDefaultThing, validateRowValue) => {
   const storeListenerIds = mapNew();
   const getStore = () => store;
   const getThingIds = () => mapKeys(tableIds);
+  const forEachThing = (cb) => mapForEach(things, cb);
   const hasThing = (id) => collHas(things, id);
   const getTableId = (id) => mapGet(tableIds, id);
   const getThing = (id) => mapGet(things, id);
@@ -147,6 +148,7 @@ const getDefinableFunctions = (store, getDefaultThing, validateRowValue) => {
   return [
     getStore,
     getThingIds,
+    forEachThing,
     hasThing,
     getTableId,
     getThing,
@@ -254,6 +256,7 @@ const createIndexes = getCreateFunction((store) => {
   const [
     getStore,
     getIndexIds,
+    forEachIndexImpl,
     hasIndex,
     getTableId,
     getIndex,
@@ -363,6 +366,26 @@ const createIndexes = getCreateFunction((store) => {
     );
     return indexes;
   };
+  const forEachIndex = (indexCallback) =>
+    forEachIndexImpl((indexId, slices) =>
+      indexCallback(indexId, (sliceCallback) =>
+        forEachSliceImpl(indexId, sliceCallback, slices),
+      ),
+    );
+  const forEachSlice = (indexId, sliceCallback) =>
+    forEachSliceImpl(indexId, sliceCallback, getIndex(indexId));
+  const forEachSliceImpl = (indexId, sliceCallback, slices) => {
+    const tableId = getTableId(indexId);
+    collForEach(slices, (rowIds, sliceId) =>
+      sliceCallback(sliceId, (rowCallback) =>
+        collForEach(rowIds, (rowId) =>
+          rowCallback(rowId, (cellCallback) =>
+            store.forEachCell(tableId, rowId, cellCallback),
+          ),
+        ),
+      ),
+    );
+  };
   const delIndexDefinition = (indexId) => {
     delDefinition(indexId);
     return indexes;
@@ -387,6 +410,8 @@ const createIndexes = getCreateFunction((store) => {
     delIndexDefinition,
     getStore,
     getIndexIds,
+    forEachIndex,
+    forEachSlice,
     hasIndex,
     hasSlice,
     getTableId,

package/lib/debug/metrics.d.ts

@@ -22,6 +22,20 @@ import {Id, IdOrNull, Ids} from './common.d';
  */
 export type Metric = number;
 
+/**
+ * The MetricCallback type describes a function that takes a Metric's Id and a
+ * callback to loop over each Row within it.
+ *
+ * A MetricCallback is provided when using the forEachMetric method, so that you
+ * can do something based on every Metric in the Metrics object. See that method
+ * for specific examples.
+ *
+ * @param metricId The Id of the Metric that the callback can operate on.
+ * @param metric The value of the Metric.
+ * @category Callback
+ */
+export type MetricCallback = (metricId: Id, metric?: Metric) => void;
+
 /**
  * The Aggregate type describes a custom function that takes an array or numbers
  * and returns an aggregate that is used as a Metric.
@@ -478,6 +492,38 @@ export interface Metrics {
    */
   getMetricIds(): Ids;
 
+  /**
+   * The forEachMetric method takes a function that it will then call for each
+   * Metric in the Metrics object.
+   *
+   * This method is useful for iterating over all the Metrics in a functional
+   * style. The `metricCallback` parameter is a MetricCallback function that
+   * will be called with the Id of each Metric and its value.
+   *
+   * @param metricCallback The function that should be called for every Metric.
+   * @example
+   * This example iterates over each Metric in a Metrics object.
+   *
+   * ```js
+   * const store = createStore().setTable('species', {
+   *   dog: {price: 5},
+   *   cat: {price: 4},
+   *   worm: {price: 1},
+   * });
+   * const metrics = createMetrics(store)
+   *   .setMetricDefinition('highestPrice', 'species', 'max', 'price')
+   *   .setMetricDefinition('lowestPrice', 'species', 'min', 'price');
+   *
+   * metrics.forEachMetric((metricId, metric) => {
+   *   console.log([metricId, metric]);
+   * });
+   * // -> ['highestPrice', 5]
+   * // -> ['lowestPrice', 1]
+   * ```
+   * @category Iterator
+   */
+  forEachMetric(metricCallback: MetricCallback): void;
+
   /**
    * The hasMetric method returns a boolean indicating whether a given Metric
    * exists in the Metrics object, and has a value.

package/lib/debug/metrics.js

@@ -62,6 +62,7 @@ const getDefinableFunctions = (store, getDefaultThing, validateRowValue) => {
   const storeListenerIds = mapNew();
   const getStore = () => store;
   const getThingIds = () => mapKeys(tableIds);
+  const forEachThing = (cb) => mapForEach(things, cb);
   const hasThing = (id) => collHas(things, id);
   const getTableId = (id) => mapGet(tableIds, id);
   const getThing = (id) => mapGet(things, id);
@@ -152,6 +153,7 @@ const getDefinableFunctions = (store, getDefaultThing, validateRowValue) => {
   return [
     getStore,
     getThingIds,
+    forEachThing,
     hasThing,
     getTableId,
     getThing,
@@ -296,6 +298,7 @@ const createMetrics = getCreateFunction((store) => {
   const [
     getStore,
     getMetricIds,
+    forEachMetric,
     hasMetric,
     getTableId,
     getMetric,
@@ -381,6 +384,7 @@ const createMetrics = getCreateFunction((store) => {
     delMetricDefinition,
     getStore,
     getMetricIds,
+    forEachMetric,
     hasMetric,
     getTableId,
     getMetric,

package/lib/debug/relationships.d.ts

@@ -11,7 +11,7 @@
  * @module relationships
  */
 
-import {GetCell, Store} from './store.d';
+import {GetCell, RowCallback, Store} from './store.d';
 import {Id, IdOrNull, Ids} from './common.d';
 
 /**
@@ -39,6 +39,25 @@ export type Relationship = {
   linkedRowIds: {[firstRowId: Id]: Ids};
 };
 
+/**
+ * The RelationshipCallback type describes a function that takes a
+ * Relationship's Id and a callback to loop over each local Row within it.
+ *
+ * A RelationshipCallback is provided when using the forEachRelationship method,
+ * so that you can do something based on every Relationship in the Relationships
+ * object. See that method for specific examples.
+ *
+ * @param relationshipId The Id of the Relationship that the callback can
+ * operate on.
+ * @param forEachRow A function that will let you iterate over the local Row
+ * objects in this Relationship.
+ * @category Callback
+ */
+export type RelationshipCallback = (
+  relationshipId: Id,
+  forEachRow: (rowCallback: RowCallback) => void,
+) => void;
+
 /**
  * The RemoteRowIdListener type describes a function that is used to listen to
  * changes to the remote Row Id end of a Relationship.
@@ -405,6 +424,49 @@ export interface Relationships {
    */
   getRelationshipIds(): Ids;
 
+  /**
+   * The forEachRelationship method takes a function that it will then call for
+   * each Relationship in a specified Relationships object.
+   *
+   * This method is useful for iterating over the structure of the Relationships
+   * object in a functional style. The `relationshipCallback` parameter is a
+   * RelationshipCallback function that will be called with the Id of each
+   * Relationship, and with a function that can then be used to iterate over
+   * each local Row involved in the Relationship.
+   *
+   * @param relationshipCallback The function that should be called for every
+   * Relationship.
+   * @example
+   * This example iterates over each Relationship in a Relationships object, and
+   * lists each Row Id within them.
+   *
+   * ```js
+   * const store = createStore().setTable('pets', {
+   *   fido: {species: 'dog', next: 'felix'},
+   *   felix: {species: 'cat', next: 'cujo'},
+   *   cujo: {species: 'dog'},
+   * });
+   * const relationships = createRelationships(store)
+   *   .setRelationshipDefinition('petSpecies', 'pets', 'species', 'species')
+   *   .setRelationshipDefinition('petSequence', 'pets', 'pets', 'next');
+   *
+   * relationships.forEachRelationship((relationshipId, forEachRow) => {
+   *   console.log(relationshipId);
+   *   forEachRow((rowId) => console.log(`- ${rowId}`));
+   * });
+   * // -> 'petSpecies'
+   * // -> '- fido'
+   * // -> '- felix'
+   * // -> '- cujo'
+   * // -> 'petSequence'
+   * // -> '- fido'
+   * // -> '- felix'
+   * // -> '- cujo'
+   * ```
+   * @category Iterator
+   */
+  forEachRelationship(relationshipCallback: RelationshipCallback): void;
+
   /**
    * The hasRelationship method returns a boolean indicating whether a given
    * Relationship exists in the Relationships object.

package/lib/debug/relationships.js

@@ -52,6 +52,7 @@ const getDefinableFunctions = (store, getDefaultThing, validateRowValue) => {
   const storeListenerIds = mapNew();
   const getStore = () => store;
   const getThingIds = () => mapKeys(tableIds);
+  const forEachThing = (cb) => mapForEach(things, cb);
   const hasThing = (id) => collHas(things, id);
   const getTableId = (id) => mapGet(tableIds, id);
   const getThing = (id) => mapGet(things, id);
@@ -142,6 +143,7 @@ const getDefinableFunctions = (store, getDefaultThing, validateRowValue) => {
   return [
     getStore,
     getThingIds,
+    forEachThing,
     hasThing,
     getTableId,
     getThing,
@@ -249,6 +251,7 @@ const createRelationships = getCreateFunction((store) => {
   const [
     getStore,
     getRelationshipIds,
+    forEachRelationshipImpl,
     hasRelationship,
     getLocalTableId,
     getRelationship,
@@ -363,6 +366,12 @@ const createRelationships = getCreateFunction((store) => {
     );
     return relationships;
   };
+  const forEachRelationship = (relationshipCallback) =>
+    forEachRelationshipImpl((relationshipId) =>
+      relationshipCallback(relationshipId, (rowCallback) =>
+        store.forEachRow(getLocalTableId(relationshipId), rowCallback),
+      ),
+    );
   const delRelationshipDefinition = (relationshipId) => {
     mapSet(remoteTableIds, relationshipId);
     delDefinition(relationshipId);
@@ -403,6 +412,7 @@ const createRelationships = getCreateFunction((store) => {
     delRelationshipDefinition,
     getStore,
     getRelationshipIds,
+    forEachRelationship,
     hasRelationship,
     getLocalTableId,
     getRemoteTableId,

package/lib/debug/store.d.ts

@@ -89,7 +89,7 @@ export type Row = {[cellId: Id]: Cell};
 export type Cell = string | number | boolean;
 
 /**
- * The TableCallback type describes a function that takes a Tables's Id and a
+ * The TableCallback type describes a function that takes a Table's Id and a
  * callback to loop over each Row within it.
  *
  * A TableCallback is provided when using the forEachTable method, so that you
@@ -1631,7 +1631,7 @@ export interface Store {
    *
    * This method is useful for iterating over the Table structure of the Store
    * in a functional style. The `tableCallback` parameter is a TableCallback
-   * function that will called with the Id of each Table, and with a function
+   * function that will be called with the Id of each Table, and with a function
    * that can then be used to iterate over each Row of the Table, should you
    * wish.
    *
@@ -1664,9 +1664,10 @@ export interface Store {
    *
    * This method is useful for iterating over the Row structure of the Table in
    * a functional style. The `rowCallback` parameter is a RowCallback function
-   * that will called with the Id of each Row, and with a function that can then
-   * be used to iterate over each Cell of the Row, should you wish.
+   * that will be called with the Id of each Row, and with a function that can
+   * then be used to iterate over each Cell of the Row, should you wish.
    *
+   * @param tableId The Id of the Table to iterate over.
    * @param rowCallback The function that should be called for every Row.
    * @example
    * This example iterates over each Row in a Table, and lists each Cell Id
@@ -1698,8 +1699,10 @@ export interface Store {
    *
    * This method is useful for iterating over the Cell structure of the Row in a
    * functional style. The `cellCallback` parameter is a CellCallback function
-   * that will called with the Id and value of each Cell.
+   * that will be called with the Id and value of each Cell.
    *
+   * @param tableId The Id of the Table containing the Row to iterate over.
+   * @param rowId The Id of the Row to iterate over.
    * @param cellCallback The function that should be called for every Cell.
    * @example
    * This example iterates over each Cell in a Row, and lists its value.