@rljson/rljson 0.0.15 → 0.0.16

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/package.json

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