@rljson/io 0.0.20 → 0.0.22

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,21 @@ 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,40 @@
+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);
+    /**
+     * Example object for test purposes
+     * @returns An instance of io tools
+     */
+    static example: () => Promise<IoTools>;
+    /**
+     * Returns a list with all table names
+     */
+    allTableNames(): 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,7 +3,7 @@ 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";
 // @license
 class IoInit {
   constructor(io) {
@@ -15,15 +15,15 @@ class IoInit {
         isHead: false,
         isRoot: false,
         isShared: true,
-        columns: {
-          table: { type: "string" },
-          predecessor: { type: "string" },
-          successor: { type: "string" },
-          timestamp: { type: "number" },
-          id: { type: "string" }
-        }
+        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;
   }
@@ -35,15 +35,117 @@ class IoInit {
       isHead: false,
       isRoot: false,
       isShared: true,
-      columns: {
-        key: { type: "string" },
-        type: { type: "string" }
-      }
+      columns: [
+        { key: "key", type: "string" },
+        { key: "type", type: "string" }
+      ]
     });
     return tableCfg;
   }
 }
 // @license
+const _IoTools = class _IoTools {
+  /**
+   * Constructor
+   * @param io The Io interface to use
+   */
+  constructor(io) {
+    this.io = io;
+  }
+  /**
+   * Returns a list with all table names
+   */
+  async allTableNames() {
+    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 {
   // ...........................................................................
   // Constructor & example
@@ -51,6 +153,7 @@ const _IoMem = class _IoMem {
     // ######################
     // Private
     // ######################
+    __publicField(this, "_ioTools");
     __publicField(this, "_isReady", new IsReady());
     __publicField(this, "_mem", hip({}));
     __publicField(this, "_ioInit");
@@ -84,6 +187,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 +201,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 +223,19 @@ const _IoMem = class _IoMem {
       }
     });
   }
-  async allTableNames() {
-    const tables = Object.keys(this._mem).filter((key) => !key.startsWith("_"));
-    return tables;
-  }
   // ...........................................................................
   async _init() {
+    this._ioTools = new IoTools(this);
     this._ioInit = new IoInit(this);
     this._initTableCfgs();
     await this._ioInit.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 +243,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,7 +322,7 @@ const _IoMem = class _IoMem {
     return result;
   }
 };
-__publicField(_IoMem, "example", () => {
+__publicField(_IoMem, "example", async () => {
   return new _IoMem();
 });
 let IoMem = _IoMem;

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.20",
+  "version": "0.0.22",
   "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.13.17",
-    "@typescript-eslint/eslint-plugin": "^8.29.0",
-    "@typescript-eslint/parser": "^8.29.0",
-    "@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.23.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.2",
-    "typescript-eslint": "^8.29.0",
-    "vite": "^6.2.4",
-    "vite-node": "^3.1.1",
+    "typescript": "~5.8.3",
+    "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": {
@@ -59,7 +59,7 @@
     "@rljson/hash": "^0.0.13",
     "@rljson/is-ready": "^0.0.17",
     "@rljson/json": "^0.0.18",
-    "@rljson/rljson": "^0.0.37",
-    "@rljson/validate": "^0.0.9"
+    "@rljson/rljson": "^0.0.40",
+    "@rljson/validate": "^0.0.10"
   }
 }