@rljson/rljson 0.0.65 → 0.0.66

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

@@ -25,6 +25,13 @@ export interface ColumnCfg extends Json {
      * An optional short title of the column
      */
     titleShort: string;
+    /**
+     * Defines if the column is reference column to another table (foreign key)
+     */
+    ref?: {
+        tableKey: TableKey;
+        columnKey?: ColumnKey;
+    };
 }
 /**
  * A column configuration with route

package/dist/example.d.ts

@@ -7,11 +7,9 @@ export declare class Example {
         singleRow: () => Rljson;
         multipleRows: () => Rljson;
         singleRef: () => Rljson;
+        multiRef: () => Rljson;
         singleSliceIdRef: () => Rljson;
         multiSliceIdRef: () => Rljson;
-        singleNamedRef: () => Rljson;
-        multiRef: () => Rljson;
-        multiMixedRef: () => Rljson;
         complete: () => Rljson;
     };
     static readonly broken: {
@@ -24,7 +22,6 @@ export declare class Example {
             missingData: () => Rljson;
             dataNotBeingAnArray: () => Rljson;
             missingRef: () => Rljson;
-            missingNamedRef: () => Rljson;
             missingMultiRef: () => Rljson;
             missingReferencedTable: () => Rljson;
             missingSliceId: () => Rljson;

package/dist/rljson.js

@@ -535,26 +535,172 @@ class Example {
       };
     },
     singleRef: () => {
+      const tableCfgs = hip({
+        _type: "tableCfgs",
+        _data: [
+          {
+            key: "tableA",
+            type: "components",
+            isHead: false,
+            isRoot: false,
+            isShared: true,
+            columns: [
+              {
+                key: "_hash",
+                type: "string",
+                titleLong: "Hash",
+                titleShort: "Hash"
+              },
+              {
+                key: "propertyA",
+                type: "string",
+                titleLong: "Key",
+                titleShort: "Key"
+              }
+            ],
+            _hash: ""
+          },
+          {
+            key: "tableB",
+            type: "components",
+            isHead: false,
+            isRoot: false,
+            isShared: true,
+            columns: [
+              {
+                key: "_hash",
+                type: "string",
+                titleLong: "Hash",
+                titleShort: "Hash"
+              },
+              {
+                key: "propertyAFromTableA",
+                type: "string",
+                titleLong: "Table A Reference",
+                titleShort: "TableARef",
+                ref: {
+                  tableKey: "tableA",
+                  columnKey: "propertyA"
+                }
+              }
+            ],
+            _hash: ""
+          }
+        ]
+      });
+      const tableA = hip({
+        _type: "components",
+        _tableCfg: tableCfgs._data[0]._hash,
+        _data: [
+          {
+            propertyA: "a0"
+          },
+          {
+            propertyA: "a1"
+          }
+        ],
+        _hash: ""
+      });
+      const tableB = hip({
+        _type: "components",
+        _tableCfg: tableCfgs._data[1]._hash,
+        _data: [
+          {
+            propertyAFromTableA: tableA._data[0]._hash
+          }
+        ],
+        _hash: ""
+      });
       return {
-        tableA: {
-          _type: "components",
-          _data: [
-            {
-              keyA0: "a0"
-            },
-            {
-              keyA1: "a1"
-            }
-          ]
-        },
-        tableB: {
-          _type: "components",
-          _data: [
-            {
-              tableARef: "KFQrf4mEz0UPmUaFHwH4T6"
-            }
-          ]
-        }
+        tableCfgs,
+        tableA,
+        tableB
+      };
+    },
+    multiRef: () => {
+      const tableCfgs = hip({
+        _type: "tableCfgs",
+        _data: [
+          {
+            key: "tableA",
+            type: "components",
+            isHead: false,
+            isRoot: false,
+            isShared: true,
+            columns: [
+              {
+                key: "_hash",
+                type: "string",
+                titleLong: "Hash",
+                titleShort: "Hash"
+              },
+              {
+                key: "propertyA",
+                type: "string",
+                titleLong: "Key",
+                titleShort: "Key"
+              }
+            ],
+            _hash: ""
+          },
+          {
+            key: "tableB",
+            type: "components",
+            isHead: false,
+            isRoot: false,
+            isShared: true,
+            columns: [
+              {
+                key: "_hash",
+                type: "string",
+                titleLong: "Hash",
+                titleShort: "Hash"
+              },
+              {
+                key: "propertyAFromTableA",
+                type: "jsonValue",
+                titleLong: "Table A Reference",
+                titleShort: "TableARef",
+                ref: {
+                  tableKey: "tableA",
+                  columnKey: "propertyA"
+                }
+              }
+            ],
+            _hash: ""
+          }
+        ]
+      });
+      const tableA = hip({
+        _type: "components",
+        _tableCfg: tableCfgs._data[0]._hash,
+        _data: [
+          {
+            propertyA: "a0"
+          },
+          {
+            propertyA: "a1"
+          }
+        ],
+        _hash: ""
+      });
+      const tableB = hip({
+        _type: "components",
+        _tableCfg: tableCfgs._data[1]._hash,
+        _data: [
+          {
+            propertyAFromTableA: [
+              tableA._data[0]._hash,
+              tableA._data[1]._hash
+            ]
+          }
+        ],
+        _hash: ""
+      });
+      return {
+        tableCfgs,
+        tableA,
+        tableB
       };
     },
     singleSliceIdRef: () => {
@@ -597,89 +743,6 @@ class Example {
         }
       };
     },
-    singleNamedRef: () => {
-      return {
-        tableA: {
-          _type: "components",
-          _data: [
-            {
-              keyA0: "a0"
-            },
-            {
-              keyA1: "a1"
-            }
-          ]
-        },
-        tableB: {
-          _type: "components",
-          _data: [
-            {
-              namedRef: { component: "tableA", ref: "KFQrf4mEz0UPmUaFHwH4T6" }
-            }
-          ]
-        }
-      };
-    },
-    multiRef: () => {
-      return {
-        tableA: {
-          _type: "components",
-          _data: [
-            {
-              keyA0: "a0"
-            },
-            {
-              keyA1: "a1"
-            }
-          ]
-        },
-        tableB: {
-          _type: "components",
-          _data: [
-            {
-              tableARef: ["KFQrf4mEz0UPmUaFHwH4T6", "YPw-pxhqaUOWRFGramr4B1"]
-            }
-          ]
-        }
-      };
-    },
-    multiMixedRef: () => {
-      return {
-        tableA: {
-          _type: "components",
-          _data: [
-            {
-              keyA0: "a0"
-            },
-            {
-              keyA1: "a1"
-            }
-          ]
-        },
-        tableB: {
-          _type: "components",
-          _data: [
-            {
-              keyB0: "b0"
-            },
-            {
-              keyB1: "b1"
-            }
-          ]
-        },
-        tableC: {
-          _type: "components",
-          _data: [
-            {
-              tableRef: [
-                { component: "tableA", ref: "KFQrf4mEz0UPmUaFHwH4T6" },
-                { component: "tableB", ref: "dXhIygNwNMVPEqFbsFJkn6" }
-              ]
-            }
-          ]
-        }
-      };
-    },
     complete: () => {
       const sliceIds = hip({
         _type: "sliceIds",
@@ -777,87 +840,220 @@ class Example {
         };
       },
       missingRef: () => {
+        const tableCfgs = hip({
+          _type: "tableCfgs",
+          _data: [
+            {
+              key: "tableA",
+              type: "components",
+              isHead: false,
+              isRoot: false,
+              isShared: true,
+              columns: [
+                {
+                  key: "_hash",
+                  type: "string",
+                  titleLong: "Hash",
+                  titleShort: "Hash"
+                },
+                {
+                  key: "propertyA",
+                  type: "string",
+                  titleLong: "Key",
+                  titleShort: "Key"
+                }
+              ],
+              _hash: ""
+            },
+            {
+              key: "tableB",
+              type: "components",
+              isHead: false,
+              isRoot: false,
+              isShared: true,
+              columns: [
+                {
+                  key: "_hash",
+                  type: "string",
+                  titleLong: "Hash",
+                  titleShort: "Hash"
+                },
+                {
+                  key: "propertyAFromTableA",
+                  type: "jsonValue",
+                  titleLong: "Table A Reference",
+                  titleShort: "TableARef",
+                  ref: {
+                    tableKey: "tableA",
+                    columnKey: "propertyA"
+                  }
+                }
+              ],
+              _hash: ""
+            }
+          ]
+        });
+        const tableA = hip({
+          _type: "components",
+          _tableCfg: tableCfgs._data[0]._hash,
+          _data: [
+            {
+              propertyA: "a0"
+            },
+            {
+              propertyA: "a1"
+            }
+          ],
+          _hash: ""
+        });
+        const tableB = hip({
+          _type: "components",
+          _tableCfg: tableCfgs._data[1]._hash,
+          _data: [
+            {
+              propertyAFromTableA: "MISSINGREF"
+              // Missing reference
+            }
+          ],
+          _hash: ""
+        });
         return {
-          tableA: {
-            _type: "components",
-            _data: [
-              {
-                keyA0: "a0"
-              },
-              {
-                keyA1: "a1"
-              }
-            ]
-          },
-          tableB: {
-            _type: "components",
-            _data: [
-              {
-                tableARef: "MISSINGREF"
-                // MISSINGREF does not exist in tableA
-              }
-            ]
-          }
-        };
-      },
-      missingNamedRef: () => {
-        return {
-          tableA: {
-            _type: "components",
-            _data: [
-              {
-                keyA0: "a0"
-              },
-              {
-                keyA1: "a1"
-              }
-            ]
-          },
-          tableB: {
-            _type: "components",
-            _data: [
-              {
-                namedRef: { component: "tableA", ref: "MISSINGREF" }
-                // MISSINGREF does not exist in tableA
-              }
-            ]
-          }
+          tableCfgs,
+          tableA,
+          tableB
         };
       },
       missingMultiRef: () => {
+        const tableCfgs = hip({
+          _type: "tableCfgs",
+          _data: [
+            {
+              key: "tableA",
+              type: "components",
+              isHead: false,
+              isRoot: false,
+              isShared: true,
+              columns: [
+                {
+                  key: "_hash",
+                  type: "string",
+                  titleLong: "Hash",
+                  titleShort: "Hash"
+                },
+                {
+                  key: "propertyA",
+                  type: "string",
+                  titleLong: "Key",
+                  titleShort: "Key"
+                }
+              ],
+              _hash: ""
+            },
+            {
+              key: "tableB",
+              type: "components",
+              isHead: false,
+              isRoot: false,
+              isShared: true,
+              columns: [
+                {
+                  key: "_hash",
+                  type: "string",
+                  titleLong: "Hash",
+                  titleShort: "Hash"
+                },
+                {
+                  key: "propertyAFromTableA",
+                  type: "jsonValue",
+                  titleLong: "Table A Reference",
+                  titleShort: "TableARef",
+                  ref: {
+                    tableKey: "tableA",
+                    columnKey: "propertyA"
+                  }
+                }
+              ],
+              _hash: ""
+            }
+          ]
+        });
+        const tableA = hip({
+          _type: "components",
+          _tableCfg: tableCfgs._data[0]._hash,
+          _data: [
+            {
+              propertyA: "a0"
+            },
+            {
+              propertyA: "a1"
+            }
+          ],
+          _hash: ""
+        });
+        const tableB = hip({
+          _type: "components",
+          _tableCfg: tableCfgs._data[1]._hash,
+          _data: [
+            {
+              propertyAFromTableA: [tableA._data[0]._hash, "MISSINGREF"]
+              // Missing reference
+            }
+          ],
+          _hash: ""
+        });
         return {
-          tableA: {
-            _type: "components",
-            _data: [
-              {
-                keyA0: "a0"
-              },
-              {
-                keyA1: "a1"
-              }
-            ]
-          },
-          tableB: {
-            _type: "components",
-            _data: [
-              {
-                tableARef: ["KFQrf4mEz0UPmUaFHwH4T6", "MISSING"]
-              }
-            ]
-          }
+          tableCfgs,
+          tableA,
+          tableB
         };
       },
       missingReferencedTable: () => {
+        const tableCfgs = hip({
+          _type: "tableCfgs",
+          _data: [
+            {
+              key: "tableB",
+              type: "components",
+              isHead: false,
+              isRoot: false,
+              isShared: true,
+              columns: [
+                {
+                  key: "_hash",
+                  type: "string",
+                  titleLong: "Hash",
+                  titleShort: "Hash"
+                },
+                {
+                  key: "propertyAFromTableA",
+                  type: "jsonValue",
+                  titleLong: "Table A Reference",
+                  titleShort: "TableARef",
+                  ref: {
+                    tableKey: "tableA",
+                    // Referenced table missing
+                    columnKey: "propertyA"
+                  }
+                }
+              ],
+              _hash: ""
+            }
+          ]
+        });
+        const tableB = hip({
+          _type: "components",
+          _tableCfg: tableCfgs._data[0]._hash,
+          _data: [
+            {
+              propertyAFromTableA: "MISSINGREF"
+              // Missing reference
+            }
+          ],
+          _hash: ""
+        });
         return {
-          tableB: {
-            _type: "components",
-            _data: [
-              {
-                tableARef: "MISSINGREF"
-                // tableA is missing
-              }
-            ]
-          }
+          tableCfgs,
+          tableB
         };
       },
       missingSliceId: () => {
@@ -1400,7 +1596,6 @@ class _BaseValidator {
       () => this._rootOrHeadTableHasNoIdColumn(),
       // Check references
       () => this._refsNotFound(),
-      () => this._sliceIdRefsNotFound(),
       // Check layers
       () => this._layerBasesNotFound(),
       () => this._layerSliceIdsTableNotFound(),
@@ -1769,36 +1964,46 @@ class _BaseValidator {
   _refsNotFound() {
     const missingRefs = [];
     iterateTablesSync(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 targetItemRefs = Array.isArray(item[key]) ? item[key] : [item[key]];
-            for (const targetItemRef of targetItemRefs) {
-              const targetTableKey = typeof targetItemRef !== "string" ? targetItemRef.component : key.substring(0, key.length - 3);
-              const targetItemHash = typeof targetItemRef !== "string" ? targetItemRef.ref : targetItemRef;
-              const itemHash = item._hash;
+      if (tableKey === "tableCfgs") return;
+      const tableCfgRef = table._tableCfg;
+      if (!tableCfgRef) return;
+      const tableCfg = this.rljsonIndexed.tableCfgs._data[tableCfgRef];
+      /* v8 ignore next -- @preserve */
+      if (!tableCfg) return;
+      const tableRows = table._data;
+      for (const row of tableRows) {
+        for (const columnKey of Object.keys(row)) {
+          if (columnKey.startsWith("_")) continue;
+          const columnCfg = tableCfg.columns.find(
+            (col) => col.key === columnKey
+          );
+          /* v8 ignore next -- @preserve */
+          if (columnCfg === void 0) continue;
+          if (columnCfg.ref && columnCfg.ref.tableKey) {
+            const targetTableKey = columnCfg.ref.tableKey;
+            const targetRefs = Array.isArray(row[columnKey]) ? row[columnKey] : [row[columnKey]];
+            for (const targetRef of targetRefs) {
               if (this.tableKeys.indexOf(targetTableKey) === -1) {
                 missingRefs.push({
                   error: `Target table "${targetTableKey}" not found.`,
                   sourceTable: tableKey,
-                  sourceKey: key,
-                  sourceItemHash: itemHash,
-                  targetItemHash,
+                  sourceKey: columnKey,
+                  sourceItemHash: row._hash,
+                  targetItemHash: targetRef,
                   targetTable: targetTableKey
                 });
                 continue;
               }
               const targetTableIndexed = this.rljsonIndexed[targetTableKey];
-              const referencedItem = targetTableIndexed._data[targetItemHash];
+              const referencedItem = targetTableIndexed._data[targetRef];
               if (referencedItem === void 0) {
                 missingRefs.push({
                   sourceTable: tableKey,
-                  sourceItemHash: itemHash,
-                  sourceKey: key,
-                  targetItemHash,
+                  sourceItemHash: row._hash,
+                  sourceKey: columnKey,
+                  targetItemHash: targetRef,
                   targetTable: targetTableKey,
-                  error: `Table "${targetTableKey}" has no item with hash "${targetItemHash}"`
+                  error: `Table "${targetTableKey}" has no item with hash "${targetRef}"`
                 });
               }
             }
@@ -1814,49 +2019,6 @@ class _BaseValidator {
     }
   }
   // ...........................................................................
-  _sliceIdRefsNotFound() {
-    const missingSliceIdRefs = [];
-    iterateTablesSync(this.rljson, (tableKey, table) => {
-      const tableData = table._data;
-      for (const item of tableData) {
-        for (const key of Object.keys(item)) {
-          if (key.endsWith("SliceId")) {
-            const targetSliceIds = Array.isArray(item[key]) ? item[key] : [item[key]];
-            for (const targetSliceId of targetSliceIds) {
-              if (this.tableKeys.indexOf(key) === -1) {
-                missingSliceIdRefs.push({
-                  sourceTable: tableKey,
-                  targetSliceId,
-                  targetTable: key,
-                  error: `Target table "${targetSliceId}" not found.`
-                });
-                continue;
-              }
-              const targetSliceIdsTable = this.rljson[key];
-              const targetSliceIds2 = targetSliceIdsTable._data.flatMap(
-                (d) => [...d.add, ...d.remove ?? []]
-              );
-              if (targetSliceIds2.indexOf(targetSliceId) === -1) {
-                missingSliceIdRefs.push({
-                  sourceTable: tableKey,
-                  targetSliceId,
-                  targetTable: key,
-                  error: `Table "${key}" has no sliceId "${targetSliceId}"`
-                });
-              }
-            }
-          }
-        }
-      }
-    });
-    if (missingSliceIdRefs.length > 0) {
-      this.errors.refsNotFound = {
-        error: "Broken references",
-        missingRefs: missingSliceIdRefs
-      };
-    }
-  }
-  // ...........................................................................
   _layerBasesNotFound() {
     const brokenLayers = [];
     iterateTablesSync(this.rljson, (tableKey, table) => {

package/dist/src/example.ts

@@ -16,7 +16,6 @@ import { ColumnCfg, TablesCfgTable } from './content/table-cfg.ts';
 import { bakeryExample } from './example/bakery-example.ts';
 import { Rljson } from './rljson.ts';
 
-
 export class Example {
   static readonly ok = {
     bakery: (): Rljson => bakeryExample(),
@@ -158,26 +157,178 @@ export class Example {
     },
 
     singleRef: (): Rljson => {
+      const tableCfgs = hip<TablesCfgTable>({
+        _type: 'tableCfgs',
+        _data: [
+          {
+            key: 'tableA',
+            type: 'components',
+            isHead: false,
+            isRoot: false,
+            isShared: true,
+            columns: [
+              {
+                key: '_hash',
+                type: 'string',
+                titleLong: 'Hash',
+                titleShort: 'Hash',
+              },
+              {
+                key: 'propertyA',
+                type: 'string',
+                titleLong: 'Key',
+                titleShort: 'Key',
+              },
+            ],
+            _hash: '',
+          },
+          {
+            key: 'tableB',
+            type: 'components',
+            isHead: false,
+            isRoot: false,
+            isShared: true,
+            columns: [
+              {
+                key: '_hash',
+                type: 'string',
+                titleLong: 'Hash',
+                titleShort: 'Hash',
+              },
+              {
+                key: 'propertyAFromTableA',
+                type: 'string',
+                titleLong: 'Table A Reference',
+                titleShort: 'TableARef',
+                ref: {
+                  tableKey: 'tableA',
+                  columnKey: 'propertyA',
+                },
+              },
+            ],
+            _hash: '',
+          },
+        ],
+      } as TablesCfgTable);
+
+      const tableA = hip<ComponentsTable<Json>>({
+        _type: 'components',
+        _tableCfg: tableCfgs._data[0]._hash as string,
+        _data: [
+          {
+            propertyA: 'a0',
+          },
+          {
+            propertyA: 'a1',
+          },
+        ],
+        _hash: '',
+      });
+
+      const tableB = hip<ComponentsTable<Json>>({
+        _type: 'components',
+        _tableCfg: tableCfgs._data[1]._hash as string,
+        _data: [
+          {
+            propertyAFromTableA: tableA._data[0]._hash as string,
+          },
+        ],
+        _hash: '',
+      });
+
       return {
-        tableA: {
-          _type: 'components',
-          _data: [
-            {
-              keyA0: 'a0',
-            },
-            {
-              keyA1: 'a1',
-            },
-          ],
-        },
-        tableB: {
-          _type: 'components',
-          _data: [
-            {
-              tableARef: 'KFQrf4mEz0UPmUaFHwH4T6',
-            },
-          ],
-        },
+        tableCfgs,
+        tableA,
+        tableB,
+      };
+    },
+    multiRef: (): Rljson => {
+      const tableCfgs = hip<TablesCfgTable>({
+        _type: 'tableCfgs',
+        _data: [
+          {
+            key: 'tableA',
+            type: 'components',
+            isHead: false,
+            isRoot: false,
+            isShared: true,
+            columns: [
+              {
+                key: '_hash',
+                type: 'string',
+                titleLong: 'Hash',
+                titleShort: 'Hash',
+              },
+              {
+                key: 'propertyA',
+                type: 'string',
+                titleLong: 'Key',
+                titleShort: 'Key',
+              },
+            ],
+            _hash: '',
+          },
+          {
+            key: 'tableB',
+            type: 'components',
+            isHead: false,
+            isRoot: false,
+            isShared: true,
+            columns: [
+              {
+                key: '_hash',
+                type: 'string',
+                titleLong: 'Hash',
+                titleShort: 'Hash',
+              },
+              {
+                key: 'propertyAFromTableA',
+                type: 'jsonValue',
+                titleLong: 'Table A Reference',
+                titleShort: 'TableARef',
+                ref: {
+                  tableKey: 'tableA',
+                  columnKey: 'propertyA',
+                },
+              },
+            ],
+            _hash: '',
+          },
+        ],
+      } as TablesCfgTable);
+
+      const tableA = hip<ComponentsTable<Json>>({
+        _type: 'components',
+        _tableCfg: tableCfgs._data[0]._hash as string,
+        _data: [
+          {
+            propertyA: 'a0',
+          },
+          {
+            propertyA: 'a1',
+          },
+        ],
+        _hash: '',
+      });
+
+      const tableB = hip<ComponentsTable<Json>>({
+        _type: 'components',
+        _tableCfg: tableCfgs._data[1]._hash as string,
+        _data: [
+          {
+            propertyAFromTableA: [
+              tableA._data[0]._hash,
+              tableA._data[1]._hash,
+            ] as string[],
+          },
+        ],
+        _hash: '',
+      });
+
+      return {
+        tableCfgs,
+        tableA,
+        tableB,
       };
     },
     singleSliceIdRef: (): Rljson => {
@@ -220,90 +371,6 @@ export class Example {
         } as ComponentsTable<Json>,
       };
     },
-    singleNamedRef: (): Rljson => {
-      return {
-        tableA: {
-          _type: 'components',
-          _data: [
-            {
-              keyA0: 'a0',
-            },
-            {
-              keyA1: 'a1',
-            },
-          ],
-        },
-        tableB: {
-          _type: 'components',
-          _data: [
-            {
-              namedRef: { component: 'tableA', ref: 'KFQrf4mEz0UPmUaFHwH4T6' },
-            },
-          ],
-        },
-      };
-    },
-    multiRef: (): Rljson => {
-      return {
-        tableA: {
-          _type: 'components',
-          _data: [
-            {
-              keyA0: 'a0',
-            },
-            {
-              keyA1: 'a1',
-            },
-          ],
-        },
-        tableB: {
-          _type: 'components',
-          _data: [
-            {
-              tableARef: ['KFQrf4mEz0UPmUaFHwH4T6', 'YPw-pxhqaUOWRFGramr4B1'],
-            },
-          ],
-        },
-      };
-    },
-    multiMixedRef: (): Rljson => {
-      return {
-        tableA: {
-          _type: 'components',
-          _data: [
-            {
-              keyA0: 'a0',
-            },
-            {
-              keyA1: 'a1',
-            },
-          ],
-        },
-        tableB: {
-          _type: 'components',
-          _data: [
-            {
-              keyB0: 'b0',
-            },
-            {
-              keyB1: 'b1',
-            },
-          ],
-        },
-        tableC: {
-          _type: 'components',
-          _data: [
-            {
-              tableRef: [
-                { component: 'tableA', ref: 'KFQrf4mEz0UPmUaFHwH4T6' },
-                { component: 'tableB', ref: 'dXhIygNwNMVPEqFbsFJkn6' },
-              ],
-            },
-          ],
-        },
-      };
-    },
-
     complete: (): Rljson => {
       const sliceIds = hip<SliceIdsTable>({
         _type: 'sliceIds',
@@ -413,87 +480,226 @@ export class Example {
       },
 
       missingRef: (): Rljson => {
-        return {
-          tableA: {
-            _type: 'components',
-            _data: [
-              {
-                keyA0: 'a0',
-              },
-              {
-                keyA1: 'a1',
-              },
-            ],
-          },
-          tableB: {
-            _type: 'components',
-            _data: [
-              {
-                tableARef: 'MISSINGREF', // MISSINGREF does not exist in tableA
-              },
-            ],
-          },
-        };
-      },
+        const tableCfgs = hip<TablesCfgTable>({
+          _type: 'tableCfgs',
+          _data: [
+            {
+              key: 'tableA',
+              type: 'components',
+              isHead: false,
+              isRoot: false,
+              isShared: true,
+              columns: [
+                {
+                  key: '_hash',
+                  type: 'string',
+                  titleLong: 'Hash',
+                  titleShort: 'Hash',
+                },
+                {
+                  key: 'propertyA',
+                  type: 'string',
+                  titleLong: 'Key',
+                  titleShort: 'Key',
+                },
+              ],
+              _hash: '',
+            },
+            {
+              key: 'tableB',
+              type: 'components',
+              isHead: false,
+              isRoot: false,
+              isShared: true,
+              columns: [
+                {
+                  key: '_hash',
+                  type: 'string',
+                  titleLong: 'Hash',
+                  titleShort: 'Hash',
+                },
+                {
+                  key: 'propertyAFromTableA',
+                  type: 'jsonValue',
+                  titleLong: 'Table A Reference',
+                  titleShort: 'TableARef',
+                  ref: {
+                    tableKey: 'tableA',
+                    columnKey: 'propertyA',
+                  },
+                },
+              ],
+              _hash: '',
+            },
+          ],
+        } as TablesCfgTable);
+
+        const tableA = hip<ComponentsTable<Json>>({
+          _type: 'components',
+          _tableCfg: tableCfgs._data[0]._hash as string,
+          _data: [
+            {
+              propertyA: 'a0',
+            },
+            {
+              propertyA: 'a1',
+            },
+          ],
+          _hash: '',
+        });
+
+        const tableB = hip<ComponentsTable<Json>>({
+          _type: 'components',
+          _tableCfg: tableCfgs._data[1]._hash as string,
+          _data: [
+            {
+              propertyAFromTableA: 'MISSINGREF', // Missing reference
+            },
+          ],
+          _hash: '',
+        });
 
-      missingNamedRef: (): Rljson => {
         return {
-          tableA: {
-            _type: 'components',
-            _data: [
-              {
-                keyA0: 'a0',
-              },
-              {
-                keyA1: 'a1',
-              },
-            ],
-          },
-          tableB: {
-            _type: 'components',
-            _data: [
-              {
-                namedRef: { component: 'tableA', ref: 'MISSINGREF' }, // MISSINGREF does not exist in tableA
-              },
-            ],
-          },
+          tableCfgs,
+          tableA,
+          tableB,
         };
       },
 
       missingMultiRef: (): Rljson => {
+        const tableCfgs = hip<TablesCfgTable>({
+          _type: 'tableCfgs',
+          _data: [
+            {
+              key: 'tableA',
+              type: 'components',
+              isHead: false,
+              isRoot: false,
+              isShared: true,
+              columns: [
+                {
+                  key: '_hash',
+                  type: 'string',
+                  titleLong: 'Hash',
+                  titleShort: 'Hash',
+                },
+                {
+                  key: 'propertyA',
+                  type: 'string',
+                  titleLong: 'Key',
+                  titleShort: 'Key',
+                },
+              ],
+              _hash: '',
+            },
+            {
+              key: 'tableB',
+              type: 'components',
+              isHead: false,
+              isRoot: false,
+              isShared: true,
+              columns: [
+                {
+                  key: '_hash',
+                  type: 'string',
+                  titleLong: 'Hash',
+                  titleShort: 'Hash',
+                },
+                {
+                  key: 'propertyAFromTableA',
+                  type: 'jsonValue',
+                  titleLong: 'Table A Reference',
+                  titleShort: 'TableARef',
+                  ref: {
+                    tableKey: 'tableA',
+                    columnKey: 'propertyA',
+                  },
+                },
+              ],
+              _hash: '',
+            },
+          ],
+        } as TablesCfgTable);
+
+        const tableA = hip<ComponentsTable<Json>>({
+          _type: 'components',
+          _tableCfg: tableCfgs._data[0]._hash as string,
+          _data: [
+            {
+              propertyA: 'a0',
+            },
+            {
+              propertyA: 'a1',
+            },
+          ],
+          _hash: '',
+        });
+
+        const tableB = hip<ComponentsTable<Json>>({
+          _type: 'components',
+          _tableCfg: tableCfgs._data[1]._hash as string,
+          _data: [
+            {
+              propertyAFromTableA: [tableA._data[0]._hash, 'MISSINGREF'], // Missing reference
+            },
+          ],
+          _hash: '',
+        });
+
         return {
-          tableA: {
-            _type: 'components',
-            _data: [
-              {
-                keyA0: 'a0',
-              },
-              {
-                keyA1: 'a1',
-              },
-            ],
-          },
-          tableB: {
-            _type: 'components',
-            _data: [
-              {
-                tableARef: ['KFQrf4mEz0UPmUaFHwH4T6', 'MISSING'],
-              },
-            ],
-          },
+          tableCfgs,
+          tableA,
+          tableB,
         };
       },
 
       missingReferencedTable: (): Rljson => {
+        const tableCfgs = hip<TablesCfgTable>({
+          _type: 'tableCfgs',
+          _data: [
+            {
+              key: 'tableB',
+              type: 'components',
+              isHead: false,
+              isRoot: false,
+              isShared: true,
+              columns: [
+                {
+                  key: '_hash',
+                  type: 'string',
+                  titleLong: 'Hash',
+                  titleShort: 'Hash',
+                },
+                {
+                  key: 'propertyAFromTableA',
+                  type: 'jsonValue',
+                  titleLong: 'Table A Reference',
+                  titleShort: 'TableARef',
+                  ref: {
+                    tableKey: 'tableA', // Referenced table missing
+                    columnKey: 'propertyA',
+                  },
+                },
+              ],
+              _hash: '',
+            },
+          ],
+        } as TablesCfgTable);
+
+        const tableB = hip<ComponentsTable<Json>>({
+          _type: 'components',
+          _tableCfg: tableCfgs._data[0]._hash as string,
+          _data: [
+            {
+              propertyAFromTableA: 'MISSINGREF', // Missing reference
+            },
+          ],
+          _hash: '',
+        });
+
         return {
-          tableB: {
-            _type: 'components',
-            _data: [
-              {
-                tableARef: 'MISSINGREF', // tableA is missing
-              },
-            ],
-          },
+          tableCfgs,
+          tableB,
         };
       },
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rljson/rljson",
-  "version": "0.0.65",
+  "version": "0.0.66",
   "description": "The RLJSON data format specification",
   "homepage": "https://github.com/rljson/rljson",
   "bugs": "https://github.com/rljson/rljson/issues",