@rljson/rljson 0.0.22 → 0.0.24

package/dist/content/buffet.d.ts

@@ -1,6 +1,6 @@
 import { Json } from '@rljson/json';
 import { RljsonTable } from '../rljson.ts';
-import { ItemId, Ref, TableName } from '../typedefs.ts';
+import { ItemId, Ref, TableKey } from '../typedefs.ts';
 /**
  * A buffet id is a name or id of a buffet
  */
@@ -17,7 +17,7 @@ export interface Buffet extends Json {
         /**
          * The table the item is taken from
          */
-        table: TableName;
+        table: TableKey;
         /**
          * The hash of the item in the able
          */

package/dist/content/cake.d.ts

@@ -1,6 +1,6 @@
 import { Json } from '@rljson/json';
 import { RljsonTable } from '../rljson.ts';
-import { ItemId, TableName } from '../typedefs.ts';
+import { ItemId, TableKey } from '../typedefs.ts';
 import { CollectionRef } from './collection.ts';
 import { IdSetRef } from './id-set.ts';
 /**
@@ -22,7 +22,7 @@ export interface Cake extends Json {
     /**
      * The table containing the item collections defining the layers
      */
-    collections: TableName;
+    collections: TableKey;
     /**
      * Assigns a collection to each layer of the cake.
      */

package/dist/content/collection.d.ts

@@ -1,6 +1,6 @@
 import { Json } from '@rljson/json';
 import { RljsonTable } from '../rljson.ts';
-import { ItemId, Ref, TableName } from '../typedefs.ts';
+import { ItemId, Ref, TableKey } from '../typedefs.ts';
 import { IdSetRef } from './id-set.ts';
 import { PropertiesRef } from './properties.ts';
 /**
@@ -24,7 +24,7 @@ export interface Collection extends Json {
      * The table containing the properties that are assigned to the items
      * with the assign property below
      */
-    properties: TableName;
+    properties: TableKey;
     /**
      * Assign properties to each item of the collection.
      */

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

@@ -1,6 +1,6 @@
 import { Json, JsonKey, JsonValueType } from '@rljson/json';
 import { RljsonTable } from '../rljson.ts';
-import { Ref } from '../typedefs.ts';
+import { ColumnKey, ContentType, Ref, TableKey } from '../typedefs.ts';
 /**
  * A ColumnsRef is a hash pointing to columns metadata
  */
@@ -10,17 +10,9 @@ export type TableCfgRef = Ref;
  */
 export interface ColumnCfg extends Json {
     /**
-     * The jsonKey of the column used in data
+     * The key of the column used in data
      */
-    jsonKey: JsonKey;
-    /**
-     * Average number of characters in the column
-     */
-    avgChars?: number;
-    /**
-     * Maximum number of characters in the column
-     */
-    maxChars?: number;
+    key: ColumnKey;
     /**
      * The type of the column
      */
@@ -33,11 +25,15 @@ export interface TableCfg extends Json {
     /**
      * Technical lower camel case json identifier of the table
      */
-    jsonKey: JsonKey;
+    key: TableKey;
     /**
      * A short description of the table
      */
     columns: Record<JsonKey, ColumnCfg>;
+    /**
+     * The content type of the table
+     */
+    type: ContentType;
 }
 /**
  * A table containing columns

package/dist/example.d.ts

@@ -11,7 +11,7 @@ export declare class Example {
     };
     static readonly broken: {
         base: {
-            brokenTableName: () => {
+            brokenTableKey: () => {
                 brok$en: {
                     _type: string;
                     _data: never[];

package/dist/rljson-indexed.d.ts

@@ -4,7 +4,7 @@ import { Rljson } from './rljson.ts';
  * An Rljson object where all tables' rows are indexed by their hash.
  */
 export interface RljsonIndexed {
-    [tableName: string]: {
+    [tableKey: string]: {
         _data: {
             [rowHash: string]: Json;
         };

package/dist/rljson.d.ts

@@ -5,16 +5,16 @@ 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';
+import { ContentType, Ref, TableKey } from './typedefs.ts';
 export declare const reservedFieldNames: string[];
-export declare const reservedTableNames: string[];
+export declare const reservedTableKeys: string[];
 /**
  * One of the supported Rljson table types
  */
 export type TableType = BuffetsTable | PropertiesTable<any> | CollectionsTable | IdSetsTable | CakesTable;
 /** The rljson data format */
 export interface Rljson extends Json {
-    [tableId: TableName]: TableType;
+    [tableId: TableKey]: TableType;
 }
 /**
  * Rljson set with private fields
@@ -58,4 +58,4 @@ export interface RljsonTable<Data extends Json, Type extends ContentType> extend
  * @param rljson - The Rljson object to iterate
  * @param callback - The callback to call for each table
  */
-export declare const iterateTables: (rljson: Rljson, callback: (tableName: string, table: TableType) => void) => void;
+export declare const iterateTables: (rljson: Rljson, callback: (tableKey: string, table: TableType) => void) => void;

package/dist/rljson.js

@@ -157,72 +157,56 @@ __publicField(_Example, "ok", {
     };
   },
   singleRow: () => {
-    const tableCfgs = {
+    const tableCfgs = hip({
       _hash: "",
       _type: "properties",
       _data: [
         {
-          _hash: "R-rCQ4YwYYJAp6uAo6S_6n",
-          name: "Single Row Table",
-          jsonKey: "table",
+          _hash: "",
+          key: "table",
+          type: "properties",
           columns: {
             int: {
-              jsonKey: "int",
-              type: "number",
-              name: "Integer",
-              nameShort: "Int"
+              key: "int",
+              type: "number"
             },
             double: {
-              jsonKey: "double",
-              type: "number",
-              name: "Double",
-              nameShort: "Dbl"
+              key: "double",
+              type: "number"
             },
             string: {
-              jsonKey: "string",
-              type: "string",
-              name: "String",
-              nameShort: "Str"
+              key: "string",
+              type: "string"
             },
             boolean: {
-              jsonKey: "boolean",
-              type: "boolean",
-              name: "Boolean",
-              nameShort: "Bool"
+              key: "boolean",
+              type: "boolean"
             },
             null: {
-              jsonKey: "null",
-              type: "null",
-              name: "null",
-              nameShort: "null"
+              key: "null",
+              type: "null"
             },
             jsonArray: {
-              jsonKey: "jsonArray",
-              type: "jsonArray",
-              name: "Json Array",
-              nameShort: "Jarray"
+              key: "jsonArray",
+              type: "jsonArray"
             },
             json: {
-              jsonKey: "json",
-              type: "json",
-              name: "Json",
-              nameShort: "Json"
+              key: "json",
+              type: "json"
             },
             jsonValue: {
-              jsonKey: "jsonValue",
-              type: "jsonValue",
-              name: "Json Value",
-              nameShort: "Jval"
+              key: "jsonValue",
+              type: "jsonValue"
             }
           }
         }
       ]
-    };
+    });
     const result = {
       tableCfgs,
       table: {
         _type: "properties",
-        _tableCfg: "R-rCQ4YwYYJAp6uAo6S_6n",
+        _tableCfg: tableCfgs._data[0]._hash,
         _data: [exampleJsonObject()],
         _hash: ""
       }
@@ -357,7 +341,7 @@ __publicField(_Example, "ok", {
 });
 __publicField(_Example, "broken", {
   base: {
-    brokenTableName: () => {
+    brokenTableKey: () => {
       return {
         brok$en: {
           _type: "properties",
@@ -518,23 +502,30 @@ const rljsonIndexed = (rljson) => {
 };
 // @license
 const reservedFieldNames = ["_type", "_data"];
-const reservedTableNames = ["_hash", "idSets", "tableCfgs"];
+const reservedTableKeys = ["_hash", "idSets", "tableCfgs"];
 const exampleRljson = () => Example.ok.singleRow();
 const iterateTables = (rljson, callback) => {
-  for (const tableName in rljson) {
-    const value = rljson[tableName];
+  for (const tableKey in rljson) {
+    const value = rljson[tableKey];
     if (typeof value !== "object" || !Array.isArray(value._data)) {
       continue;
     }
-    callback(tableName, rljson[tableName]);
+    callback(tableKey, rljson[tableKey]);
   }
 };
 // @license
+const contentTypes = [
+  "buffets",
+  "cakes",
+  "collections",
+  "idSets",
+  "properties"
+];
 const exampleTypedefs = () => {
   return {
     ref: "ref",
     itemId: "itemId",
-    tableName: "tableName",
+    tableKey: "tableKey",
     contentType: "collections"
   };
 };
@@ -559,10 +550,10 @@ class _BaseValidator {
     // ######################
     // Private
     // ######################
-    __publicField(this, "tableNames");
+    __publicField(this, "tableKeys");
     __publicField(this, "rljsonIndexed");
     this.rljson = rljson;
-    this.tableNames = Object.keys(this.rljson).filter(
+    this.tableKeys = Object.keys(this.rljson).filter(
       (table) => !table.startsWith("_")
     );
     this.rljsonIndexed = rljsonIndexed(rljson);
@@ -574,17 +565,19 @@ class _BaseValidator {
     const steps = [
       // Base checks
       () => this._writeAndValidHashes(),
-      () => this._tableNamesNotLowerCamelCase(),
-      () => this._tableNamesDoNotEndWithRef(),
+      () => this._tableKeysNotLowerCamelCase(),
+      () => this._tableKeysDoNotEndWithRef(),
       () => this._columnNamesNotLowerCamelCase(),
       () => this._dataNotFound(),
       () => this._dataHasWrongType(),
+      () => this._invalidTableTypes(),
       // Check table cfg
-      () => this.tableCfgsReferencedTableNameNotFound(),
-      () => this.tableCfgsHaveWrongType(),
+      () => this._tableCfgsReferencedTableKeyNotFound(),
+      () => this._tableCfgsHaveWrongType(),
       () => this._tableCfgNotFound(),
       () => this._missingColumnConfigs(),
       () => this._dataDoesNotMatchColumnConfig(),
+      () => this._tableTypesDoNotMatch(),
       // Check references
       () => this._refsNotFound(),
       // Check collections
@@ -606,32 +599,32 @@ class _BaseValidator {
     this.errors.hasErrors = this.hasErrors;
     return this.errors;
   }
-  _tableNamesNotLowerCamelCase() {
-    const invalidTableNames = [];
-    for (const tableName of this.tableNames) {
-      if (!BaseValidator.isValidFieldName(tableName)) {
-        invalidTableNames.push(tableName);
+  _tableKeysNotLowerCamelCase() {
+    const invalidTableKeys = [];
+    for (const tableKey of this.tableKeys) {
+      if (!BaseValidator.isValidFieldName(tableKey)) {
+        invalidTableKeys.push(tableKey);
       }
     }
-    if (invalidTableNames.length > 0) {
-      this.errors.tableNamesNotLowerCamelCase = {
+    if (invalidTableKeys.length > 0) {
+      this.errors.tableKeysNotLowerCamelCase = {
         error: "Table names must be lower camel case",
-        invalidTableNames
+        invalidTableKeys
       };
     }
   }
   // ...........................................................................
-  _tableNamesDoNotEndWithRef() {
-    const invalidTableNames = [];
-    for (const tableName of this.tableNames) {
-      if (tableName.endsWith("Ref")) {
-        invalidTableNames.push(tableName);
+  _tableKeysDoNotEndWithRef() {
+    const invalidTableKeys = [];
+    for (const tableKey of this.tableKeys) {
+      if (tableKey.endsWith("Ref")) {
+        invalidTableKeys.push(tableKey);
       }
     }
-    if (invalidTableNames.length > 0) {
-      this.errors.tableNamesDoNotEndWithRef = {
+    if (invalidTableKeys.length > 0) {
+      this.errors.tableKeysDoNotEndWithRef = {
         error: 'Table names must not end with "Ref"',
-        invalidTableNames
+        invalidTableKeys
       };
     }
   }
@@ -639,8 +632,8 @@ class _BaseValidator {
   _columnNamesNotLowerCamelCase() {
     const invalidColumnNames = {};
     let hadErrors = false;
-    for (const tableName of this.tableNames) {
-      const table = this.rljson[tableName];
+    for (const tableKey of this.tableKeys) {
+      const table = this.rljson[tableKey];
       if (!table._data || !Array.isArray(table._data)) {
         continue;
       }
@@ -650,8 +643,8 @@ class _BaseValidator {
             continue;
           }
           if (!BaseValidator.isValidFieldName(columnName)) {
-            invalidColumnNames[tableName] ?? (invalidColumnNames[tableName] = []);
-            invalidColumnNames[tableName].push(columnName);
+            invalidColumnNames[tableKey] ?? (invalidColumnNames[tableKey] = []);
+            invalidColumnNames[tableKey].push(columnName);
             hadErrors = true;
           }
         }
@@ -689,7 +682,7 @@ class _BaseValidator {
   _dataNotFound() {
     const rljson = this.rljson;
     const tablesWithMissingData = [];
-    for (const table of this.tableNames) {
+    for (const table of this.tableKeys) {
       const tableData = rljson[table];
       const items = tableData["_data"];
       if (items == null) {
@@ -704,30 +697,30 @@ class _BaseValidator {
     }
   }
   // ...........................................................................
-  tableCfgsReferencedTableNameNotFound() {
+  _tableCfgsReferencedTableKeyNotFound() {
     const tableCfgs = this.rljson.tableCfgs;
     if (!tableCfgs) {
       return;
     }
     const brokenCfgs = [];
     for (const item of tableCfgs._data) {
-      const table = this.rljson[item.jsonKey];
+      const table = this.rljson[item.key];
       if (!table) {
         brokenCfgs.push({
           brokenTableCfg: item._hash,
-          tableNameNotFound: item.jsonKey
+          tableKeyNotFound: item.key
         });
       }
     }
     if (brokenCfgs.length > 0) {
-      this.errors.tableCfgsReferencedTableNameNotFound = {
+      this.errors.tableCfgsReferencedTableKeyNotFound = {
         error: "Tables referenced in tableCfgs not found",
         brokenCfgs
       };
     }
   }
   // ...........................................................................
-  tableCfgsHaveWrongType() {
+  _tableCfgsHaveWrongType() {
     const tableCfgs = this.rljson.tableCfgs;
     if (!tableCfgs) {
       return;
@@ -749,7 +742,7 @@ class _BaseValidator {
       }
     }
     if (brokenCfgs.length > 0) {
-      this.errors.tableCfgsHaveWrongTypes = {
+      this.errors.columnsHaveWrongType = {
         error: "Some of the columns have invalid types. Valid types are: " + jsonValueTypes.join(", "),
         brokenCfgs
       };
@@ -759,7 +752,7 @@ class _BaseValidator {
   _tableCfgNotFound() {
     const tableCfgs = this.rljsonIndexed.tableCfgs;
     const tableCfgNotFound = [];
-    iterateTables(this.rljson, (tableName, table) => {
+    iterateTables(this.rljson, (tableKey, table) => {
       const tableCfgRef = table._tableCfg;
       if (!tableCfgRef) {
         return;
@@ -767,7 +760,7 @@ class _BaseValidator {
       const tableCfgData = tableCfgs._data[tableCfgRef];
       if (!tableCfgData) {
         tableCfgNotFound.push({
-          tableWithBrokenTableCfgRef: tableName,
+          tableWithBrokenTableCfgRef: tableKey,
           brokenTableCfgRef: tableCfgRef
         });
         return;
@@ -784,7 +777,7 @@ class _BaseValidator {
   _missingColumnConfigs() {
     const tableCfgs = this.rljsonIndexed.tableCfgs;
     const missingColumnConfigs = [];
-    iterateTables(this.rljson, (tableName, table) => {
+    iterateTables(this.rljson, (tableKey, table) => {
       const tableCfgRef = table._tableCfg;
       if (!tableCfgRef) {
         return;
@@ -805,7 +798,7 @@ class _BaseValidator {
               tableCfg: tableCfgRef,
               row: row._hash,
               column: columnKey,
-              table: tableName
+              table: tableKey
             });
           }
           processedColumnKeys.push(columnKey);
@@ -823,7 +816,7 @@ class _BaseValidator {
   _dataDoesNotMatchColumnConfig() {
     const tableCfgs = this.rljsonIndexed.tableCfgs;
     const brokenValues = [];
-    iterateTables(this.rljson, (tableName, table) => {
+    iterateTables(this.rljson, (tableKey, table) => {
       const tableCfgRef = table._tableCfg;
       if (!tableCfgRef) {
         return;
@@ -843,7 +836,7 @@ class _BaseValidator {
           const typeShould = columnConfig.type;
           if (!jsonValueMatchesType(value, typeShould)) {
             brokenValues.push({
-              table: tableName,
+              table: tableKey,
               row: row._hash,
               column: columnKey,
               tableCfg: tableCfgRef
@@ -860,14 +853,43 @@ class _BaseValidator {
     }
   }
   // ...........................................................................
+  _tableTypesDoNotMatch() {
+    const rljson = this.rljson;
+    const tablesWithTypeMissmatch = [];
+    for (const tableKey of this.tableKeys) {
+      const table = rljson[tableKey];
+      const cfgRef = table._tableCfg;
+      if (!cfgRef) {
+        continue;
+      }
+      const cfg = this.rljsonIndexed.tableCfgs._data[cfgRef];
+      const typeShould = cfg.type;
+      const typeIs = table._type;
+      if (typeShould !== typeIs) {
+        tablesWithTypeMissmatch.push({
+          table: tableKey,
+          typeInTable: typeIs,
+          typeInConfig: typeShould,
+          tableCfg: cfgRef
+        });
+      }
+    }
+    if (tablesWithTypeMissmatch.length > 0) {
+      this.errors.tableTypesDoNotMatch = {
+        error: "Table types do not match table config",
+        tables: tablesWithTypeMissmatch
+      };
+    }
+  }
+  // ...........................................................................
   _dataHasWrongType() {
     const rljson = this.rljson;
     const tablesWithWrongType = [];
-    for (const tableName of this.tableNames) {
-      const tableData = rljson[tableName];
+    for (const tableKey of this.tableKeys) {
+      const tableData = rljson[tableKey];
       const items = tableData["_data"];
       if (!Array.isArray(items)) {
-        tablesWithWrongType.push(tableName);
+        tablesWithWrongType.push(tableKey);
       }
     }
     if (tablesWithWrongType.length > 0) {
@@ -877,37 +899,59 @@ class _BaseValidator {
       };
     }
   }
+  // ...........................................................................
+  _invalidTableTypes() {
+    const rljson = this.rljson;
+    const tablesWithWrongType = [];
+    for (const tableKey of this.tableKeys) {
+      const table = rljson[tableKey];
+      const type = table._type;
+      if (contentTypes.indexOf(type) === -1) {
+        tablesWithWrongType.push({
+          table: tableKey,
+          type,
+          allowedTypes: contentTypes.join(" | ")
+        });
+      }
+    }
+    if (tablesWithWrongType.length > 0) {
+      this.errors.invalidTableTypes = {
+        error: "Tables with invalid types",
+        tables: tablesWithWrongType
+      };
+    }
+  }
   _refsNotFound() {
     const missingRefs = [];
-    iterateTables(this.rljson, (tableName, table) => {
+    iterateTables(this.rljson, (tableKey, 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 targetTableKey = key.substring(0, key.length - 3);
             const itemHash = item._hash;
-            if (this.tableNames.indexOf(targetTableName) === -1) {
+            if (this.tableKeys.indexOf(targetTableKey) === -1) {
               missingRefs.push({
-                error: `Target table "${targetTableName}" not found.`,
-                sourceTable: tableName,
+                error: `Target table "${targetTableKey}" not found.`,
+                sourceTable: tableKey,
                 sourceKey: key,
                 sourceItemHash: itemHash,
                 targetItemHash,
-                targetTable: targetTableName
+                targetTable: targetTableKey
               });
               continue;
             }
-            const targetTableIndexed = this.rljsonIndexed[targetTableName];
+            const targetTableIndexed = this.rljsonIndexed[targetTableKey];
             const referencedItem = targetTableIndexed._data[targetItemHash];
             if (referencedItem === void 0) {
               missingRefs.push({
-                sourceTable: tableName,
+                sourceTable: tableKey,
                 sourceItemHash: itemHash,
                 sourceKey: key,
                 targetItemHash,
-                targetTable: targetTableName,
-                error: `Table "${targetTableName}" has no item with hash "${targetItemHash}"`
+                targetTable: targetTableKey,
+                error: `Table "${targetTableKey}" has no item with hash "${targetItemHash}"`
               });
             }
           }
@@ -923,11 +967,11 @@ class _BaseValidator {
   }
   _collectionBasesNotFound() {
     const brokenCollections = [];
-    iterateTables(this.rljson, (tableName, table) => {
+    iterateTables(this.rljson, (tableKey, table) => {
       if (table._type !== "collections") {
         return;
       }
-      const collectionsIndexed = this.rljsonIndexed[tableName];
+      const collectionsIndexed = this.rljsonIndexed[tableKey];
       const collectionsTable = table;
       for (const collection of collectionsTable._data) {
         const baseRef = collection.base;
@@ -937,7 +981,7 @@ class _BaseValidator {
         const baseCollection = collectionsIndexed._data[baseRef];
         if (!baseCollection) {
           brokenCollections.push({
-            collectionsTable: tableName,
+            collectionsTable: tableKey,
             brokenCollection: collection._hash,
             missingBaseCollection: baseRef
           });
@@ -953,7 +997,7 @@ class _BaseValidator {
   }
   _collectionIdSetsExist() {
     const brokenCollections = [];
-    iterateTables(this.rljson, (tableName, table) => {
+    iterateTables(this.rljson, (tableKey, table) => {
       if (table._type !== "collections") {
         return;
       }
@@ -967,7 +1011,7 @@ class _BaseValidator {
         const idSet = idSets._data[idSetRef];
         if (!idSet) {
           brokenCollections.push({
-            collectionsTable: tableName,
+            collectionsTable: tableKey,
             collectionHash: collection._hash,
             missingIdSet: idSetRef
           });
@@ -984,19 +1028,19 @@ class _BaseValidator {
   _collectionPropertyAssignmentsNotFound() {
     const missingPropertyTables = [];
     const brokenAssignments = [];
-    iterateTables(this.rljson, (tableName, table) => {
+    iterateTables(this.rljson, (tableKey, table) => {
       if (table._type !== "collections") {
         return;
       }
       const collectionsTable = table;
       for (const collection of collectionsTable._data) {
-        const propertyTableName = collection.properties;
-        const propertiesTable = this.rljsonIndexed[propertyTableName];
+        const propertyTableKey = collection.properties;
+        const propertiesTable = this.rljsonIndexed[propertyTableKey];
         if (!propertiesTable) {
           missingPropertyTables.push({
             brokenCollection: collection._hash,
-            collectionsTable: tableName,
-            missingPropertyTable: propertyTableName
+            collectionsTable: tableKey,
+            missingPropertyTable: propertyTableKey
           });
           continue;
         }
@@ -1008,9 +1052,9 @@ class _BaseValidator {
           const propertyHash = assignments[itemId];
           if (!propertiesTable._data[propertyHash]) {
             brokenAssignments.push({
-              collectionsTable: tableName,
+              collectionsTable: tableKey,
               brokenCollection: collection._hash,
-              referencedPropertyTable: propertyTableName,
+              referencedPropertyTable: propertyTableKey,
               brokenAssignment: itemId,
               missingProperty: propertyHash
             });
@@ -1033,7 +1077,7 @@ class _BaseValidator {
   }
   _cakeIdSetsNotFound() {
     const brokenCakes = [];
-    iterateTables(this.rljson, (tableName, table) => {
+    iterateTables(this.rljson, (tableKey, table) => {
       if (table._type !== "cakes") {
         return;
       }
@@ -1047,7 +1091,7 @@ class _BaseValidator {
         const idSet = idSets._data[idSetRef];
         if (!idSet) {
           brokenCakes.push({
-            cakeTable: tableName,
+            cakeTable: tableKey,
             brokenCake: cake._hash,
             missingIdSet: idSetRef
           });
@@ -1064,19 +1108,19 @@ class _BaseValidator {
   _cakeCollectionTablesNotFound() {
     const missingCollectionTables = [];
     const missingLayerCollections = [];
-    iterateTables(this.rljson, (tableName, table) => {
+    iterateTables(this.rljson, (tableKey, table) => {
       if (table._type !== "cakes") {
         return;
       }
       const cakesTable = table;
       for (const cake of cakesTable._data) {
-        const collectionsTableName = cake.collections;
-        const collectionsTable = this.rljsonIndexed[collectionsTableName];
+        const collectionsTableKey = cake.collections;
+        const collectionsTable = this.rljsonIndexed[collectionsTableKey];
         if (!collectionsTable) {
           missingCollectionTables.push({
-            cakeTable: tableName,
+            cakeTable: tableKey,
             brokenCake: cake._hash,
-            missingCollectionsTable: collectionsTableName
+            missingCollectionsTable: collectionsTableKey
           });
           continue;
         }
@@ -1088,10 +1132,10 @@ class _BaseValidator {
           const collection = collectionsTable._data[collectionRef];
           if (!collection) {
             missingLayerCollections.push({
-              cakeTable: tableName,
+              cakeTable: tableKey,
               brokenCake: cake._hash,
               brokenLayerName: layer,
-              collectionsTable: collectionsTableName,
+              collectionsTable: collectionsTableKey,
               missingCollection: collectionRef
             });
           }
@@ -1114,20 +1158,20 @@ class _BaseValidator {
   _buffetReferencedTableNotFound() {
     const missingTables = [];
     const missingItems = [];
-    iterateTables(this.rljson, (tableName, table) => {
+    iterateTables(this.rljson, (tableKey, 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];
+          const itemTableKey = item.table;
+          const itemTable = this.rljsonIndexed[itemTableKey];
           if (!itemTable) {
             missingTables.push({
-              buffetTable: tableName,
+              buffetTable: tableKey,
               brokenBuffet: buffet._hash,
-              missingItemTable: itemTableName
+              missingItemTable: itemTableKey
             });
             continue;
           }
@@ -1135,9 +1179,9 @@ class _BaseValidator {
           const referencedItem = itemTable._data[ref];
           if (!referencedItem) {
             missingItems.push({
-              buffetTable: tableName,
+              buffetTable: tableKey,
               brokenBuffet: buffet._hash,
-              itemTable: itemTableName,
+              itemTable: itemTableKey,
               missingItem: ref
             });
           }
@@ -1201,6 +1245,7 @@ export {
   Example,
   Validate,
   bakeryExample,
+  contentTypes,
   exampleBuffetsTable,
   exampleCakesTable,
   exampleCollectionsTable,
@@ -1212,6 +1257,6 @@ export {
   isValidFieldName,
   iterateTables,
   reservedFieldNames,
-  reservedTableNames,
+  reservedTableKeys,
   rljsonIndexed
 };

package/dist/src/example.ts

@@ -34,73 +34,57 @@ export class Example {
     },
 
     singleRow: (): Rljson => {
-      const tableCfgs: TablesCfgTable = {
+      const tableCfgs: TablesCfgTable = hip({
         _hash: '',
         _type: 'properties',
         _data: [
           {
-            _hash: 'R-rCQ4YwYYJAp6uAo6S_6n',
-            name: 'Single Row Table',
-            jsonKey: 'table',
+            _hash: '',
+            key: 'table',
+            type: 'properties',
             columns: {
               int: {
-                jsonKey: 'int',
+                key: 'int',
                 type: 'number',
-                name: 'Integer',
-                nameShort: 'Int',
               },
               double: {
-                jsonKey: 'double',
+                key: 'double',
                 type: 'number',
-                name: 'Double',
-                nameShort: 'Dbl',
               },
               string: {
-                jsonKey: 'string',
+                key: 'string',
                 type: 'string',
-                name: 'String',
-                nameShort: 'Str',
               },
               boolean: {
-                jsonKey: 'boolean',
+                key: 'boolean',
                 type: 'boolean',
-                name: 'Boolean',
-                nameShort: 'Bool',
               },
               null: {
-                jsonKey: 'null',
+                key: 'null',
                 type: 'null',
-                name: 'null',
-                nameShort: 'null',
               },
               jsonArray: {
-                jsonKey: 'jsonArray',
+                key: 'jsonArray',
                 type: 'jsonArray',
-                name: 'Json Array',
-                nameShort: 'Jarray',
               },
               json: {
-                jsonKey: 'json',
+                key: 'json',
                 type: 'json',
-                name: 'Json',
-                nameShort: 'Json',
               },
               jsonValue: {
-                jsonKey: 'jsonValue',
+                key: 'jsonValue',
                 type: 'jsonValue',
-                name: 'Json Value',
-                nameShort: 'Jval',
               },
             },
           },
         ],
-      };
+      });
 
       const result: Rljson = {
         tableCfgs: tableCfgs,
         table: {
           _type: 'properties',
-          _tableCfg: 'R-rCQ4YwYYJAp6uAo6S_6n',
+          _tableCfg: tableCfgs._data[0]._hash as string,
           _data: [exampleJsonObject()],
           _hash: '',
         },
@@ -245,7 +229,7 @@ export class Example {
 
   static readonly broken = {
     base: {
-      brokenTableName: () => {
+      brokenTableKey: () => {
         return {
           brok$en: {
             _type: 'properties',

package/dist/typedefs.d.ts

@@ -1,3 +1,4 @@
+import { JsonKey } from '@rljson/json';
 /**
  * A ref is a hash that references to another element
  */
@@ -11,7 +12,11 @@ export type ItemId = string;
  * A table id reference to a table. The table ids are used as keys in the top
  * level structure of an Rljson data object.
  */
-export type TableName = ItemId;
+export type TableKey = JsonKey;
+/**
+ * A column key is a key that references a column in a table
+ */
+export type ColumnKey = JsonKey;
 /**
  * Types of tables that can be stored in an Rljson object
  *
@@ -21,13 +26,14 @@ export type TableName = ItemId;
  * - `ids` Tables containing item ids
  * - `properties` Tables containing item properties
  */
-export type ContentType = 'buffets' | 'cakes' | 'collections' | 'idSets' | 'properties';
+export declare const contentTypes: readonly ["buffets", "cakes", "collections", "idSets", "properties"];
+export type ContentType = (typeof contentTypes)[number];
 /**
  * An example object using the typedefs
  */
 export declare const exampleTypedefs: () => {
     ref: Ref;
     itemId: ItemId;
-    tableName: TableName;
+    tableKey: TableKey;
     contentType: ContentType;
 };

package/dist/validate/base-validator.d.ts

@@ -2,18 +2,20 @@ import { Json } from '@rljson/json';
 import { Rljson } from '../rljson.ts';
 import { Errors, Validator } from './validate.ts';
 export interface BaseErrors extends Errors {
-    tableNamesNotLowerCamelCase?: Json;
+    tableKeysNotLowerCamelCase?: Json;
     columnNamesNotLowerCamelCase?: Json;
-    tableNamesDoNotStartWithANumber?: Json;
-    tableNamesDoNotEndWithRef?: Json;
+    tableKeysDoNotStartWithANumber?: Json;
+    tableKeysDoNotEndWithRef?: Json;
     hashesNotValid?: Json;
     dataNotFound?: Json;
     dataHasWrongType?: Json;
-    tableCfgsReferencedTableNameNotFound?: Json;
-    tableCfgsHaveWrongTypes?: Json;
+    invalidTableTypes?: Json;
+    tableCfgsReferencedTableKeyNotFound?: Json;
+    columnsHaveWrongType?: Json;
     tableCfgReferencedNotFound?: Json;
     columnConfigNotFound?: Json;
     dataDoesNotMatchColumnConfig?: Json;
+    tableTypesDoNotMatch?: Json;
     refsNotFound?: Json;
     collectionBasesNotFound?: Json;
     collectionIdSetsNotFound?: Json;

package/package.json

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