@rljson/rljson 0.0.15 → 0.0.17

package/dist/content/buffet.d.ts

@@ -0,0 +1,31 @@
+import { Json } from '@rljson/json';
+import { RljsonTable } from '../rljson.ts';
+import { ItemId, Ref, TableName } from '../typedefs.ts';
+/**
+ * A buffet id is a name or id of a buffet
+ */
+export type BuffetId = ItemId;
+/**
+ * A buffet is a collection of arbitrary but related items, e.g. cakes,
+ * collections, or items.
+ */
+export interface Buffet extends Json {
+    /**
+     * The items of the buffet
+     */
+    items: Array<{
+        /**
+         * The table the item is taken from
+         */
+        table: TableName;
+        /**
+         * The hash of the item in the able
+         */
+        ref: Ref;
+    }>;
+}
+/**
+ * A table containing buffets
+ */
+export type BuffetsTable = RljsonTable<Buffet, 'buffets'>;
+export declare const exampleBuffetsTable: () => BuffetsTable;

package/dist/content/cake.d.ts

@@ -0,0 +1,40 @@
+import { Json } from '@rljson/json';
+import { RljsonTable } from '../rljson.ts';
+import { ItemId, TableName } from '../typedefs.ts';
+import { CollectionRef } from './collection.ts';
+import { IdSetRef } from './id-set.ts';
+/**
+ * A `CakeLayerId` assigns an id or name to a cake layer
+ */
+export type CakeLayerId = ItemId;
+/**
+ * A cake is a collection of layers.
+ *
+ * A layer is a collection of items.
+ * All layers of a cake refer to the same items.
+ */
+export interface Cake extends Json {
+    /**
+     * The item ids of the collection. If present, the item ids in the layers
+     * must match these ids. The item id sets can be found in the _idSets table.
+     */
+    idSet?: IdSetRef;
+    /**
+     * The table containing the item collections defining the layers
+     */
+    collections: TableName;
+    /**
+     * Assigns a collection to each layer of the cake.
+     */
+    layers: {
+        [layerId: CakeLayerId]: CollectionRef;
+    };
+}
+/**
+ * A table containing cakes
+ */
+export type CakesTable = RljsonTable<Cake, 'cakes'>;
+/**
+ * Provides an example collectionsTable for test purposes
+ */
+export declare const exampleCakesTable: () => CakesTable;

package/dist/content/collection.d.ts

@@ -0,0 +1,40 @@
+import { Json } from '@rljson/json';
+import { RljsonTable } from '../rljson.ts';
+import { ItemId, Ref, TableName } from '../typedefs.ts';
+import { IdSetRef } from './id-set.ts';
+import { PropertiesRef } from './properties.ts';
+/**
+ * A CollectionRef is a hash pointing to a collection
+ */
+export type CollectionRef = Ref;
+/**
+ * A collection assigns properties to item ids
+ */
+export interface Collection extends Json {
+    /**
+     * `base` an optional base collection that is extended by this collection
+     */
+    base?: CollectionRef;
+    /**
+     * The item ids of the collection. If presnet, the item ids in `assign`
+     * must match these ids. The item id sets can be found in the _idSets table.
+     */
+    idSet?: IdSetRef;
+    /**
+     * The table containing the properties that are assigned to the items
+     * with the assign property below
+     */
+    properties: TableName;
+    /**
+     * Assign properties to each item of the collection.
+     */
+    assign: Record<ItemId, PropertiesRef>;
+}
+/**
+ * A table containing collections
+ */
+export type CollectionsTable = RljsonTable<Collection, 'collections'>;
+/**
+ * Provides an example collectionsTable for test purposes
+ */
+export declare const exampleCollectionsTable: () => CollectionsTable;

package/dist/content/id-set.d.ts

@@ -0,0 +1,33 @@
+import { Json } from '@rljson/json';
+import { RljsonTable } from '../rljson.ts';
+import { ItemId, Ref } from '../typedefs.ts';
+/**
+ * An IdSetRef is a hash pointing to an Ids
+ */
+export type IdSetRef = Ref;
+/**
+ * An Ids manages list of item ids
+ */
+export interface IdSet extends Json {
+    /**
+     * The hash of another item id list which is extended by this one.
+     * Must be empty or null, when the list is the root.
+     */
+    base?: IdSetRef;
+    /**
+     * The item ids added to base
+     */
+    add: ItemId[];
+    /**
+     * The item ids removed from base
+     */
+    remove?: ItemId[];
+}
+/**
+ * A table containing item ids
+ */
+export type IdSetsTable = RljsonTable<IdSet, 'idSets'>;
+/**
+ * Returns one of the layers of the example cake
+ */
+export declare const exampleIdSetsTable: () => IdSetsTable;

package/dist/content/properties.d.ts

@@ -0,0 +1,16 @@
+import { Json } from '@rljson/json';
+import { NutritiveValues } from '../example/bakery-example.ts';
+import { RljsonTable } from '../rljson.ts';
+import { Ref } from '../typedefs.ts';
+/**
+ * A reference to a properties row in a properties table
+ */
+export type PropertiesRef = Ref;
+/**
+ * A table containing item properties
+ */
+export type PropertiesTable<T extends Json> = RljsonTable<T, 'properties'>;
+/**
+ * Provides an example collectionsTable for test purposes
+ */
+export declare const examplePropertiesTable: () => PropertiesTable<NutritiveValues>;

package/dist/content/table-cfg.d.ts

