@rljson/io 0.0.21 → 0.0.23

package/dist/index.d.ts

@@ -1,2 +1,4 @@
 export * from './io-mem.ts';
+export * from './io-tools.ts';
 export * from './io.ts';
+export * from './reverse-ref.ts';

package/dist/io-mem.d.ts

@@ -6,7 +6,7 @@ import { Io } from './io.ts';
  */
 export declare class IoMem implements Io {
     constructor();
-    static example: () => IoMem;
+    static example: () => Promise<IoMem>;
     isReady(): Promise<void>;
     dump(): Promise<Rljson>;
     dumpTable(request: {
@@ -18,20 +18,20 @@ export declare class IoMem implements Io {
             [column: string]: JsonValue;
         };
     }): Promise<Rljson>;
+    rowCount(table: string): Promise<number>;
     write(request: {
         data: Rljson;
     }): Promise<void>;
-    createTable(request: {
+    createOrExtendTable(request: {
         tableCfg: TableCfg;
     }): Promise<void>;
     tableCfgs(): Promise<Rljson>;
-    allTableNames(): Promise<string[]>;
+    private _ioTools;
     private _isReady;
     private _mem;
-    private _ioInit;
     private _init;
     private _initTableCfgs;
-    private _createTable;
+    private _createOrExtendTable;
     private _dump;
     private _dumpTable;
     private _write;

package/dist/io-tools.d.ts

@@ -0,0 +1,48 @@
+import { TableCfg, TableKey } from '@rljson/rljson';
+import { Io } from './io.ts';
+/**
+ * Provides utility functions for the Io interface.
+ */
+export declare class IoTools {
+    readonly io: Io;
+    /**
+     * Constructor
+     * @param io The Io interface to use
+     */
+    constructor(io: Io);
+    /**
+     * Initializes the revisions table.
+     */
+    initRevisionsTable: () => Promise<void>;
+    /**
+     * Returns the table configuration of the tableCfgs table.
+     */
+    get tableCfgsTableCfg(): TableCfg;
+    /**
+     * Example object for test purposes
+     * @returns An instance of io tools
+     */
+    static example: () => Promise<IoTools>;
+    /**
+     * Returns a list with all table names
+     */
+    allTableKeys(): Promise<string[]>;
+    /**
+     * Returns the configuration of a given table
+     */
+    tableCfg(table: TableKey): Promise<TableCfg>;
+    /**
+     * Returns the configuration of a given table or null if it does not exist.
+  
+     */
+    tableCfgOrNull(table: TableKey): Promise<TableCfg | null>;
+    /**
+     * Returns a list of all column names of a given table
+     */
+    allColumnKeys(table: TableKey): Promise<string[]>;
+    /**
+     * Throws when a table update is not compatible with the current table
+     * configuration.
+     */
+    throwWhenTableIsNotCompatible(update: TableCfg): Promise<void>;
+}

package/dist/io.d.ts

@@ -13,21 +13,19 @@ export interface Io {
         table: string;
     }): Promise<Rljson>;
     /**
-     * Creates a table with a given config
-     *
-     * The config must be already in the database
+     * Creates a table with a given config.
+     * If the table already exists, new columns are added to the existing table.
+     * If the table does not exist, it is created with the given config.
+     * If the table exists and columns are removed, an error is thrown.
+     * If the table exists and the column type is changed, an error is thrown.
      */
-    createTable(request: {
+    createOrExtendTable(request: {
         tableCfg: TableCfg;
     }): Promise<void>;
     /**
      * Returns a json structure returning current table configurations
      */
     tableCfgs(): Promise<Rljson>;
-    /**
-     * Returns an rljson with all available tables without data
-     */
-    allTableNames(): Promise<string[]>;
     /** Writes Rljson data into the database */
     write(request: {
         data: Rljson;
@@ -39,5 +37,7 @@ export interface Io {
             [column: string]: JsonValue;
         };
     }): Promise<Rljson>;
+    /** Returns the number of rows in the given table */
+    rowCount(table: string): Promise<number>;
 }
 export declare const exampleIo = "Checkout @rljson/io-mem for an example implementation";

package/dist/io.js

@@ -3,46 +3,156 @@ var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { en
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 import { hip, hsh } from "@rljson/hash";
 import { IsReady } from "@rljson/is-ready";
-import { copy, equals } from "@rljson/json";
+import { jsonValueTypes, copy, equals } from "@rljson/json";
+import { iterateTablesSync } from "@rljson/rljson";
 // @license
-class IoInit {
+const _IoTools = class _IoTools {
+  /**
+   * Constructor
+   * @param io The Io interface to use
+   */
   constructor(io) {
+    /**
+     * Initializes the revisions table.
+     */
     __publicField(this, "initRevisionsTable", async () => {
       const tableCfg = {
         version: 1,
         key: "revisions",
         type: "ingredients",
-        isHead: false,
-        isRoot: false,
-        isShared: true,
-        columns: {
-          table: { type: "string" },
-          predecessor: { type: "string" },
-          successor: { type: "string" },
-          timestamp: { type: "number" },
-          id: { type: "string" }
-        }
+        isHead: true,
+        isRoot: true,
+        isShared: false,
+        columns: [
+          { key: "table", type: "string" },
+          { key: "predecessor", type: "string" },
+          { key: "successor", type: "string" },
+          { key: "timestamp", type: "number" },
+          { key: "id", type: "string" }
+        ]
       };
-      await this.io.createTable({ tableCfg });
+      await this.io.createOrExtendTable({ tableCfg });
     });
     this.io = io;
   }
-  get tableCfg() {
+  /**
+   * Returns the table configuration of the tableCfgs table.
+   */
+  get tableCfgsTableCfg() {
     const tableCfg = hip({
-      version: 1,
+      _hash: "",
       key: "tableCfgs",
       type: "ingredients",
       isHead: false,
       isRoot: false,
       isShared: true,
-      columns: {
-        key: { type: "string" },
-        type: { type: "string" }
-      }
+      version: 1,
+      columns: [
+        { key: "_hash", type: "string" },
+        { key: "key", type: "string" },
+        { key: "type", type: "string" },
+        { key: "isHead", type: "boolean" },
+        { key: "isRoot", type: "boolean" },
+        { key: "isShared", type: "boolean" },
+        { key: "version", type: "number" },
+        { key: "columns", type: "jsonArray" }
+      ]
     });
     return tableCfg;
   }
-}
+  /**
+   * Returns a list with all table names
+   */
+  async allTableKeys() {
+    const result = (await this.io.tableCfgs()).tableCfgs._data.map(
+      (e) => e.key
+    );
+    return result;
+  }
+  /**
+   * Returns the configuration of a given table
+   */
+  async tableCfg(table) {
+    const tableCfg = await this.tableCfgOrNull(table);
+    if (!tableCfg) {
+      throw new Error(`Table "${table}" not found`);
+    }
+    return tableCfg;
+  }
+  /**
+     * Returns the configuration of a given table or null if it does not exist.
+  
+     */
+  async tableCfgOrNull(table) {
+    const tableCfgs = await this.io.tableCfgs();
+    const tableCfg = tableCfgs.tableCfgs._data.find((e) => e.key === table);
+    return tableCfg ?? null;
+  }
+  /**
+   * Returns a list of all column names of a given table
+   */
+  async allColumnKeys(table) {
+    const tableCfg = await this.tableCfg(table);
+    const result = tableCfg.columns.map((column) => column.key);
+    return result;
+  }
+  /**
+   * Throws when a table update is not compatible with the current table
+   * configuration.
+   */
+  async throwWhenTableIsNotCompatible(update) {
+    const prefix = `Invalid update of table able "${update.key}"`;
+    for (const column of update.columns) {
+      if (!jsonValueTypes.includes(column.type)) {
+        throw new Error(
+          `${prefix}: Column "${column.key}" has an unsupported type "${column.type}"`
+        );
+      }
+    }
+    const existing = await this.tableCfgOrNull(update.key);
+    if (existing) {
+      if (existing.columns.length > update.columns.length) {
+        const deletedColumnKeys = existing.columns.map((column) => column.key).filter(
+          (key) => !update.columns.some((column) => column.key === key)
+        );
+        if (deletedColumnKeys.length > 0) {
+          const deletedColumns = deletedColumnKeys.join(", ");
+          throw new Error(
+            `${prefix}: Columns must not be deleted. Deleted columns: ${deletedColumns}}`
+          );
+        }
+      }
+      for (let i = 0; i < existing.columns.length; i++) {
+        const before = existing.columns[i].key;
+        const after = update.columns[i].key;
+        if (before !== after) {
+          throw new Error(
+            `${prefix}: Column keys must not change! Column "${before}" was renamed into "${after}".`
+          );
+        }
+      }
+      for (let i = 0; i < existing.columns.length; i++) {
+        const column = existing.columns[i].key;
+        const before = existing.columns[i].type;
+        const after = update.columns[i].type;
+        if (before !== after) {
+          throw new Error(
+            `${prefix}: Column types must not change! Type of column "${column}" was changed from "${before}" to ${after}.`
+          );
+        }
+      }
+    }
+  }
+};
+/**
+ * Example object for test purposes
+ * @returns An instance of io tools
+ */
+__publicField(_IoTools, "example", async () => {
+  const io = await IoMem.example();
+  return new _IoTools(io);
+});
+let IoTools = _IoTools;
 // @license
 const _IoMem = class _IoMem {
   // ...........................................................................
@@ -51,12 +161,12 @@ const _IoMem = class _IoMem {
     // ######################
     // Private
     // ######################
+    __publicField(this, "_ioTools");
     __publicField(this, "_isReady", new IsReady());
     __publicField(this, "_mem", hip({}));
-    __publicField(this, "_ioInit");
     // ...........................................................................
     __publicField(this, "_initTableCfgs", () => {
-      const tableCfg = this._ioInit.tableCfg;
+      const tableCfg = this._ioTools.tableCfgsTableCfg;
       this._mem.tableCfgs = hip({
         _data: [tableCfg],
         _type: "ingredients",
@@ -84,6 +194,13 @@ const _IoMem = class _IoMem {
   readRows(request) {
     return this._readRows(request);
   }
+  async rowCount(table) {
+    const tableData = this._mem[table];
+    if (!tableData) {
+      throw new Error(`Table "${table}" not found`);
+    }
+    return Promise.resolve(tableData._data.length);
+  }
   // ...........................................................................
   // Write
   write(request) {
@@ -91,8 +208,8 @@ const _IoMem = class _IoMem {
   }
   // ...........................................................................
   // Table management
-  createTable(request) {
-    return this._createTable(request);
+  createOrExtendTable(request) {
+    return this._createOrExtendTable(request);
   }
   async tableCfgs() {
     const tables = this._mem.tableCfgs._data;
@@ -113,25 +230,18 @@ const _IoMem = class _IoMem {
       }
     });
   }
-  async allTableNames() {
-    const tables = Object.keys(this._mem).filter((key) => !key.startsWith("_"));
-    return tables;
-  }
   // ...........................................................................
   async _init() {
-    this._ioInit = new IoInit(this);
+    this._ioTools = new IoTools(this);
     this._initTableCfgs();
-    await this._ioInit.initRevisionsTable();
+    await this._ioTools.initRevisionsTable();
     this._isReady.resolve();
   }
   // ...........................................................................
-  async _createTable(request) {
+  async _createOrExtendTable(request) {
     var _a;
-    const { key, type } = request.tableCfg;
-    const existing = this._mem[key];
-    if (existing) {
-      throw new Error(`Table ${key} already exists`);
-    }
+    await this._ioTools.throwWhenTableIsNotCompatible(request.tableCfg);
+    const { type, key } = request.tableCfg;
     const newConfig = hsh(request.tableCfg);
     const existingConfig = this._mem.tableCfgs._data.find(
       (cfg) => cfg._hash === newConfig._hash
@@ -139,9 +249,10 @@ const _IoMem = class _IoMem {
     if (!existingConfig) {
       this._mem.tableCfgs._data.push(newConfig);
       this._mem.tableCfgs._hash = "";
-      const updateExistingHashes = false;
-      const throwOnWrongHashes = false;
-      hip(this._mem.tableCfgs, { updateExistingHashes, throwOnWrongHashes });
+      hip(this._mem.tableCfgs, {
+        updateExistingHashes: false,
+        throwOnWrongHashes: false
+      });
     }
     const table = {
       _data: [],
@@ -217,13 +328,117 @@ const _IoMem = class _IoMem {
     return result;
   }
 };
-__publicField(_IoMem, "example", () => {
+__publicField(_IoMem, "example", async () => {
   return new _IoMem();
 });
 let IoMem = _IoMem;
 // @license
 const exampleIo = "Checkout @rljson/io-mem for an example implementation";
+// @license
+const calcReverseRefs = (rljson) => {
+  const result = {};
+  iterateTablesSync(rljson, (childTableKey, table) => {
+    const childTable = {};
+    result[childTableKey] = childTable;
+    for (const childRow of table._data) {
+      childTable[childRow._hash] = {};
+    }
+  });
+  iterateTablesSync(rljson, (parentTableKey, parentTable) => {
+    for (const parentTableRow of parentTable._data) {
+      switch (parentTable._type) {
+        case "ingredients":
+          _writeIngredientRefs(parentTableKey, parentTableRow, result);
+          break;
+        case "layers": {
+          _writeLayerRefs(parentTableKey, parentTableRow, result);
+          break;
+        }
+        case "sliceIds": {
+          break;
+        }
+        case "cakes": {
+          _writeCakeRefs(parentTableKey, parentTableRow, result);
+          break;
+        }
+        case "buffets": {
+          _writeBuffetRefs(parentTableKey, parentTableRow, result);
+          break;
+        }
+      }
+    }
+  });
+  return result;
+};
+const _writeIngredientRefs = (parentTableName, parentRow, result) => {
+  const parentRowHash = parentRow._hash;
+  for (const parentColumnName in parentRow) {
+    if (parentColumnName.startsWith("_")) {
+      continue;
+    }
+    if (!parentColumnName.endsWith("Ref")) {
+      continue;
+    }
+    const childTableName = parentColumnName.slice(0, -3);
+    const childRowHash = parentRow[parentColumnName];
+    _write(
+      result,
+      childTableName,
+      childRowHash,
+      parentTableName,
+      parentRowHash
+    );
+  }
+};
+const _writeLayerRefs = (parentTableName, parentRow, result) => {
+  const childTableName = parentRow.ingredientsTable;
+  const parentRowHash = parentRow._hash;
+  for (const sliceId in parentRow.assign) {
+    if (sliceId.startsWith("_")) {
+      continue;
+    }
+    const sliceHash = parentRow.assign[sliceId];
+    _write(result, childTableName, sliceHash, parentTableName, parentRowHash);
+  }
+};
+const _writeCakeRefs = (parentTableName, parentRow, result) => {
+  const parentRowHash = parentRow._hash;
+  for (const layer in parentRow.layers) {
+    const childTableName = parentRow.layersTable;
+    const childRowHash = parentRow.layers[layer];
+    _write(
+      result,
+      childTableName,
+      childRowHash,
+      parentTableName,
+      parentRowHash
+    );
+  }
+};
+const _writeBuffetRefs = (parentTableName, parentRow, result) => {
+  const parentRowHash = parentRow._hash;
+  for (const item of parentRow.items) {
+    const childTableName = item.table;
+    const childRowHash = item.ref;
+    _write(
+      result,
+      childTableName,
+      childRowHash,
+      parentTableName,
+      parentRowHash
+    );
+  }
+};
+const _write = (result, childTableName, childRowHash, parentTableName, parentRowHash) => {
+  var _a;
+  const referencesForChildTable = result[childTableName] ?? (result[childTableName] = {});
+  const referencesForChildTableRow = referencesForChildTable[childRowHash] ?? (referencesForChildTable[childRowHash] = {});
+  referencesForChildTableRow[parentTableName] ?? (referencesForChildTableRow[parentTableName] = {});
+  (_a = referencesForChildTableRow[parentTableName])[parentRowHash] ?? (_a[parentRowHash] = {});
+};
 export {
   IoMem,
+  IoTools,
+  calcReverseRefs,
   exampleIo
 };

package/dist/src/example.ts

@@ -17,11 +17,15 @@ export const example = async () => {
   const rowWithHash = hsh(row);
 
   // Create a table config first
-  const tableCfg = hip({
+  const tableCfg = hip<TableCfg>({
     key: 'tableA',
     type: 'ingredients',
-    columns: {},
-  } as TableCfg);
+    columns: [],
+    version: 1,
+    isHead: true,
+    isRoot: true,
+    isShared: false,
+  });
 
   await ioMem.write({
     data: {
@@ -33,7 +37,7 @@ export const example = async () => {
   });
 
   // Create a table first
-  await ioMem.createTable({ tableCfg: tableCfg });
+  await ioMem.createOrExtendTable({ tableCfg: tableCfg });
 
   // Write data into the table
   await ioMem.write({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rljson/io",
-  "version": "0.0.21",
+  "version": "0.0.23",
   "packageManager": "pnpm@10.6.2",
   "description": "Low level interface for reading and writing RLJSON data",
   "homepage": "https://github.com/rljson/io",
@@ -29,24 +29,24 @@
     "updateGoldens": "cross-env UPDATE_GOLDENS=true pnpm test"
   },
   "devDependencies": {
-    "@types/node": "^22.14.1",
-    "@typescript-eslint/eslint-plugin": "^8.30.1",
-    "@typescript-eslint/parser": "^8.30.1",
-    "@vitest/coverage-v8": "^3.1.1",
+    "@types/node": "^22.15.2",
+    "@typescript-eslint/eslint-plugin": "^8.31.0",
+    "@typescript-eslint/parser": "^8.31.0",
+    "@vitest/coverage-v8": "^3.1.2",
     "cross-env": "^7.0.3",
-    "eslint": "^9.24.0",
-    "eslint-plugin-jsdoc": "^50.6.9",
+    "eslint": "^9.25.1",
+    "eslint-plugin-jsdoc": "^50.6.11",
     "eslint-plugin-tsdoc": "^0.4.0",
     "globals": "^16.0.0",
     "jsdoc": "^4.0.4",
     "read-pkg": "^9.0.1",
     "typescript": "~5.8.3",
-    "typescript-eslint": "^8.30.1",
-    "vite": "^6.2.6",
-    "vite-node": "^3.1.1",
+    "typescript-eslint": "^8.31.0",
+    "vite": "^6.3.3",
+    "vite-node": "^3.1.2",
     "vite-plugin-dts": "^4.5.3",
     "vite-tsconfig-paths": "^5.1.4",
-    "vitest": "^3.1.1",
+    "vitest": "^3.1.2",
     "vitest-dom": "^0.1.1"
   },
   "pnpm": {
@@ -56,10 +56,10 @@
     "overrides": {}
   },
   "dependencies": {
-    "@rljson/hash": "^0.0.13",
+    "@rljson/hash": "^0.0.15",
     "@rljson/is-ready": "^0.0.17",
-    "@rljson/json": "^0.0.18",
-    "@rljson/rljson": "^0.0.38",
-    "@rljson/validate": "^0.0.9"
+    "@rljson/json": "^0.0.21",
+    "@rljson/rljson": "^0.0.42",
+    "@rljson/validate": "^0.0.10"
   }
 }

package/dist/io-init.d.ts

@@ -1,11 +0,0 @@
-import { TableCfg } from '@rljson/rljson';
-import { Io } from './io.ts';
-/**
- * Initialization tools for Io
- */
-export declare class IoInit {
-    readonly io: Io;
-    constructor(io: Io);
-    get tableCfg(): TableCfg;
-    initRevisionsTable: () => Promise<void>;
-}