@rljson/rljson 0.0.14 → 0.0.16

package/dist/example.d.ts

@@ -10,16 +10,21 @@ export declare class Example {
         complete: () => Rljson;
     };
     static readonly broken: {
-        brokenTableName: () => {
-            brok$en: {
-                _type: string;
-                _data: never[];
+        base: {
+            brokenTableName: () => {
+                brok$en: {
+                    _type: string;
+                    _data: never[];
+                };
             };
+            missingData: () => Rljson;
+            dataNotBeingAnArray: () => Rljson;
+            missingRef: () => Rljson;
+            missingReferencedTable: () => Rljson;
+        };
+        tableCfg: {
+            wrongType: () => import('@rljson/hash').Hashed<Rljson>;
         };
-        missingData: () => Rljson;
-        dataNotBeingAnArray: () => Rljson;
-        missingRef: () => Rljson;
-        missingReferencedTable: () => Rljson;
         collections: {
             missingBase: () => Rljson;
             missingIdSet: () => Rljson;

package/dist/index.d.ts

@@ -3,7 +3,11 @@ export * from './content/cake.ts';
 export * from './content/collection.ts';
 export * from './content/id-set.ts';
 export * from './content/properties.ts';
+export * from './content/table-cfg.ts';
 export * from './example.ts';
+export * from './example/bakery-example.ts';
 export * from './rljson-indexed.ts';
 export * from './rljson.ts';
 export * from './typedefs.ts';
+export * from './validate/base-validator.ts';
+export * from './validate/validate.ts';

package/dist/rljson.d.ts

@@ -4,6 +4,7 @@ import { CakesTable } from './content/cake.ts';
 import { CollectionsTable } from './content/collection.ts';
 import { IdSetsTable } from './content/id-set.ts';
 import { PropertiesTable } from './content/properties.ts';
+import { TableCfgRef, TablesCfgTable } from './content/table-cfg.ts';
 import { ContentType, Ref, TableName } from './typedefs.ts';
 export declare const reservedFieldNames: string[];
 export declare const reservedTableNames: string[];
@@ -19,15 +20,26 @@ export interface Rljson extends Json {
  * Rljson set with private fields
  */
 export type RljsonPrivate = {
+    /**
+     * The hash of the Rljson object
+     */
+    _hash: string;
     /**
      * Contains id sets used accross the Rljson object
      */
-    _idSets: IdSetsTable;
+    _idSet?: IdSetsTable;
+    /**
+     * References that are not part of the Rljson object
+     */
+    _externalRefs?: Ref[];
+    /**
+     * Referenced tables that are not part of the Rljson object
+     */
+    _externalTables?: Ref[];
     /**
-     * Used by validation. If external references are not present,
-     * validation does not throw an error.
+     * Column configurations used accross the Rljson object
      */
-    _externalRefs: Ref[];
+    _tableCfgs?: TablesCfgTable;
 };
 /** An example rljson object */
 export declare const exampleRljson: () => Rljson;
@@ -37,6 +49,8 @@ export interface RljsonTable<Data extends Json, Type extends ContentType> extend
     _data: Data[];
     /**  The type of the table. If not set, the type is "properties" */
     _type: Type;
+    /** The columns configuration of the table */
+    _tableCfg?: TableCfgRef;
 }
 /**
  * Iterates over all tables of an Rljson object.

package/dist/rljson.js

@@ -2,99 +2,92 @@ 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 { hip, hsh } from "@rljson/hash";
-import { exampleJsonObject } from "@rljson/json";
+import { exampleJsonObject, jsonValueTypes, jsonValueMatchesType } from "@rljson/json";
 // @license
 const bakeryExample = () => {
-  return {
-    // Every rljson object has a list of id-sets other objects can refer to
+  const result = {
     _idSets: {
       _type: "idSets",
       _data: [
         {
           add: ["slice0", "slice1"],
-          _hash: "KAwCRFD4mdx8b1bzxBb2_O"
+          _hash: "Ko990SJfgPJvNGxC63CRf7"
         }
-      ]
+      ],
+      _hash: "NiojsJvZ7iEU7WeMWttzyJ"
     },
-    // A bakery offers a variety of buffets containing different pastries
     buffets: {
       _type: "buffets",
       _data: [
         {
-          items: [{ table: "cakes", ref: "fw8IrV05Z1ZekPXTdUdmt8" }]
+          items: [
+            {
+              table: "cakes",
+              ref: "KdLv3zTftqKKUeqYrTtO2r"
+            }
+          ]
         }
       ]
     },
-    // A cake is a collection of layers, i.e. a base, a filling and a topping.
-    // Each layer of the cake has the same slice structure.
     cakes: {
       _type: "cakes",
       _data: [
         {
-          idSet: "KAwCRFD4mdx8b1bzxBb2_O",
+          idSet: "Ko990SJfgPJvNGxC63CRf7",
           collections: "layers",
           layers: {
-            _hash: "50ZHxZ8KeUYJ3NC7ax5CbR"
+            _hash: "RBNvo1WzZ4oRRq0W9-hknp"
           },
-          _hash: "gMqFPTkYU66L32jDYZiZ79"
+          _hash: "KdLv3zTftqKKUeqYrTtO2r"
         }
-      ],
-      _hash: "fw8IrV05Z1ZekPXTdUdmt8"
+      ]
     },
-    // Cakes are cut into slices. The cake layers are shared among the slices.
     slices: {
       _type: "idSets",
       _data: [
         {
           add: ["slice0", "slice1"],
-          remove: []
+          remove: [],
+          _hash: "wyYfK5E4ArrMKQ_zvi2-EE"
         }
-      ]
+      ],
+      _hash: "Qt6FzyzwHdEdYC3fKUXaAm"
     },
-    // A layer is a collection of ingredients described by a recipe
     layers: {
       _type: "collections",
       _data: [
         {
           properties: "recipes",
           assign: {
-            slice0: "VXUW79JrkOAG_pQ-75ahH5",
-            slice1: "VXUW79JrkOAG_pQ-75ahH5",
-            _hash: "Di4uG3-DHSq3_ArFu0V68m"
-          },
-          _hash: "IIg0e-6Qr73s7sNZe0RhKs"
+            slice0: "uRTo_Jmt9lOA09e2QnwB9W",
+            slice1: "uRTo_Jmt9lOA09e2QnwB9W"
+          }
         }
-      ],
-      _hash: "e3utfEf_VS1-ljAMgqesua"
+      ]
     },
-    // Recipes are sets of ingredients
     recipes: {
       _type: "collections",
       _data: [
         {
           properties: "recipeIngredients",
           assign: {
-            flour: "mqLl7Q44V1t2MotJvaVRM_",
-            _hash: "UImWlyWZTSGhNAMC1JUzF1"
+            flour: "RCA4yzQe6mYOqquoLijKop"
           },
-          _hash: "G1YV_P8-_vTxtkXXHJeNBI"
+          _hash: "uRTo_Jmt9lOA09e2QnwB9W"
         }
-      ],
-      _hash: "r3lw7VsnywyasRmtynZqIt"
+      ]
     },
-    // A recipe ingredient combines an ingredient type with a quantity
     recipeIngredients: {
       _type: "properties",
       _data: [
         {
-          ingredientTypesRef: "WOfnFT1svec3iJ6x",
+          ingredientsRef: "CdSJV-WOfnFT1svec3iJ6x",
           quantity: 500,
-          _hash: "mqLl7Q44V1t2MotJvaVRM_"
+          _hash: "RCA4yzQe6mYOqquoLijKop"
         }
       ],
-      _hash: "J7GJEjCRXLNfdAHARg_fzx"
+      _hash: "R6dJq4ZJ3QDa9Bz8QJDhNq"
     },
-    // A table describing basic properties of ingredients
     ingredients: {
       _type: "properties",
       _data: [
@@ -107,7 +100,6 @@ const bakeryExample = () => {
       ],
       _hash: "FgJeTM0NcZvXwFcU-PD8Jf"
     },
-    // A table with nutritive values of ingredients
     nutritiveValues: {
       _type: "properties",
       _data: [
@@ -122,6 +114,7 @@ const bakeryExample = () => {
       _hash: "7k4OqQtk71w3yVGMoA9F6p"
     }
   };
+  return result;
 };
 // @license
 const exampleBuffetsTable = () => bakeryExample().buffets;
@@ -155,12 +148,77 @@ __publicField(_Example, "ok", {
     };
   },
   singleRow: () => {
-    return {
+    const tableCfgs = {
+      _hash: "",
+      _type: "properties",
+      _data: [
+        {
+          _hash: "R-rCQ4YwYYJAp6uAo6S_6n",
+          name: "Single Row Table",
+          jsonKey: "table",
+          columns: {
+            int: {
+              jsonKey: "int",
+              type: "number",
+              name: "Integer",
+              nameShort: "Int"
+            },
+            double: {
+              jsonKey: "double",
+              type: "number",
+              name: "Double",
+              nameShort: "Dbl"
+            },
+            string: {
+              jsonKey: "string",
+              type: "string",
+              name: "String",
+              nameShort: "Str"
+            },
+            boolean: {
+              jsonKey: "boolean",
+              type: "boolean",
+              name: "Boolean",
+              nameShort: "Bool"
+            },
+            null: {
+              jsonKey: "null",
+              type: "null",
+              name: "null",
+              nameShort: "null"
+            },
+            jsonArray: {
+              jsonKey: "jsonArray",
+              type: "jsonArray",
+              name: "Json Array",
+              nameShort: "Jarray"
+            },
+            json: {
+              jsonKey: "json",
+              type: "json",
+              name: "Json",
+              nameShort: "Json"
+            },
+            jsonValue: {
+              jsonKey: "jsonValue",
+              type: "jsonValue",
+              name: "Json Value",
+              nameShort: "Jval"
+            }
+          }
+        }
+      ]
+    };
+    const result = {
+      _tableCfgs: tableCfgs,
       table: {
         _type: "properties",
-        _data: [exampleJsonObject()]
+        _tableCfg: "R-rCQ4YwYYJAp6uAo6S_6n",
+        _data: [exampleJsonObject()],
+        _hash: ""
       }
     };
+    return result;
   },
   multipleRows: () => {
     return {
@@ -289,65 +347,75 @@ __publicField(_Example, "ok", {
   }
 });
 __publicField(_Example, "broken", {
-  brokenTableName: () => {
-    return {
-      brok$en: {
-        _type: "properties",
-        _data: []
-      }
-    };
-  },
-  missingData: () => {
-    return {
-      table: {
-        _type: "properties"
-      }
-    };
-  },
-  dataNotBeingAnArray: () => {
-    return {
-      table: {
-        _type: "properties",
-        _data: {}
-      }
-    };
-  },
-  missingRef: () => {
-    return {
-      tableA: {
-        _type: "properties",
-        _data: [
-          {
-            keyA0: "a0"
-          },
-          {
-            keyA1: "a1"
-          }
-        ]
-      },
-      tableB: {
-        _type: "properties",
-        _data: [
-          {
-            tableARef: "MISSINGREF"
-            // MISSINGREF does not exist in tableA
-          }
-        ]
-      }
-    };
+  base: {
+    brokenTableName: () => {
+      return {
+        brok$en: {
+          _type: "properties",
+          _data: []
+        }
+      };
+    },
+    missingData: () => {
+      return {
+        table: {
+          _type: "properties"
+        }
+      };
+    },
+    dataNotBeingAnArray: () => {
+      return {
+        table: {
+          _type: "properties",
+          _data: {}
+        }
+      };
+    },
+    missingRef: () => {
+      return {
+        tableA: {
+          _type: "properties",
+          _data: [
+            {
+              keyA0: "a0"
+            },
+            {
+              keyA1: "a1"
+            }
+          ]
+        },
+        tableB: {
+          _type: "properties",
+          _data: [
+            {
+              tableARef: "MISSINGREF"
+              // MISSINGREF does not exist in tableA
+            }
+          ]
+        }
+      };
+    },
+    missingReferencedTable: () => {
+      return {
+        tableB: {
+          _type: "properties",
+          _data: [
+            {
+              tableARef: "MISSINGREF"
+              // tableA is missing
+            }
+          ]
+        }
+      };
+    }
   },
-  missingReferencedTable: () => {
-    return {
-      tableB: {
-        _type: "properties",
-        _data: [
-          {
-            tableARef: "MISSINGREF"
-            // tableA is missing
-          }
-        ]
-      }
-    };
+  tableCfg: {
+    wrongType: () => {
+      const result = _Example.ok.singleRow();
+      const tableCfg = result._tableCfgs._data[0];
+      tableCfg.columns["int"].type = "numberBroken";
+      return hip(result, true, false);
+    }
   },
   collections: {
     missingBase: () => {
@@ -415,6 +483,8 @@ __publicField(_Example, "broken", {
 });
 let Example = _Example;
 // @license
+const exampleTableCfgTable = () => Example.ok.singleRow()._tableCfgs;
+// @license
 const rljsonIndexed = (rljson) => {
   const result = {};
   for (const key in rljson) {
@@ -459,15 +529,676 @@ const exampleTypedefs = () => {
     contentType: "collections"
   };
 };
+// @license
+class BaseValidator {
+  constructor() {
+    __publicField(this, "name", "syntax");
+  }
+  async validate(rljson) {
+    return this.validateSync(rljson);
+  }
+  validateSync(rljson) {
+    return new _BaseValidator(rljson).validate();
+  }
+  static isValidFieldName(fieldName) {
+    return /^[a-z][a-zA-Z0-9]*$/.test(fieldName);
+  }
+}
+class _BaseValidator {
+  constructor(rljson) {
+    __publicField(this, "errors", { hasErrors: false });
+    // ######################
+    // Private
+    // ######################
+    __publicField(this, "tableNames");
+    __publicField(this, "rljsonIndexed");
+    this.rljson = rljson;
+    this.tableNames = Object.keys(this.rljson).filter(
+      (table) => !table.startsWith("_")
+    );
+    this.rljsonIndexed = rljsonIndexed(rljson);
+  }
+  get hasErrors() {
+    return Object.keys(this.errors).length > 1;
+  }
+  validate() {
+    const steps = [
+      // Base checks
+      () => this._writeAndValidHashes(),
+      () => this._tableNamesNotLowerCamelCase(),
+      () => this._tableNamesDoNotEndWithRef(),
+      () => this._columnNamesNotLowerCamelCase(),
+      () => this._dataNotFound(),
+      () => this._dataHasWrongType(),
+      // Check table cfg
+      () => this._tableCfgsReferencedTableNameNotFound(),
+      () => this._tableCfgsHaveWrongType(),
+      () => this._tableCfgNotFound(),
+      () => this._missingColumnConfigs(),
+      () => this._dataDoesNotMatchColumnConfig(),
+      // Check references
+      () => this._refsNotFound(),
+      // Check collections
+      () => this._collectionBasesNotFound(),
+      () => this._collectionIdSetsExist(),
+      () => this._collectionPropertyAssignmentsNotFound(),
+      // Check cakes
+      () => this._cakeIdSetsNotFound(),
+      () => this._cakeCollectionTablesNotFound(),
+      // Check buffets
+      () => this._buffetReferencedTableNotFound()
+    ];
+    for (const step of steps) {
+      step();
+      if (this.hasErrors) {
+        break;
+      }
+    }
+    this.errors.hasErrors = this.hasErrors;
+    return this.errors;
+  }
+  _tableNamesNotLowerCamelCase() {
+    const invalidTableNames = [];
+    for (const tableName of this.tableNames) {
+      if (!BaseValidator.isValidFieldName(tableName)) {
+        invalidTableNames.push(tableName);
+      }
+    }
+    if (invalidTableNames.length > 0) {
+      this.errors.tableNamesNotLowerCamelCase = {
+        error: "Table names must be lower camel case",
+        invalidTableNames
+      };
+    }
+  }
+  // ...........................................................................
+  _tableNamesDoNotEndWithRef() {
+    const invalidTableNames = [];
+    for (const tableName of this.tableNames) {
+      if (tableName.endsWith("Ref")) {
+        invalidTableNames.push(tableName);
+      }
+    }
+    if (invalidTableNames.length > 0) {
+      this.errors.tableNamesDoNotEndWithRef = {
+        error: 'Table names must not end with "Ref"',
+        invalidTableNames
+      };
+    }
+  }
+  // ...........................................................................
+  _columnNamesNotLowerCamelCase() {
+    const invalidColumnNames = {};
+    let hadErrors = false;
+    for (const tableName of this.tableNames) {
+      const table = this.rljson[tableName];
+      if (!table._data || !Array.isArray(table._data)) {
+        continue;
+      }
+      for (const row of table._data) {
+        for (const columnName in row) {
+          if (columnName.startsWith("_")) {
+            continue;
+          }
+          if (!BaseValidator.isValidFieldName(columnName)) {
+            invalidColumnNames[tableName] ?? (invalidColumnNames[tableName] = []);
+            invalidColumnNames[tableName].push(columnName);
+            hadErrors = true;
+          }
+        }
+      }
+    }
+    if (hadErrors) {
+      this.errors.columnNamesNotLowerCamelCase = {
+        error: "Column names must be lower camel case",
+        invalidColumnNames
+      };
+    }
+  }
+  // ...........................................................................
+  _writeAndValidHashes() {
+    try {
+      this.rljson = hsh(this.rljson, {
+        inPlace: false,
+        updateExistingHashes: true,
+        throwOnWrongHashes: true
+      });
+    } catch (error) {
+      if (error instanceof Error) {
+        this.errors.hashesNotValid = {
+          error: error.message
+        };
+      } else {
+        this.errors.hashesNotValid = {
+          error: "Unknown error"
+        };
+      }
+    }
+  }
+  // ...........................................................................
+  /// Checks if data is valid
+  _dataNotFound() {
+    const rljson = this.rljson;
+    const tablesWithMissingData = [];
+    for (const table of this.tableNames) {
+      const tableData = rljson[table];
+      const items = tableData["_data"];
+      if (items == null) {
+        tablesWithMissingData.push(table);
+      }
+    }
+    if (tablesWithMissingData.length > 0) {
+      this.errors.dataNotFound = {
+        error: "_data is missing in tables",
+        tables: tablesWithMissingData
+      };
+    }
+  }
+  // ...........................................................................
+  _tableCfgsReferencedTableNameNotFound() {
+    const tableCfgs = this.rljson._tableCfgs;
+    if (!tableCfgs) {
+      return;
+    }
+    const brokenCfgs = [];
+    for (const item of tableCfgs._data) {
+      const table = this.rljson[item.jsonKey];
+      if (!table) {
+        brokenCfgs.push({
+          brokenTableCfg: item._hash,
+          tableNameNotFound: item.jsonKey
+        });
+      }
+    }
+    if (brokenCfgs.length > 0) {
+      this.errors.tableCfgsReferencedTableNameNotFound = {
+        error: "Tables referenced in _tableCfgs not found",
+        brokenCfgs
+      };
+    }
+  }
+  // ...........................................................................
+  _tableCfgsHaveWrongType() {
+    const tableCfgs = this.rljson._tableCfgs;
+    if (!tableCfgs) {
+      return;
+    }
+    const brokenCfgs = [];
+    for (const item of tableCfgs._data) {
+      for (const columnKey in item.columns) {
+        if (columnKey.startsWith("_")) {
+          continue;
+        }
+        const column = item.columns[columnKey];
+        if (jsonValueTypes.indexOf(column.type) === -1) {
+          brokenCfgs.push({
+            brokenTableCfg: item._hash,
+            brokenColumnKey: columnKey,
+            brokenColumnType: column.type
+          });
+        }
+      }
+    }
+    if (brokenCfgs.length > 0) {
+      this.errors.tableCfgsHaveWrongTypes = {
+        error: "Some of the columns have invalid types. Valid types are: " + jsonValueTypes.join(", "),
+        brokenCfgs
+      };
+    }
+  }
+  // ...........................................................................
+  _tableCfgNotFound() {
+    const tableCfgs = this.rljsonIndexed._tableCfgs;
+    const tableCfgNotFound = [];
+    iterateTables(this.rljson, (tableName, table) => {
+      const tableCfgRef = table._tableCfg;
+      if (!tableCfgRef) {
+        return;
+      }
+      const tableCfgData = tableCfgs._data[tableCfgRef];
+      if (!tableCfgData) {
+        tableCfgNotFound.push({
+          tableWithBrokenTableCfgRef: tableName,
+          brokenTableCfgRef: tableCfgRef
+        });
+        return;
+      }
+    });
+    if (tableCfgNotFound.length > 0) {
+      this.errors.tableCfgReferencedNotFound = {
+        error: "Referenced table config not found",
+        tableCfgNotFound
+      };
+    }
+  }
+  // ...........................................................................
+  _missingColumnConfigs() {
+    const tableCfgs = this.rljsonIndexed._tableCfgs;
+    const missingColumnConfigs = [];
+    iterateTables(this.rljson, (tableName, table) => {
+      const tableCfgRef = table._tableCfg;
+      if (!tableCfgRef) {
+        return;
+      }
+      const tableCfgData = tableCfgs._data[tableCfgRef];
+      const processedColumnKeys = [];
+      for (const row of table._data) {
+        const columnKeys = Object.keys(row).filter(
+          (key) => !key.startsWith("_")
+        );
+        const newColumnKey = columnKeys.filter(
+          (key) => processedColumnKeys.indexOf(key) === -1
+        );
+        for (const columnKey of newColumnKey) {
+          if (!tableCfgData.columns[columnKey]) {
+            missingColumnConfigs.push({
+              tableCfg: tableCfgRef,
+              row: row._hash,
+              column: columnKey,
+              table: tableName
+            });
+          }
+          processedColumnKeys.push(columnKey);
+        }
+      }
+    });
+    if (missingColumnConfigs.length > 0) {
+      this.errors.columnConfigNotFound = {
+        error: "Column configurations not found",
+        missingColumnConfigs
+      };
+    }
+  }
+  // ...........................................................................
+  _dataDoesNotMatchColumnConfig() {
+    const tableCfgs = this.rljsonIndexed._tableCfgs;
+    const brokenValues = [];
+    iterateTables(this.rljson, (tableName, table) => {
+      const tableCfgRef = table._tableCfg;
+      if (!tableCfgRef) {
+        return;
+      }
+      const tableCfgData = tableCfgs._data[tableCfgRef];
+      for (const row of table._data) {
+        const columnKeys = Object.keys(row).filter(
+          (key) => !key.startsWith("_")
+        );
+        for (const columnKey of columnKeys) {
+          const columnConfig = tableCfgData.columns[columnKey];
+          const value = row[columnKey];
+          if (value == null || value == void 0) {
+            continue;
+          }
+          const typeShould = columnConfig.type;
+          if (!jsonValueMatchesType(value, typeShould)) {
+            brokenValues.push({
+              table: tableName,
+              row: row._hash,
+              column: columnKey,
+              tableCfg: tableCfgRef
+            });
+          }
+        }
+      }
+    });
+    if (brokenValues.length > 0) {
+      this.errors.dataDoesNotMatchColumnConfig = {
+        error: "Table values have wrong types",
+        brokenValues
+      };
+    }
+  }
+  // ...........................................................................
+  _dataHasWrongType() {
+    const rljson = this.rljson;
+    const tablesWithWrongType = [];
+    for (const tableName of this.tableNames) {
+      const tableData = rljson[tableName];
+      const items = tableData["_data"];
+      if (!Array.isArray(items)) {
+        tablesWithWrongType.push(tableName);
+      }
+    }
+    if (tablesWithWrongType.length > 0) {
+      this.errors.dataHasWrongType = {
+        error: "_data must be a list",
+        tables: tablesWithWrongType
+      };
+    }
+  }
+  _refsNotFound() {
+    const missingRefs = [];
+    iterateTables(this.rljson, (tableName, table) => {
+      const tableData = table._data;
+      for (const item of tableData) {
+        for (const key of Object.keys(item)) {
+          if (key.endsWith("Ref")) {
+            const targetItemHash = item[key];
+            const targetTableName = key.substring(0, key.length - 3);
+            const itemHash = item._hash;
+            if (this.tableNames.indexOf(targetTableName) === -1) {
+              missingRefs.push({
+                error: `Target table "${targetTableName}" not found.`,
+                sourceTable: tableName,
+                sourceKey: key,
+                sourceItemHash: itemHash,
+                targetItemHash,
+                targetTable: targetTableName
+              });
+              continue;
+            }
+            const targetTableIndexed = this.rljsonIndexed[targetTableName];
+            const referencedItem = targetTableIndexed._data[targetItemHash];
+            if (referencedItem === void 0) {
+              missingRefs.push({
+                sourceTable: tableName,
+                sourceItemHash: itemHash,
+                sourceKey: key,
+                targetItemHash,
+                targetTable: targetTableName,
+                error: `Table "${targetTableName}" has no item with hash "${targetItemHash}"`
+              });
+            }
+          }
+        }
+      }
+    });
+    if (missingRefs.length > 0) {
+      this.errors.refsNotFound = {
+        error: "Broken references",
+        missingRefs
+      };
+    }
+  }
+  _collectionBasesNotFound() {
+    const brokenCollections = [];
+    iterateTables(this.rljson, (tableName, table) => {
+      if (table._type !== "collections") {
+        return;
+      }
+      const collectionsIndexed = this.rljsonIndexed[tableName];
+      const collectionsTable = table;
+      for (const collection of collectionsTable._data) {
+        const baseRef = collection.base;
+        if (!baseRef) {
+          continue;
+        }
+        const baseCollection = collectionsIndexed._data[baseRef];
+        if (!baseCollection) {
+          brokenCollections.push({
+            collectionsTable: tableName,
+            brokenCollection: collection._hash,
+            missingBaseCollection: baseRef
+          });
+        }
+      }
+    });
+    if (brokenCollections.length > 0) {
+      this.errors.collectionBasesNotFound = {
+        error: "Base collections are missing",
+        brokenCollections
+      };
+    }
+  }
+  _collectionIdSetsExist() {
+    const brokenCollections = [];
+    iterateTables(this.rljson, (tableName, table) => {
+      if (table._type !== "collections") {
+        return;
+      }
+      const idSets = this.rljsonIndexed._idSets;
+      const collectionsTable = table;
+      for (const collection of collectionsTable._data) {
+        const idSetRef = collection.idSet;
+        if (!idSetRef) {
+          continue;
+        }
+        const idSet = idSets._data[idSetRef];
+        if (!idSet) {
+          brokenCollections.push({
+            collectionsTable: tableName,
+            collectionHash: collection._hash,
+            missingIdSet: idSetRef
+          });
+        }
+      }
+    });
+    if (brokenCollections.length > 0) {
+      this.errors.collectionIdSetsExist = {
+        error: "Id sets of collections are missing",
+        brokenCollections
+      };
+    }
+  }
+  _collectionPropertyAssignmentsNotFound() {
+    const missingPropertyTables = [];
+    const brokenAssignments = [];
+    iterateTables(this.rljson, (tableName, table) => {
+      if (table._type !== "collections") {
+        return;
+      }
+      const collectionsTable = table;
+      for (const collection of collectionsTable._data) {
+        const propertyTableName = collection.properties;
+        const propertiesTable = this.rljsonIndexed[propertyTableName];
+        if (!propertiesTable) {
+          missingPropertyTables.push({
+            brokenCollection: collection._hash,
+            collectionsTable: tableName,
+            missingPropertyTable: propertyTableName
+          });
+          continue;
+        }
+        const assignments = collection.assign;
+        for (const itemId in assignments) {
+          if (itemId.startsWith("_")) {
+            continue;
+          }
+          const propertyHash = assignments[itemId];
+          if (!propertiesTable._data[propertyHash]) {
+            brokenAssignments.push({
+              collectionsTable: tableName,
+              brokenCollection: collection._hash,
+              referencedPropertyTable: propertyTableName,
+              brokenAssignment: itemId,
+              missingProperty: propertyHash
+            });
+          }
+        }
+      }
+    });
+    if (missingPropertyTables.length > 0) {
+      this.errors.collectionPropertyTablesNotFound = {
+        error: "Collection property tables do not exist",
+        collections: missingPropertyTables
+      };
+    }
+    if (brokenAssignments.length > 0) {
+      this.errors.collectionPropertyAssignmentsNotFound = {
+        error: "Collection property assignments are broken",
+        brokenAssignments
+      };
+    }
+  }
+  _cakeIdSetsNotFound() {
+    const brokenCakes = [];
+    iterateTables(this.rljson, (tableName, table) => {
+      if (table._type !== "cakes") {
+        return;
+      }
+      const idSets = this.rljsonIndexed._idSets;
+      const cakesTable = table;
+      for (const cake of cakesTable._data) {
+        const idSetRef = cake.idSet;
+        if (!idSetRef) {
+          continue;
+        }
+        const idSet = idSets._data[idSetRef];
+        if (!idSet) {
+          brokenCakes.push({
+            cakeTable: tableName,
+            brokenCake: cake._hash,
+            missingIdSet: idSetRef
+          });
+        }
+      }
+    });
+    if (brokenCakes.length > 0) {
+      this.errors.cakeIdSetsNotFound = {
+        error: "Id sets of cakes are missing",
+        brokenCakes
+      };
+    }
+  }
+  _cakeCollectionTablesNotFound() {
+    const missingCollectionTables = [];
+    const missingLayerCollections = [];
+    iterateTables(this.rljson, (tableName, table) => {
+      if (table._type !== "cakes") {
+        return;
+      }
+      const cakesTable = table;
+      for (const cake of cakesTable._data) {
+        const collectionsTableName = cake.collections;
+        const collectionsTable = this.rljsonIndexed[collectionsTableName];
+        if (!collectionsTable) {
+          missingCollectionTables.push({
+            cakeTable: tableName,
+            brokenCake: cake._hash,
+            missingCollectionsTable: collectionsTableName
+          });
+          continue;
+        }
+        for (const layer in cake.layers) {
+          if (layer.startsWith("_")) {
+            continue;
+          }
+          const collectionRef = cake.layers[layer];
+          const collection = collectionsTable._data[collectionRef];
+          if (!collection) {
+            missingLayerCollections.push({
+              cakeTable: tableName,
+              brokenCake: cake._hash,
+              brokenLayerName: layer,
+              collectionsTable: collectionsTableName,
+              missingCollection: collectionRef
+            });
+          }
+        }
+      }
+    });
+    if (missingCollectionTables.length > 0) {
+      this.errors.cakeCollectionTablesNotFound = {
+        error: "Collection tables of cakes are missing",
+        brokenCakes: missingCollectionTables
+      };
+    }
+    if (missingLayerCollections.length > 0) {
+      this.errors.cakeLayerCollectionsNotFound = {
+        error: "Layer collections of cakes are missing",
+        brokenCakes: missingLayerCollections
+      };
+    }
+  }
+  _buffetReferencedTableNotFound() {
+    const missingTables = [];
+    const missingItems = [];
+    iterateTables(this.rljson, (tableName, table) => {
+      if (table._type !== "buffets") {
+        return;
+      }
+      const buffetsTable = table;
+      for (const buffet of buffetsTable._data) {
+        for (const item of buffet.items) {
+          const itemTableName = item.table;
+          const itemTable = this.rljsonIndexed[itemTableName];
+          if (!itemTable) {
+            missingTables.push({
+              buffetTable: tableName,
+              brokenBuffet: buffet._hash,
+              missingItemTable: itemTableName
+            });
+            continue;
+          }
+          const ref = item.ref;
+          const referencedItem = itemTable._data[ref];
+          if (!referencedItem) {
+            missingItems.push({
+              buffetTable: tableName,
+              brokenBuffet: buffet._hash,
+              itemTable: itemTableName,
+              missingItem: ref
+            });
+          }
+        }
+      }
+    });
+    if (missingTables.length > 0) {
+      this.errors.buffetReferencedTablesNotFound = {
+        error: "Referenced tables of buffets are missing",
+        brokenBuffets: missingTables
+      };
+    }
+    if (missingItems.length > 0) {
+      this.errors.buffetReferencedItemsNotFound = {
+        error: "Referenced items of buffets are missing",
+        brokenItems: missingItems
+      };
+    }
+  }
+}
+const isValidFieldName = (fieldName) => BaseValidator.isValidFieldName(fieldName);
+// @license
+class Validate {
+  constructor() {
+    // ######################
+    // Private
+    // ######################
+    __publicField(this, "_validators", []);
+  }
+  addValidator(validator) {
+    this._validators.push(validator);
+  }
+  async run(rljson) {
+    const result = await Promise.all(
+      this._validators.map(async (validator) => {
+        const errors = await validator.validate(rljson);
+        const name = validator.name;
+        return {
+          [name]: errors
+        };
+      })
+    );
+    return result.reduce((acc, errors) => {
+      let hasErrors = false;
+      for (const key of Object.keys(errors)) {
+        const e = Object.keys(errors[key]);
+        if (e.length > 0) {
+          hasErrors = true;
+          break;
+        }
+      }
+      if (hasErrors) {
+        return { ...acc, ...errors };
+      }
+      return acc;
+    }, {});
+  }
+}
 export {
+  BaseValidator,
   Example,
+  Validate,
+  bakeryExample,
   exampleBuffetsTable,
   exampleCakesTable,
   exampleCollectionsTable,
   exampleIdSetsTable,
   examplePropertiesTable,
   exampleRljson,
+  exampleTableCfgTable,
   exampleTypedefs,
+  isValidFieldName,
   iterateTables,
   reservedFieldNames,
   reservedTableNames,

package/dist/src/example.ts

@@ -7,6 +7,7 @@
 import { hip } from '@rljson/hash';
 import { exampleJsonObject } from '@rljson/json';
 
+import { TablesCfgTable } from './content/table-cfg.ts';
 import { bakeryExample } from './example/bakery-example.ts';
 import { Rljson } from './rljson.ts';
 
@@ -33,12 +34,78 @@ export class Example {
     },
 
     singleRow: (): Rljson => {
-      return {
+      const tableCfgs: TablesCfgTable = {
+        _hash: '',
+        _type: 'properties',
+        _data: [
+          {
+            _hash: 'R-rCQ4YwYYJAp6uAo6S_6n',
+            name: 'Single Row Table',
+            jsonKey: 'table',
+            columns: {
+              int: {
+                jsonKey: 'int',
+                type: 'number',
+                name: 'Integer',
+                nameShort: 'Int',
+              },
+              double: {
+                jsonKey: 'double',
+                type: 'number',
+                name: 'Double',
+                nameShort: 'Dbl',
+              },
+              string: {
+                jsonKey: 'string',
+                type: 'string',
+                name: 'String',
+                nameShort: 'Str',
+              },
+              boolean: {
+                jsonKey: 'boolean',
+                type: 'boolean',
+                name: 'Boolean',
+                nameShort: 'Bool',
+              },
+              null: {
+                jsonKey: 'null',
+                type: 'null',
+                name: 'null',
+                nameShort: 'null',
+              },
+              jsonArray: {
+                jsonKey: 'jsonArray',
+                type: 'jsonArray',
+                name: 'Json Array',
+                nameShort: 'Jarray',
+              },
+              json: {
+                jsonKey: 'json',
+                type: 'json',
+                name: 'Json',
+                nameShort: 'Json',
+              },
+              jsonValue: {
+                jsonKey: 'jsonValue',
+                type: 'jsonValue',
+                name: 'Json Value',
+                nameShort: 'Jval',
+              },
+            },
+          },
+        ],
+      };
+
+      const result: Rljson = {
+        _tableCfgs: tableCfgs,
         table: {
           _type: 'properties',
+          _tableCfg: 'R-rCQ4YwYYJAp6uAo6S_6n',
           _data: [exampleJsonObject()],
+          _hash: '',
         },
       };
+      return result as Rljson;
     },
 
     multipleRows: (): Rljson => {
@@ -177,67 +244,78 @@ export class Example {
   };
 
   static readonly broken = {
-    brokenTableName: () => {
-      return {
-        brok$en: {
-          _type: 'properties',
-          _data: [],
-        },
-      };
-    },
+    base: {
+      brokenTableName: () => {
+        return {
+          brok$en: {
+            _type: 'properties',
+            _data: [],
+          },
+        };
+      },
 
-    missingData: () => {
-      return {
-        table: {
-          _type: 'properties',
-        },
-      } as unknown as Rljson;
-    },
+      missingData: () => {
+        return {
+          table: {
+            _type: 'properties',
+          },
+        } as unknown as Rljson;
+      },
 
-    dataNotBeingAnArray: () => {
-      return {
-        table: {
-          _type: 'properties',
-          _data: {},
-        },
-      } as unknown as Rljson;
-    },
+      dataNotBeingAnArray: () => {
+        return {
+          table: {
+            _type: 'properties',
+            _data: {},
+          },
+        } as unknown as Rljson;
+      },
 
-    missingRef: (): Rljson => {
-      return {
-        tableA: {
-          _type: 'properties',
-          _data: [
-            {
-              keyA0: 'a0',
-            },
-            {
-              keyA1: 'a1',
-            },
-          ],
-        },
-        tableB: {
-          _type: 'properties',
-          _data: [
-            {
-              tableARef: 'MISSINGREF', // MISSINGREF does not exist in tableA
-            },
-          ],
-        },
-      };
+      missingRef: (): Rljson => {
+        return {
+          tableA: {
+            _type: 'properties',
+            _data: [
+              {
+                keyA0: 'a0',
+              },
+              {
+                keyA1: 'a1',
+              },
+            ],
+          },
+          tableB: {
+            _type: 'properties',
+            _data: [
+              {
+                tableARef: 'MISSINGREF', // MISSINGREF does not exist in tableA
+              },
+            ],
+          },
+        };
+      },
+
+      missingReferencedTable: (): Rljson => {
+        return {
+          tableB: {
+            _type: 'properties',
+            _data: [
+              {
+                tableARef: 'MISSINGREF', // tableA is missing
+              },
+            ],
+          },
+        };
+      },
     },
 
-    missingReferencedTable: (): Rljson => {
-      return {
-        tableB: {
-          _type: 'properties',
-          _data: [
-            {
-              tableARef: 'MISSINGREF', // tableA is missing
-            },
-          ],
-        },
-      };
+    tableCfg: {
+      wrongType: () => {
+        const result = Example.ok.singleRow();
+        const tableCfg = result._tableCfgs._data[0];
+        tableCfg.columns['int'].type = 'numberBroken'; // Break one of the types
+        return hip(result, true, false);
+      },
     },
 
     collections: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rljson/rljson",
-  "version": "0.0.14",
+  "version": "0.0.16",
   "packageManager": "pnpm@10.6.3",
   "description": "The RLJSON data format specification",
   "homepage": "https://github.com/rljson/rljson",
@@ -51,7 +51,7 @@
   },
   "dependencies": {
     "@rljson/hash": "^0.0.12",
-    "@rljson/json": "^0.0.15"
+    "@rljson/json": "^0.0.18"
   },
   "pnpm": {
     "onlyBuiltDependencies": [