@@ -0,0 +1,48 @@
+import { Json, JsonKey, JsonValueType } from '@rljson/json';
+import { RljsonTable } from '../rljson.ts';
+import { Ref } from '../typedefs.ts';
+/**
+ * A ColumnsRef is a hash pointing to columns metadata
+ */
+export type TableCfgRef = Ref;
+/**
+ * A column configuration
+ */
+export interface ColumnCfg extends Json {
+    /**
+     * The jsonKey of the column used in data
+     */
+    jsonKey: JsonKey;
+    /**
+     * A short name of the column to be shown in the table header
+     */
+    nameShort: string;
+    /**
+     * A unshorted name to be shown in the tool tip
+     */
+    name: string;
+    /**
+     * Average number of characters in the column
+     */
+    avgChars?: number;
+    /**
+     * The type of the column
+     */
+    type: JsonValueType;
+}
+/**
+ * Describes the configuration of a table, i.e. table metadata and columns
+ */
+export interface TableCfg extends Json {
+    name: string;
+    jsonKey: JsonKey;
+    columns: Record<JsonKey, ColumnCfg>;
+}
+/**
+ * A table containing columns
+ */
+export type TablesCfgTable = RljsonTable<TableCfg, 'properties'>;
+/**
+ * Example matching allTypesRow
+ */
+export declare const exampleTableCfgTable: () => TablesCfgTable;

package/dist/example/bakery-example.d.ts

@@ -0,0 +1,35 @@
+import { Json } from '@rljson/json';
+import { BuffetsTable } from '../content/buffet.ts';
+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 { Rljson } from '../rljson.ts';
+import { Ref } from '../typedefs.ts';
+export interface Ingredient extends Json {
+    name: string;
+    amountUnit: 'g' | 'ml';
+    nutritiveValuesRef: Ref;
+}
+export interface RecipeIngredient extends Json {
+    ingredientsRef: string;
+    quantity: number;
+}
+export type IngredientsTypeTable = PropertiesTable<Ingredient>;
+export interface NutritiveValues extends Json {
+    energy: number;
+    fat: number;
+    protein: number;
+    carbohydrates: number;
+}
+export interface Bakery extends Rljson {
+    buffets: BuffetsTable;
+    cakes: CakesTable;
+    slices: IdSetsTable;
+    layers: CollectionsTable;
+    recipes: CollectionsTable;
+    recipeIngredients: PropertiesTable<RecipeIngredient>;
+    ingredients: PropertiesTable<Ingredient>;
+    nutritiveValues: PropertiesTable<NutritiveValues>;
+}
+export declare const bakeryExample: () => Bakery;

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.js

@@ -2,7 +2,7 @@ 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 = () => {
   const result = {
@@ -483,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) {
@@ -527,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/validate/base-validator.d.ts

@@ -0,0 +1,39 @@
+import { Json } from '@rljson/json';
+import { Rljson } from '../rljson.ts';
+import { Errors, Validator } from './validate.ts';
+export interface BaseErrors extends Errors {
+    tableNamesNotLowerCamelCase?: Json;
+    columnNamesNotLowerCamelCase?: Json;
+    tableNamesDoNotStartWithANumber?: Json;
+    tableNamesDoNotEndWithRef?: Json;
+    hashesNotValid?: Json;
+    dataNotFound?: Json;
+    dataHasWrongType?: Json;
+    tableCfgsReferencedTableNameNotFound?: Json;
+    tableCfgsHaveWrongTypes?: Json;
+    tableCfgReferencedNotFound?: Json;
+    columnConfigNotFound?: Json;
+    dataDoesNotMatchColumnConfig?: Json;
+    refsNotFound?: Json;
+    collectionBasesNotFound?: Json;
+    collectionIdSetsNotFound?: Json;
+    collectionPropertyTablesNotFound?: Json;
+    collectionPropertyAssignmentsNotFound?: Json;
+    cakeIdSetsNotFound?: Json;
+    cakeCollectionTablesNotFound?: Json;
+    cakeLayerCollectionsNotFound?: Json;
+    buffetReferencedTablesNotFound?: Json;
+    buffetReferencedItemsNotFound?: Json;
+}
+export declare class BaseValidator implements Validator {
+    name: string;
+    validate(rljson: Rljson): Promise<Errors>;
+    validateSync(rljson: Rljson): BaseErrors;
+    static isValidFieldName(fieldName: string): boolean;
+}
+/**
+ * Validates an field name
+ * @param fieldName - The field name to validate
+ * @returns true if the field name is valid, false otherwise
+ */
+export declare const isValidFieldName: (fieldName: string) => boolean;

package/dist/validate/validate.d.ts

@@ -0,0 +1,19 @@
+import { Json } from '@rljson/json';
+import { Rljson } from '../rljson.ts';
+export type Errors = Json & {
+    hasErrors: boolean;
+};
+export interface ValidationResult {
+    [group: string]: Errors;
+}
+export interface Validator {
+    name: string;
+    validate(rljson: Rljson): Promise<Errors>;
+}
+export declare class Validate {
+    addValidator(validator: Validator): void;
+    run(rljson: Rljson): Promise<{
+        [group: string]: Errors;
+    }>;
+    private _validators;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rljson/rljson",
-  "version": "0.0.15",
+  "version": "0.0.17",
   "packageManager": "pnpm@10.6.3",
   "description": "The RLJSON data format specification",
   "homepage": "https://github.com/rljson/rljson",