@rljson/db 0.0.3 → 0.0.5

package/dist/db.js

@@ -1,22 +1,379 @@
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 import { IoMem } from "@rljson/io";
-import { validate } from "@rljson/validate";
+import { timeId, createEditProtocolTableCfg, Validate, BaseValidator, Route, validateEdit, isTimeId } from "@rljson/rljson";
+import { rmhsh, hsh } from "@rljson/hash";
+import { equals } from "@rljson/json";
 // @license
-const _Core = class _Core {
+class BaseController {
+  constructor(_core, _tableKey) {
+    this._core = _core;
+    this._tableKey = _tableKey;
+  }
+  // ...........................................................................
+  /**
+   * Retrieves the current state of the table.
+   * @returns A promise that resolves to the current state of the table.
+   */
+  async table() {
+    const rljson = await this._core.dumpTable(this._tableKey);
+    return rljson[this._tableKey];
+  }
+  // ...........................................................................
+  /**
+   * Fetches a specific entry from the table by its reference or by a partial match.
+   * @param where A string representing the reference of the entry to fetch, or an object representing a partial match.
+   * @returns A promise that resolves to an array of entries matching the criteria, or null if no entries are found.
+   */
+  async get(where, filter) {
+    if (typeof where === "string") {
+      return this._getByHash(where, filter);
+    } else if (typeof where === "object" && where !== null) {
+      return this._getByWhere(where, filter);
+    } else {
+      return Promise.resolve({});
+    }
+  }
+  // ...........................................................................
+  /**
+   * Fetches a specific entry from the table by its reference.
+   * @param hash A string representing the reference of the entry to fetch.
+   * @returns A promise that resolves to the entry matching the reference, or null if no entry is found.
+   */
+  async _getByHash(hash, filter) {
+    let result = {};
+    if (!filter || equals(filter, {})) {
+      result = await this._core.readRow(this._tableKey, hash);
+    } else {
+      result = await this._core.readRows(this._tableKey, {
+        _hash: hash,
+        ...filter
+      });
+    }
+    return result;
+  }
+  // ...........................................................................
+  /**
+   * Fetches entries from the table that match the specified criteria.
+   * @param where An object representing the criteria to match.
+   * @returns A promise that resolves to an array of entries matching the criteria, or null if no entries are found.
+   */
+  async _getByWhere(where, filter) {
+    const rows = await this._core.readRows(this._tableKey, {
+      ...where,
+      ...filter
+    });
+    return rows;
+  }
+}
+// @license
+class CakeController extends BaseController {
+  constructor(_core, _tableKey, _refs) {
+    super(_core, _tableKey);
+    this._core = _core;
+    this._tableKey = _tableKey;
+    this._refs = _refs;
+  }
+  _baseLayers = {};
+  async init() {
+    if (this._tableKey.endsWith("Cake") === false) {
+      throw new Error(
+        `Table ${this._tableKey} is not supported by CakeController.`
+      );
+    }
+    const rljson = await this._core.dumpTable(this._tableKey);
+    const table = rljson[this._tableKey];
+    if (table._type !== "cakes") {
+      throw new Error(`Table ${this._tableKey} is not of type cakes.`);
+    }
+    if (this._refs && this._refs.base) {
+      const {
+        [this._tableKey]: { _data: baseCakes }
+      } = await this._core.readRow(this._tableKey, this._refs.base);
+      if (baseCakes.length === 0) {
+        throw new Error(`Base cake ${this._refs.base} does not exist.`);
+      }
+      const baseCake = baseCakes[0];
+      this._baseLayers = rmhsh(baseCake.layers);
+      if (!this._refs.sliceIdsTable || !this._refs.sliceIdsRow) {
+        this._refs = {
+          sliceIdsTable: baseCake.sliceIdsTable,
+          sliceIdsRow: baseCake.sliceIdsRow
+        };
+      }
+    } else {
+      const cake = table._data[0];
+      this._refs = {
+        sliceIdsTable: cake.sliceIdsTable,
+        sliceIdsRow: cake.sliceIdsRow
+      };
+    }
+  }
+  async run(command, value, origin, refs) {
+    if (!command.startsWith("add")) {
+      throw new Error(`Command ${command} is not supported by CakeController.`);
+    }
+    const cake = {
+      layers: { ...this._baseLayers, ...value },
+      ...refs || this._refs
+    };
+    const rlJson = { [this._tableKey]: { _data: [cake] } };
+    await this._core.import(rlJson);
+    const result = {
+      //Ref to component
+      [this._tableKey + "Ref"]: hsh(cake)._hash,
+      //Data from edit
+      route: "",
+      origin,
+      //Unique id/timestamp
+      timeId: timeId()
+    };
+    return result;
+  }
+  async get(where, filter) {
+    if (typeof where === "string") {
+      return this._getByHash(where, filter);
+    } else if (typeof where === "object" && where !== null) {
+      const keys = Object.keys(where);
+      if (keys.length === 1 && keys[0].endsWith("Ref")) {
+        const tableKey = keys[0].replace("Ref", "");
+        return this._getByRef(tableKey, where[keys[0]], filter);
+      } else {
+        return this._getByWhere(where, filter);
+      }
+    } else {
+      return Promise.resolve({});
+    }
+  }
+  async _getByRef(tableKey, ref, filter) {
+    let table = {};
+    if (!!filter && Object.keys(filter).length > 0) {
+      table = await this._core.readRows(
+        this._tableKey,
+        filter
+      );
+    } else {
+      table = await this._core.dumpTable(this._tableKey);
+    }
+    const cakes = [];
+    for (const row of table[this._tableKey]._data) {
+      const cake = row;
+      const layers = cake.layers;
+      for (const layerTable of Object.keys(layers)) {
+        if (layerTable === tableKey && layers[layerTable] === ref) {
+          cakes.push(cake);
+        }
+      }
+    }
+    return {
+      [this._tableKey]: { _data: cakes, _type: "cakes" }
+    };
+  }
+}
+// @license
+class ComponentController extends BaseController {
+  constructor(_core, _tableKey, _refs) {
+    super(_core, _tableKey);
+    this._core = _core;
+    this._tableKey = _tableKey;
+    this._refs = _refs;
+  }
+  async init() {
+    if (!!this._refs && !this._refs.base) {
+      throw new Error(`Refs are not required on ComponentController.`);
+    }
+    const rljson = await this._core.dumpTable(this._tableKey);
+    const table = rljson[this._tableKey];
+    if (table._type !== "components") {
+      throw new Error(`Table ${this._tableKey} is not of type components.`);
+    }
+  }
+  async run(command, value, origin, refs) {
+    if (!command.startsWith("add")) {
+      throw new Error(
+        `Command ${command} is not supported by ComponentController.`
+      );
+    }
+    if (!!refs) {
+      throw new Error(`Refs are not supported on ComponentController.`);
+    }
+    const component = value;
+    const rlJson = { [this._tableKey]: { _data: [component] } };
+    await this._core.import(rlJson);
+    return {
+      //Ref to component
+      [this._tableKey + "Ref"]: hsh(component)._hash,
+      //Data from edit
+      route: "",
+      origin,
+      //Unique id/timestamp
+      timeId: timeId()
+    };
+  }
+}
+// @license
+class LayerController extends BaseController {
+  constructor(_core, _tableKey, _refs) {
+    super(_core, _tableKey);
+    this._core = _core;
+    this._tableKey = _tableKey;
+    this._refs = _refs;
+  }
+  async init() {
+    if (this._tableKey.endsWith("Layer") === false) {
+      throw new Error(
+        `Table ${this._tableKey} is not supported by LayerController.`
+      );
+    }
+    const rljson = await this._core.dumpTable(this._tableKey);
+    const table = rljson[this._tableKey];
+    if (table._type !== "layers") {
+      throw new Error(`Table ${this._tableKey} is not of type layers.`);
+    }
+    if (this._refs && this._refs.base) {
+      const {
+        [this._tableKey]: { _data: baseLayers }
+      } = await this._core.readRow(this._tableKey, this._refs.base);
+      if (baseLayers.length === 0) {
+        throw new Error(`Base layer ${this._refs.base} does not exist.`);
+      }
+      const baseLayer = baseLayers[0];
+      if (
+        /* v8 ignore start */
+        !this._refs.sliceIdsTable || !this._refs.sliceIdsRow || !this._refs.componentsTable
+      ) {
+        this._refs = {
+          sliceIdsTable: baseLayer.sliceIdsTable,
+          sliceIdsTableRow: baseLayer.sliceIdsTableRow,
+          componentsTable: baseLayer.componentsTable
+        };
+      }
+    } else {
+      const layer = table._data[0];
+      this._refs = {
+        sliceIdsTable: layer.sliceIdsTable,
+        sliceIdsTableRow: layer.sliceIdsTableRow,
+        componentsTable: layer.componentsTable
+      };
+    }
+  }
+  async run(command, value, origin, refs) {
+    if (!command.startsWith("add") && !command.startsWith("remove")) {
+      throw new Error(
+        `Command ${command} is not supported by LayerController.`
+      );
+    }
+    const layer = command.startsWith("add") === true ? {
+      add: value,
+      ...refs || this._refs
+    } : {
+      add: {},
+      remove: value,
+      ...refs || this._refs
+    };
+    const rlJson = { [this._tableKey]: { _data: [layer] } };
+    await this._core.import(rlJson);
+    const result = {
+      //Ref to component
+      [this._tableKey + "Ref"]: hsh(layer)._hash,
+      //Data from edit
+      route: "",
+      origin,
+      //Unique id/timestamp
+      timeId: timeId()
+    };
+    return result;
+  }
+  async get(where, filter) {
+    if (typeof where === "string") {
+      return this._getByHash(where, filter);
+    } else if (typeof where === "object" && where !== null) {
+      const keys = Object.keys(where);
+      if (keys.length === 1 && keys[0].endsWith("Ref")) {
+        const tableKey = keys[0].replace("Ref", "");
+        return this._getByRef(tableKey, where[keys[0]], filter);
+      } else {
+        return this._getByWhere(where, filter);
+      }
+    } else {
+      return Promise.resolve({});
+    }
+  }
+  async _getByRef(tableKey, ref, filter) {
+    let table = {};
+    if (!!filter && Object.keys(filter).length > 0) {
+      table = await this._core.readRows(this._tableKey, {
+        ...filter
+      });
+    } else {
+      table = await this._core.dumpTable(this._tableKey);
+    }
+    const layers = [];
+    for (const row of table[this._tableKey]._data) {
+      const layer = row;
+      if (layer.componentsTable !== tableKey) {
+        continue;
+      }
+      for (const layerRef of Object.values(layer.add)) {
+        if (layerRef === ref) {
+          layers.push(layer);
+        }
+      }
+    }
+    return {
+      [this._tableKey]: { _data: layers, _type: "layers" }
+    };
+  }
+}
+// @license
+const createController = async (type, core, tableKey, refs) => {
+  let ctrl;
+  switch (type) {
+    case "layers":
+      ctrl = new LayerController(core, tableKey, refs);
+      break;
+    case "components":
+      ctrl = new ComponentController(core, tableKey, refs);
+      break;
+    case "cakes":
+      ctrl = new CakeController(core, tableKey, refs);
+      break;
+    default:
+      throw new Error(`Controller for type ${type} is not implemented yet.`);
+  }
+  await ctrl.init();
+  return ctrl;
+};
+// @license
+class Core {
   // ...........................................................................
   constructor(_io) {
     this._io = _io;
   }
+  static example = async () => {
+    return new Core(await IoMem.example());
+  };
   // ...........................................................................
+  /**
+   * Creates a table and an edit protocol for the table
+   * @param tableCfg TableCfg of table to create
+   */
+  async createEditable(tableCfg) {
+    await this.createTable(tableCfg);
+    await this.createEditProtocol(tableCfg);
+  }
   /**
    * Creates a table
-   * @param name The name of the table.
-   * @param type The type of the table.
+   * @param tableCfg TableCfg of table to create
    */
-  async createTable(name, type) {
-    return this._io.createTable({ name, type });
+  async createTable(tableCfg) {
+    return this._io.createOrExtendTable({ tableCfg });
+  }
+  /**
+   * Creates an edit protocol table for a given table
+   * @param tableCfg TableCfg of table
+   */
+  async createEditProtocol(tableCfg) {
+    const cfg = createEditProtocolTableCfg(tableCfg);
+    await this.createTable(cfg);
   }
   // ...........................................................................
   /**
@@ -30,17 +387,20 @@ const _Core = class _Core {
    * @returns a dump of a table.
    * @throws when table name does not exist
    */
-  dumpTable(name) {
-    return this._io.dumpTable({ name });
+  dumpTable(table) {
+    return this._io.dumpTable({ table });
   }
   // ...........................................................................
   /**
    * Imports data into the memory.
+   * @param data - The rljson data to import.
    * @throws {Error} If the data is invalid.
    */
   async import(data) {
-    const result = validate(data);
-    if (result.hasErrors) {
+    const validate = new Validate();
+    validate.addValidator(new BaseValidator());
+    const result = await validate.run(data);
+    if ((result.hasErrors || result.base && result.base.hasErrors) && !result.base.refsNotFound) {
       throw new Error(
         "The imported rljson data is not valid:\n" + JSON.stringify(result, null, 2)
       );
@@ -49,51 +409,467 @@ const _Core = class _Core {
   }
   // ...........................................................................
   async tables() {
-    return this._io.tables();
+    return await this._io.dump();
   }
   // ...........................................................................
   async hasTable(table) {
-    const tables = await this._io.tables();
-    return tables.includes(table);
+    return await this._io.tableExists(table);
+  }
+  // ...........................................................................
+  async contentType(table) {
+    const t = await this._io.dumpTable({ table });
+    const contentType = t[table]?._type;
+    return contentType;
   }
   // ...........................................................................
   /** Reads a specific row from a database table */
   readRow(table, rowHash) {
-    return this._io.readRow({ table, rowHash });
+    return this._io.readRows({ table, where: { _hash: rowHash } });
   }
   // ...........................................................................
   readRows(table, where) {
     return this._io.readRows({ table, where });
   }
-};
-__publicField(_Core, "example", async () => {
-  return new _Core(IoMem.example());
-});
-let Core = _Core;
+}
+// @license
+class Notify {
+  _callbacks = /* @__PURE__ */ new Map();
+  // ...........................................................................
+  constructor() {
+  }
+  // ...........................................................................
+  /**
+   * Registers a callback for a specific route.
+   * @param route   The route to register the callback for.
+   * @param callback  The callback function to be invoked when a notification is sent.
+   */
+  register(route, callback) {
+    this._callbacks.set(route.flat, [
+      ...this._callbacks.get(route.flat) || [],
+      callback
+    ]);
+  }
+  // ...........................................................................
+  /**
+   * Unregisters a callback for a specific route.
+   * @param route   The route to unregister the callback from.
+   * @param callback  The callback function to be removed.
+   */
+  unregister(route, callback) {
+    const callbacks = this._callbacks.get(route.flat);
+    if (callbacks) {
+      this._callbacks.set(
+        route.flat,
+        callbacks.filter((cb) => cb !== callback)
+      );
+    }
+  }
+  // ...........................................................................
+  /**
+   * Notifies all registered callbacks for a specific route with the provided edit protocol row.
+   * @param route   The route to notify callbacks for.
+   * @param editProtocolRow  The edit protocol row to pass to the callbacks.
+   */
+  notify(route, editProtocolRow) {
+    const callbacks = this._callbacks.get(route.flat);
+    if (callbacks) {
+      for (const cb of callbacks) {
+        cb(editProtocolRow);
+      }
+    }
+  }
+  // ...........................................................................
+  /**
+   * Returns the current map of registered callbacks.
+   * @returns A map where keys are route strings and values are arrays of callback functions.
+   */
+  get callbacks() {
+    return this._callbacks;
+  }
+  // ...........................................................................
+  /**
+   * Retrieves the list of callbacks registered for a specific route.
+   * @param route   The route to get callbacks for.
+   * @returns An array of callback functions registered for the specified route.
+   */
+  getCallBacksForRoute(route) {
+    return this._callbacks.get(route.flat) || [];
+  }
+}
 // @license
-const _Db = class _Db {
+class Db {
   /**
    * Constructor
    * @param _io - The Io instance used to read and write data
    */
   constructor(_io) {
-    /**
-     * Core functionalities like importing data, setting and getting tables
-     */
-    __publicField(this, "core");
     this._io = _io;
     this.core = new Core(this._io);
+    this.notify = new Notify();
   }
-};
-/**
- * Example
- * @returns A new Db instance for test purposes
- */
-__publicField(_Db, "example", async () => {
-  const io = new IoMem();
-  return new _Db(io);
-});
-let Db = _Db;
+  /**
+   * Core functionalities like importing data, setting and getting tables
+   */
+  core;
+  /**
+   * Notification system to register callbacks on data changes
+   */
+  notify;
+  // ...........................................................................
+  /**
+   * Get data from a route with optional filtering
+   * @param route - The route to get data from
+   * @param where - Optional filter to apply to the data
+   * @returns An array of Rljson objects matching the route and filter
+   * @throws {Error} If the route is not valid or if any controller cannot be created
+   */
+  async get(route, where) {
+    if (!route.isValid) throw new Error(`Route ${route.flat} is not valid.`);
+    const controllers = await this._indexedControllers(route);
+    return this._get(route, where, controllers);
+  }
+  // ...........................................................................
+  /**
+   * Recursively fetches data from the given route using the provided controllers
+   * @param route - The route to fetch data from
+   * @param where - The filter to apply to the root table
+   * @param controllers - A record of controllers keyed by table name
+   * @returns An array of Rljson objects matching the route and filter
+   */
+  async _get(route, where, controllers) {
+    let filter = {};
+    if (Route.segmentHasRef(route.root)) {
+      let revision = "";
+      if (Route.segmentHasDefaultRef(route.root)) {
+        revision = Route.segmentRef(route.root);
+      } else {
+        revision = await this.getRefOfTimeId(
+          route.root.tableKey,
+          Route.segmentRef(route.root)
+        );
+      }
+      filter = { _hash: revision };
+    }
+    const rootRljson = await controllers[route.root.tableKey].get(
+      where,
+      filter
+    );
+    const rootRefs = rootRljson[route.root.tableKey]._data.map(
+      (r) => r._hash
+    );
+    if (route.segments.length === 1) {
+      return [rootRljson];
+    }
+    const results = [];
+    for (const ref of rootRefs) {
+      const superiorRoute = new Route(route.segments.slice(0, -1));
+      const res = await this._get(
+        superiorRoute,
+        {
+          [route.root.tableKey + "Ref"]: ref
+        },
+        controllers
+      );
+      results.push(...res);
+    }
+    return results.map((r) => ({ ...r, ...rootRljson }));
+  }
+  // ...........................................................................
+  /**
+   * Runs an edit by executing the appropriate controller(s) based on the edit's route
+   * @param edit - The edit to run
+   * @returns The result of the edit as an EditProtocolRow
+   * @throws {Error} If the edit is not valid or if any controller cannot be created
+   */
+  async run(edit, options) {
+    const initialRoute = Route.fromFlat(edit.route);
+    const runs = await this._resolveRuns(edit);
+    const errors = validateEdit(edit);
+    if (!!errors.hasErrors) {
+      throw new Error(`Edit is not valid:
+${JSON.stringify(errors, null, 2)}`);
+    }
+    return this._run(edit, initialRoute, runs, options);
+  }
+  // ...........................................................................
+  /**
+   * Recursively runs controllers based on the route of the edit
+   * @param edit - The edit to run
+   * @param route - The route of the edit
+   * @param runFns - A record of controller run functions, keyed by table name
+   * @returns The result of the edit
+   * @throws {Error} If the route is not valid or if any controller cannot be created
+   */
+  async _run(edit, route, runFns, options) {
+    let result;
+    let tableKey;
+    const segment = route.segment(0);
+    tableKey = segment.tableKey;
+    let previous = [];
+    if (Route.segmentHasRef(segment)) {
+      const routeRef = Route.segmentRef(segment);
+      if (Route.segmentHasProtocolRef(segment)) {
+        previous = [...previous, routeRef];
+      }
+      if (Route.segmentHasDefaultRef(segment)) {
+        const timeIds = await this.getTimeIdsForRef(
+          tableKey,
+          Route.segmentRef(segment)
+        );
+        previous = [...previous, ...timeIds];
+      }
+    }
+    if (!route.isRoot) {
+      const childRoute = route.deeper(1);
+      const childKeys = this._childKeys(route, edit.value);
+      const childRefs = {};
+      for (const k of childKeys) {
+        const childValue = edit.value[k];
+        const childEdit = { ...edit, value: childValue };
+        const childResult = await this._run(childEdit, childRoute, runFns);
+        const childRefKey = childRoute.top.tableKey + "Ref";
+        const childRef = childResult[childRefKey];
+        childRefs[k] = childRef;
+      }
+      const runFn = runFns[tableKey];
+      result = {
+        ...await runFn(
+          edit.command,
+          {
+            ...edit.value,
+            ...childRefs
+          },
+          edit.origin
+        ),
+        previous
+      };
+    } else {
+      tableKey = route.root.tableKey;
+      const runFn = runFns[tableKey];
+      result = {
+        ...await runFn(edit.command, edit.value, edit.origin),
+        previous
+      };
+    }
+    result.route = edit.route;
+    await this._writeProtocol(tableKey, result);
+    if (!options?.skipNotification)
+      this.notify.notify(Route.fromFlat(edit.route), result);
+    return result;
+  }
+  // ...........................................................................
+  /**
+   * Registers a callback to be called when an edit is made on the given route
+   * @param route - The route to register the callback on
+   * @param callback - The callback to be called when an edit is made
+   */
+  registerObserver(route, callback) {
+    this.notify.register(route, callback);
+  }
+  // ...........................................................................
+  /**
+   * Unregisters a callback from the given route
+   * @param route - The route to unregister the callback from
+   * @param callback - The callback to be unregistered
+   */
+  unregisterObserver(route, callback) {
+    this.notify.unregister(route, callback);
+  }
+  // ...........................................................................
+  /**
+   * Resolves an edit by returning the run functions of all controllers involved in the edit's route
+   * @param edit - The edit to resolve
+   * @returns A record of controller run functions, keyed by table name
+   * @throws {Error} If the route is not valid or if any controller cannot be created
+   */
+  async _resolveRuns(edit) {
+    const controllers = await this._indexedControllers(
+      Route.fromFlat(edit.route)
+    );
+    const runFns = {};
+    for (const tableKey of Object.keys(controllers)) {
+      runFns[tableKey] = controllers[tableKey].run.bind(controllers[tableKey]);
+    }
+    return runFns;
+  }
+  // ...........................................................................
+  /**
+   * Returns the keys of child refs in a value based on a route
+   * @param route - The route to check
+   * @param value - The value to check
+   * @returns An array of keys of child refs in the value
+   */
+  _childKeys(route, value) {
+    const keys = Object.keys(value);
+    const childKeys = [];
+    for (const k of keys) {
+      if (typeof value[k] !== "object") continue;
+      if (k.endsWith("Ref") && route.next?.tableKey + "Ref" !== k) continue;
+      childKeys.push(k);
+    }
+    return childKeys;
+  }
+  // ...........................................................................
+  /**
+   * Get a controller for a specific table
+   * @param tableKey - The key of the table to get the controller for
+   * @param refs - Optional references required by some controllers
+   * @returns A controller for the specified table
+   * @throws {Error} If the table does not exist or if the table type is not supported
+   */
+  async getController(tableKey, refs) {
+    if (typeof tableKey !== "string" || tableKey.length === 0) {
+      throw new Error("TableKey must be a non-empty string.");
+    }
+    const tableExists = this.core.hasTable(tableKey);
+    if (!tableExists) {
+      throw new Error(`Table ${tableKey} does not exist.`);
+    }
+    const contentType = await this.core.contentType(tableKey);
+    if (!contentType) {
+      throw new Error(`Table ${tableKey} does not have a valid content type.`);
+    }
+    return createController(contentType, this.core, tableKey, refs);
+  }
+  // ...........................................................................
+  async _indexedControllers(route) {
+    if (!route.isValid) throw new Error(`Route ${route.flat} is not valid.`);
+    const controllers = {};
+    for (let i = 0; i < route.segments.length; i++) {
+      const segment = route.segments[i];
+      const tableKey = segment.tableKey;
+      const segmentRef = Route.segmentRef(segment);
+      const base = segmentRef ? isTimeId(segmentRef) ? await this.getRefOfTimeId(tableKey, segmentRef) : segmentRef : null;
+      controllers[tableKey] ??= await this.getController(
+        tableKey,
+        base ? { base } : void 0
+      );
+    }
+    return controllers;
+  }
+  // ...........................................................................
+  /**
+   * Adds an edit protocol row to the edits table of a table
+   * @param table - The table the edit was made on
+   * @param editProtocolRow - The edit protocol row to add
+   * @throws {Error} If the edits table does not exist
+   */
+  async _writeProtocol(table, editProtocolRow) {
+    const protocolTable = table + "Edits";
+    const hasTable = await this.core.hasTable(protocolTable);
+    if (!hasTable) {
+      throw new Error(`Table ${table} does not exist`);
+    }
+    await this.core.import({
+      [protocolTable]: {
+        _data: [editProtocolRow],
+        _type: "edits"
+      }
+    });
+  }
+  // ...........................................................................
+  /**
+   * Get the edit protocol of a table
+   * @param table - The table to get the edit protocol for
+   * @throws {Error} If the edits table does not exist
+   */
+  async getProtocol(table, options) {
+    const protocolTable = table + "Edits";
+    const hasTable = await this.core.hasTable(protocolTable);
+    if (!hasTable) {
+      throw new Error(`Table ${table} does not exist`);
+    }
+    if (options === void 0) {
+      options = { sorted: false, ascending: true };
+    }
+    if (options.sorted) {
+      const dumpedTable = await this.core.dumpTable(protocolTable);
+      const tableData = dumpedTable[protocolTable]._data;
+      tableData.sort((a, b) => {
+        const aTime = a.timeId.split(":")[1];
+        const bTime = b.timeId.split(":")[1];
+        if (options.ascending) {
+          return aTime.localeCompare(bTime);
+        } else {
+          return bTime.localeCompare(aTime);
+        }
+      });
+      return { [protocolTable]: { _data: tableData, _type: "edits" } };
+    }
+    return this.core.dumpTable(protocolTable);
+  }
+  // ...........................................................................
+  /**
+   * Get a specific edit protocol row from a table
+   * @param table - The table to get the edit protocol row from
+   * @param ref - The reference of the edit protocol row to get
+   * @returns The edit protocol row or null if it does not exist
+   * @throws {Error} If the edits table does not exist
+   */
+  async getProtocolRowsByRef(table, ref) {
+    const protocolTable = table + "Edits";
+    const {
+      [protocolTable]: { _data: protocol }
+    } = await this.core.readRows(protocolTable, { [table + "Ref"]: ref });
+    return protocol || null;
+  }
+  // ...........................................................................
+  /**
+   * Get a specific edit protocol row from a table by its timeId
+   * @param table - The table to get the edit protocol row from
+   * @param timeId - The timeId of the edit protocol row to get
+   * @returns The edit protocol row or null if it does not exist
+   * @throws {Error} If the edits table does not exist
+   */
+  async getProtocolRowByTimeId(table, timeId2) {
+    const protocolTable = table + "Edits";
+    const { [protocolTable]: result } = await this.core.readRows(
+      protocolTable,
+      { timeId: timeId2 }
+    );
+    return result._data?.[0] || null;
+  }
+  // ...........................................................................
+  /**
+   * Get all timeIds for a specific ref in a table
+   * @param table - The table to get the timeIds from
+   * @param ref - The reference to get the timeIds for
+   * @returns An array of timeIds
+   * @throws {Error} If the edits table does not exist
+   */
+  async getTimeIdsForRef(table, ref) {
+    const protocolTable = table + "Edits";
+    const { [protocolTable]: result } = await this.core.readRows(
+      protocolTable,
+      { [table + "Ref"]: ref }
+    );
+    return result._data?.map((r) => r.timeId) || [];
+  }
+  // ...........................................................................
+  /**
+   * Get the ref for a specific timeId in a table
+   * @param table - The table to get the ref from
+   * @param timeId - The timeId to get the ref for
+   * @returns The ref or null if it does not exist
+   * @throws {Error} If the edits table does not exist
+   */
+  async getRefOfTimeId(table, timeId2) {
+    const protocolTable = table + "Edits";
+    const { [protocolTable]: result } = await this.core.readRows(
+      protocolTable,
+      { timeId: timeId2 }
+    );
+    return result._data?.[0]?.[table + "Ref"] || null;
+  }
+  /**
+   * Example
+   * @returns A new Db instance for test purposes
+   */
+  static example = async () => {
+    const io = new IoMem();
+    return new Db(io);
+  };
+}
 export {
   Db as RljsonDb
 };