@rljson/rljson 0.0.12 → 0.0.14

package/dist/example.d.ts

@@ -1,31 +1,39 @@
 import { Rljson } from './rljson.ts';
-/**
- * Provides Rljson examples
- */
 export declare class Example {
-    /**
-     * Returns the Rljson bakery example
-     */
-    static bakery(): Rljson;
-    /**
-     * Returns an Rljson object with one row containing all JSON types
-     */
-    static withAllJsonTypes(): Rljson;
-    /**
-     * Returns an empty Rljson object
-     */
-    static empty(): Rljson;
-    /**
-     * Returns an Rljson with a table containing all combinations of true and
-     * false. This is useful for testing search operators.
-     */
-    static binary(): Rljson;
-    /**
-     * An more complex example containing an table with multiple rows
-     */
-    static multiRow(): Rljson;
-    /**
-     * Returns an Rljson object with a broken table name
-     */
-    static withBrokenTableName(): Rljson;
+    static readonly ok: {
+        bakery: () => Rljson;
+        empty: () => Rljson;
+        binary: () => Rljson;
+        singleRow: () => Rljson;
+        multipleRows: () => Rljson;
+        singleRef: () => Rljson;
+        complete: () => Rljson;
+    };
+    static readonly broken: {
+        brokenTableName: () => {
+            brok$en: {
+                _type: string;
+                _data: never[];
+            };
+        };
+        missingData: () => Rljson;
+        dataNotBeingAnArray: () => Rljson;
+        missingRef: () => Rljson;
+        missingReferencedTable: () => Rljson;
+        collections: {
+            missingBase: () => Rljson;
+            missingIdSet: () => Rljson;
+            missingAssignedPropertyTable: () => Rljson;
+            missingAssignedProperty: () => Rljson;
+        };
+        cakes: {
+            missingIdSet: () => Rljson;
+            missingCollectionsTable: () => Rljson;
+            missingLayerCollection: () => Rljson;
+        };
+        buffets: {
+            missingTable: () => Rljson;
+            missingItems: () => Rljson;
+        };
+    };
 }

package/dist/index.d.ts

@@ -4,5 +4,6 @@ export * from './content/collection.ts';
 export * from './content/id-set.ts';
 export * from './content/properties.ts';
 export * from './example.ts';
+export * from './rljson-indexed.ts';
 export * from './rljson.ts';
 export * from './typedefs.ts';

package/dist/rljson-indexed.d.ts

@@ -0,0 +1,19 @@
+import { Json } from '@rljson/json';
+import { Rljson } from './rljson.ts';
+/**
+ * An Rljson object where all tables' rows are indexed by their hash.
+ */
+export interface RljsonIndexed {
+    [tableName: string]: {
+        _data: {
+            [rowHash: string]: Json;
+        };
+    };
+    [key: `_${string}`]: any;
+}
+/**
+ * Returns an rljson where all tables' rows are indexed by their hash.
+ * @param rljson - The Rljson object to index
+ * @returns The indexed Rljson object
+ */
+export declare const rljsonIndexed: (rljson: Rljson) => RljsonIndexed;

package/dist/rljson.d.ts

@@ -4,7 +4,7 @@ import { CakesTable } from './content/cake.ts';
 import { CollectionsTable } from './content/collection.ts';
 import { IdSetsTable } from './content/id-set.ts';
 import { PropertiesTable } from './content/properties.ts';
-import { ContentType, TableName } from './typedefs.ts';
+import { ContentType, Ref, TableName } from './typedefs.ts';
 export declare const reservedFieldNames: string[];
 export declare const reservedTableNames: string[];
 /**
@@ -12,8 +12,22 @@ export declare const reservedTableNames: string[];
  */
 export type TableType = BuffetsTable | PropertiesTable<any> | CollectionsTable | IdSetsTable | CakesTable;
 /** The rljson data format */
-export type Rljson = {
+export interface Rljson extends Json {
     [tableId: TableName]: TableType;
+}
+/**
+ * Rljson set with private fields
+ */
+export type RljsonPrivate = {
+    /**
+     * Contains id sets used accross the Rljson object
+     */
+    _idSets: IdSetsTable;
+    /**
+     * Used by validation. If external references are not present,
+     * validation does not throw an error.
+     */
+    _externalRefs: Ref[];
 };
 /** An example rljson object */
 export declare const exampleRljson: () => Rljson;
@@ -21,6 +35,13 @@ export declare const exampleRljson: () => Rljson;
 export interface RljsonTable<Data extends Json, Type extends ContentType> extends Json {
     /** The data rows of the table */
     _data: Data[];
-    /**  The type of the table */
+    /**  The type of the table. If not set, the type is "properties" */
     _type: Type;
 }
+/**
+ * Iterates over all tables of an Rljson object.
+ * Skips private members starting with _
+ * @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;

package/dist/rljson.js

@@ -1,160 +1,147 @@
+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";
 // @license
-const bakeryExample = {
-  buffets: {
-    _type: "buffets",
-    _data: [
-      // Counter
-      {
-        items: [
-          // Angle pie
-          {
-            table: "cakes",
-            ref: "ap"
+const bakeryExample = () => {
+  return {
+    // Every rljson object has a list of id-sets other objects can refer to
+    _idSets: {
+      _type: "idSets",
+      _data: [
+        {
+          add: ["slice0", "slice1"],
+          _hash: "KAwCRFD4mdx8b1bzxBb2_O"
+        }
+      ]
+    },
+    // A bakery offers a variety of buffets containing different pastries
+    buffets: {
+      _type: "buffets",
+      _data: [
+        {
+          items: [{ table: "cakes", ref: "fw8IrV05Z1ZekPXTdUdmt8" }]
+        }
+      ]
+    },
+    // A cake is a collection of layers, i.e. a base, a filling and a topping.
+    // Each layer of the cake has the same slice structure.
+    cakes: {
+      _type: "cakes",
+      _data: [
+        {
+          idSet: "KAwCRFD4mdx8b1bzxBb2_O",
+          collections: "layers",
+          layers: {
+            _hash: "50ZHxZ8KeUYJ3NC7ax5CbR"
           },
-          // Cumb cake
-          {
-            table: "cakes",
-            ref: "cc"
-          }
-        ]
-      },
-      // Fridge
-      {
-        id: "fridge",
-        items: [
-          // Black forest cake
-          {
-            table: "cakes",
-            ref: "bfc"
+          _hash: "gMqFPTkYU66L32jDYZiZ79"
+        }
+      ],
+      _hash: "fw8IrV05Z1ZekPXTdUdmt8"
+    },
+    // Cakes are cut into slices. The cake layers are shared among the slices.
+    slices: {
+      _type: "idSets",
+      _data: [
+        {
+          add: ["slice0", "slice1"],
+          remove: []
+        }
+      ]
+    },
+    // A layer is a collection of ingredients described by a recipe
+    layers: {
+      _type: "collections",
+      _data: [
+        {
+          properties: "recipes",
+          assign: {
+            slice0: "VXUW79JrkOAG_pQ-75ahH5",
+            slice1: "VXUW79JrkOAG_pQ-75ahH5",
+            _hash: "Di4uG3-DHSq3_ArFu0V68m"
           },
-          // Lemon cheese cake
-          {
-            table: "cakes",
-            ref: "lcc"
-          }
-        ]
-      }
-    ]
-  },
-  cakes: {
-    _type: "cakes",
-    _data: []
-  },
-  layers: {
-    _type: "collections",
-    _data: []
-  },
-  sliceIds: {
-    _type: "idSets",
-    _data: [
-      {
-        base: null,
-        add: [
-          "slice0",
-          "slice1",
-          "slice2",
-          "slice3",
-          "slice4",
-          "slice5",
-          "slice6",
-          "slice7",
-          "slice8",
-          "slice9",
-          "slice10",
-          "slice11"
-        ],
-        remove: []
-      }
-    ]
-  },
-  nutritiveValues: {
-    _type: "properties",
-    _data: []
-  }
+          _hash: "IIg0e-6Qr73s7sNZe0RhKs"
+        }
+      ],
+      _hash: "e3utfEf_VS1-ljAMgqesua"
+    },
+    // Recipes are sets of ingredients
+    recipes: {
+      _type: "collections",
+      _data: [
+        {
+          properties: "recipeIngredients",
+          assign: {
+            flour: "mqLl7Q44V1t2MotJvaVRM_",
+            _hash: "UImWlyWZTSGhNAMC1JUzF1"
+          },
+          _hash: "G1YV_P8-_vTxtkXXHJeNBI"
+        }
+      ],
+      _hash: "r3lw7VsnywyasRmtynZqIt"
+    },
+    // A recipe ingredient combines an ingredient type with a quantity
+    recipeIngredients: {
+      _type: "properties",
+      _data: [
+        {
+          ingredientTypesRef: "WOfnFT1svec3iJ6x",
+          quantity: 500,
+          _hash: "mqLl7Q44V1t2MotJvaVRM_"
+        }
+      ],
+      _hash: "J7GJEjCRXLNfdAHARg_fzx"
+    },
+    // A table describing basic properties of ingredients
+    ingredients: {
+      _type: "properties",
+      _data: [
+        {
+          name: "flour",
+          amountUnit: "g",
+          nutritiveValuesRef: "gZXFSlrl5QAs5hOVsq5sWB",
+          _hash: "CdSJV-WOfnFT1svec3iJ6x"
+        }
+      ],
+      _hash: "FgJeTM0NcZvXwFcU-PD8Jf"
+    },
+    // A table with nutritive values of ingredients
+    nutritiveValues: {
+      _type: "properties",
+      _data: [
+        {
+          energy: 364,
+          fat: 0.98,
+          protein: 10.33,
+          carbohydrates: 76.31,
+          _hash: "gZXFSlrl5QAs5hOVsq5sWB"
+        }
+      ],
+      _hash: "7k4OqQtk71w3yVGMoA9F6p"
+    }
+  };
 };
 // @license
-const exampleBuffetsTable = bakeryExample.buffets;
+const exampleBuffetsTable = () => bakeryExample().buffets;
 // @license
-const exampleCakesTable = Object.freeze(bakeryExample.cakes);
+const exampleCakesTable = () => bakeryExample().cakes;
 // @license
-const exampleCollectionsTable = Object.freeze(
-  bakeryExample.layers
-);
+const exampleCollectionsTable = () => bakeryExample().layers;
 // @license
-const exampleIdSetsTable = Object.freeze(bakeryExample.sliceIds);
+const exampleIdSetsTable = () => bakeryExample().slices;
 // @license
-const examplePropertiesTable = Object.freeze(bakeryExample.nutritiveValues);
+const examplePropertiesTable = () => bakeryExample().nutritiveValues;
 // @license
-class Example {
-  /**
-   * Returns the Rljson bakery example
-   */
-  static bakery() {
-    return {
-      // A bakery is a collection of buffets
-      bakery: {
-        name: "Bakery",
-        _type: "buffets",
-        _data: [
-          // Counter
-          {
-            id: "counter",
-            items: [
-              // Angle pie
-              {
-                table: "cakes",
-                ref: "ap"
-              },
-              // Cumb cake
-              {
-                table: "cakes",
-                ref: "cc"
-              }
-            ]
-          },
-          // Fridge
-          {
-            id: "fridge",
-            items: [
-              // Black forest
-              {
-                table: "cakes",
-                ref: "bf"
-              },
-              // Lemon cheese cake
-              {
-                table: "cakes",
-                ref: "cc"
-              }
-            ]
-          }
-        ]
-      }
-    };
-  }
-  /**
-   * Returns an Rljson object with one row containing all JSON types
-   */
-  static withAllJsonTypes() {
-    return {
-      table: {
-        _type: "properties",
-        _data: [exampleJsonObject()]
-      }
-    };
-  }
-  /**
-   * Returns an empty Rljson object
-   */
-  static empty() {
+const _Example = class _Example {
+};
+__publicField(_Example, "ok", {
+  bakery: () => bakeryExample(),
+  empty: () => {
     return {};
-  }
-  /**
-   * Returns an Rljson with a table containing all combinations of true and
-   * false. This is useful for testing search operators.
-   */
-  static binary() {
+  },
+  binary: () => {
     return {
       table: {
         _type: "properties",
@@ -166,11 +153,16 @@ class Example {
         ]
       }
     };
-  }
-  /**
-   * An more complex example containing an table with multiple rows
-   */
-  static multiRow() {
+  },
+  singleRow: () => {
+    return {
+      table: {
+        _type: "properties",
+        _data: [exampleJsonObject()]
+      }
+    };
+  },
+  multipleRows: () => {
     return {
       table: {
         _type: "properties",
@@ -199,30 +191,274 @@ class Example {
         ]
       }
     };
+  },
+  singleRef: () => {
+    return {
+      tableA: {
+        _type: "properties",
+        _data: [
+          {
+            keyA0: "a0"
+          },
+          {
+            keyA1: "a1"
+          }
+        ]
+      },
+      tableB: {
+        _type: "properties",
+        _data: [
+          {
+            tableARef: "KFQrf4mEz0UPmUaFHwH4T6"
+          }
+        ]
+      }
+    };
+  },
+  complete: () => {
+    return {
+      _idSets: {
+        _type: "idSets",
+        _data: [
+          {
+            add: ["id0", "id1"],
+            _hash: "MgHRBYSrhpyl4rvsOmAWcQ"
+          }
+        ]
+      },
+      properties: {
+        _type: "properties",
+        _data: [
+          { a: "0", _hash: "AFhW-fMzdCiz6bUZscp1Lf" },
+          { a: "1", _hash: "mv6w8rID8lQxLsje1EHQMY" }
+        ]
+      },
+      collections: {
+        _type: "collections",
+        _data: [
+          {
+            idSet: "MgHRBYSrhpyl4rvsOmAWcQ",
+            properties: "properties",
+            _hash: "sxv2NCM6UNOcX-i9FhOs5W",
+            assign: {}
+          },
+          {
+            base: "sxv2NCM6UNOcX-i9FhOs5W",
+            idSet: "MgHRBYSrhpyl4rvsOmAWcQ",
+            properties: "properties",
+            assign: {
+              id0: "AFhW-fMzdCiz6bUZscp1Lf",
+              id1: "mv6w8rID8lQxLsje1EHQMY"
+            },
+            _hash: "QB2JC6X_-rUAoixuldzWP-"
+          }
+        ]
+      },
+      cakes: {
+        _type: "cakes",
+        _data: [
+          {
+            idSet: "MgHRBYSrhpyl4rvsOmAWcQ",
+            collections: "collections",
+            layers: {
+              layer0: "sxv2NCM6UNOcX-i9FhOs5W",
+              layer1: "QB2JC6X_-rUAoixuldzWP-"
+            },
+            _hash: "QlTVJL3uoXO1L_fw2evLPe"
+          }
+        ]
+      },
+      buffets: {
+        _type: "buffets",
+        _data: [
+          {
+            items: [
+              {
+                table: "cakes",
+                ref: "QlTVJL3uoXO1L_fw2evLPe"
+              },
+              {
+                table: "collections",
+                ref: "QB2JC6X_-rUAoixuldzWP-"
+              }
+            ]
+          }
+        ]
+      }
+    };
   }
-  /**
-   * Returns an Rljson object with a broken table name
-   */
-  static withBrokenTableName() {
+});
+__publicField(_Example, "broken", {
+  brokenTableName: () => {
     return {
       brok$en: {
         _type: "properties",
         _data: []
       }
     };
+  },
+  missingData: () => {
+    return {
+      table: {
+        _type: "properties"
+      }
+    };
+  },
+  dataNotBeingAnArray: () => {
+    return {
+      table: {
+        _type: "properties",
+        _data: {}
+      }
+    };
+  },
+  missingRef: () => {
+    return {
+      tableA: {
+        _type: "properties",
+        _data: [
+          {
+            keyA0: "a0"
+          },
+          {
+            keyA1: "a1"
+          }
+        ]
+      },
+      tableB: {
+        _type: "properties",
+        _data: [
+          {
+            tableARef: "MISSINGREF"
+            // MISSINGREF does not exist in tableA
+          }
+        ]
+      }
+    };
+  },
+  missingReferencedTable: () => {
+    return {
+      tableB: {
+        _type: "properties",
+        _data: [
+          {
+            tableARef: "MISSINGREF"
+            // tableA is missing
+          }
+        ]
+      }
+    };
+  },
+  collections: {
+    missingBase: () => {
+      const result = _Example.ok.complete();
+      const collection1 = result.collections._data[1];
+      collection1.base = "MISSING";
+      return hip(result, true, false);
+    },
+    missingIdSet: () => {
+      const result = _Example.ok.complete();
+      const collection1 = result.collections._data[1];
+      collection1.idSet = "MISSING1";
+      return hip(result, true, false);
+    },
+    missingAssignedPropertyTable: () => {
+      const result = _Example.ok.complete();
+      delete result.properties;
+      return result;
+    },
+    missingAssignedProperty: () => {
+      const result = _Example.ok.complete();
+      result.properties._data.splice(1, 2);
+      return result;
+    }
+  },
+  cakes: {
+    missingIdSet: () => {
+      const result = _Example.ok.complete();
+      result.cakes._data[0].idSet = "MISSING";
+      hip(result.cakes, true, false);
+      return result;
+    },
+    missingCollectionsTable: () => {
+      const result = _Example.ok.complete();
+      result.cakes._data[0].collections = "MISSING";
+      hip(result.cakes, true, false);
+      return result;
+    },
+    missingLayerCollection: () => {
+      const result = _Example.ok.complete();
+      result.cakes._data[0].layers["layer0"] = "MISSING0";
+      result.cakes._data[0].layers["layer1"] = "MISSING1";
+      hip(result.cakes, true, false);
+      return result;
+    }
+  },
+  buffets: {
+    missingTable: () => {
+      const result = _Example.ok.complete();
+      const buffet = result.buffets._data[0];
+      buffet.items[0].table = "MISSING0";
+      buffet.items[1].table = "MISSING1";
+      hip(buffet, true, false);
+      return result;
+    },
+    missingItems: () => {
+      const result = _Example.ok.complete();
+      const buffet = result.buffets._data[0];
+      buffet.items[0].ref = "MISSING0";
+      buffet.items[1].ref = "MISSING1";
+      hip(buffet, true, false);
+      return result;
+    }
+  }
+});
+let Example = _Example;
+// @license
+const rljsonIndexed = (rljson) => {
+  const result = {};
+  for (const key in rljson) {
+    const item = rljson[key];
+    if (typeof item != "object") {
+      result[key] = item;
+      continue;
+    }
+    const dataIndexed = {};
+    result[key] = { ...item };
+    if (!Array.isArray(item._data)) {
+      continue;
+    }
+    for (const row of item._data) {
+      const hashedRow = row._hash ? row : hsh(row);
+      const hash = hashedRow._hash;
+      dataIndexed[hash] = hashedRow;
+    }
+    result[key]._data = dataIndexed;
   }
-}
+  return result;
+};
 // @license
 const reservedFieldNames = ["_type", "_data"];
 const reservedTableNames = ["_hash", "_tables", "_columns"];
-const exampleRljson = () => Example.withAllJsonTypes();
+const exampleRljson = () => Example.ok.singleRow();
+const iterateTables = (rljson, callback) => {
+  for (const tableName in rljson) {
+    const value = rljson[tableName];
+    if (typeof value !== "object" || !Array.isArray(value._data)) {
+      continue;
+    }
+    callback(tableName, rljson[tableName]);
+  }
+};
 // @license
-const exampleTypedefs = Object.freeze({
-  ref: "ref",
-  itemId: "itemId",
-  tableName: "tableName",
-  contentType: "collections"
-});
+const exampleTypedefs = () => {
+  return {
+    ref: "ref",
+    itemId: "itemId",
+    tableName: "tableName",
+    contentType: "collections"
+  };
+};
 export {
   Example,
   exampleBuffetsTable,
@@ -232,6 +468,8 @@ export {
   examplePropertiesTable,
   exampleRljson,
   exampleTypedefs,
+  iterateTables,
   reservedFieldNames,
-  reservedTableNames
+  reservedTableNames,
+  rljsonIndexed
 };

package/dist/src/example.ts

@@ -4,147 +4,317 @@
 // Use of this source code is governed by terms that can be
 // found in the LICENSE file in the root of this package.
 
+import { hip } from '@rljson/hash';
 import { exampleJsonObject } from '@rljson/json';
 
-import { BuffetsTable } from './content/buffet.ts';
+import { bakeryExample } from './example/bakery-example.ts';
 import { Rljson } from './rljson.ts';
 
-/**
- * Provides Rljson examples
- */
 export class Example {
-  /**
-   * Returns the Rljson bakery example
-   */
-  static bakery(): Rljson {
-    return {
-      // A bakery is a collection of buffets
-      bakery: {
-        name: 'Bakery',
-        _type: 'buffets',
-        _data: [
-          // Counter
-          {
-            id: 'counter',
-            items: [
-              // Angle pie
-              {
-                table: 'cakes',
-                ref: 'ap',
-              },
+  static readonly ok = {
+    bakery: (): Rljson => bakeryExample(),
 
-              // Cumb cake
-              {
-                table: 'cakes',
-                ref: 'cc',
-              },
-            ],
-          },
-
-          // Fridge
-          {
-            id: 'fridge',
-            items: [
-              // Black forest
-              {
-                table: 'cakes',
-                ref: 'bf',
+    empty: (): Rljson => {
+      return {};
+    },
+
+    binary: (): Rljson => {
+      return {
+        table: {
+          _type: 'properties',
+          _data: [
+            { a: false, b: false },
+            { a: false, b: true },
+            { a: true, b: false },
+            { a: true, b: true },
+          ],
+        },
+      };
+    },
+
+    singleRow: (): Rljson => {
+      return {
+        table: {
+          _type: 'properties',
+          _data: [exampleJsonObject()],
+        },
+      };
+    },
+
+    multipleRows: (): Rljson => {
+      return {
+        table: {
+          _type: 'properties',
+          _data: [
+            {
+              string: 'str0',
+              boolean: true,
+              number: 1,
+              array: [1, 'str0', true, { a: { b: 'c' } }],
+              object: { a: { b: 'c' } },
+            },
+
+            {
+              string: 'str1',
+              boolean: true,
+              number: 1,
+              array: [1, 'str1', true, { a: { b: 'c' } }],
+              object: { a: { b: 'c' } },
+            },
+
+            {
+              string: 'str2',
+              boolean: false,
+              number: 1,
+              array: [1, 'str1', true, { a: { b: 'c' } }],
+              object: { d: { e: 'f' } },
+            },
+          ],
+        },
+      };
+    },
+
+    singleRef: (): Rljson => {
+      return {
+        tableA: {
+          _type: 'properties',
+          _data: [
+            {
+              keyA0: 'a0',
+            },
+            {
+              keyA1: 'a1',
+            },
+          ],
+        },
+        tableB: {
+          _type: 'properties',
+          _data: [
+            {
+              tableARef: 'KFQrf4mEz0UPmUaFHwH4T6',
+            },
+          ],
+        },
+      };
+    },
+    complete: (): Rljson => {
+      return {
+        _idSets: {
+          _type: 'idSets',
+
+          _data: [
+            {
+              add: ['id0', 'id1'],
+              _hash: 'MgHRBYSrhpyl4rvsOmAWcQ',
+            },
+          ],
+        },
+
+        properties: {
+          _type: 'properties',
+          _data: [
+            { a: '0', _hash: 'AFhW-fMzdCiz6bUZscp1Lf' },
+            { a: '1', _hash: 'mv6w8rID8lQxLsje1EHQMY' },
+          ],
+        },
+
+        collections: {
+          _type: 'collections',
+          _data: [
+            {
+              idSet: 'MgHRBYSrhpyl4rvsOmAWcQ',
+              properties: 'properties',
+              _hash: 'sxv2NCM6UNOcX-i9FhOs5W',
+              assign: {},
+            },
+            {
+              base: 'sxv2NCM6UNOcX-i9FhOs5W',
+              idSet: 'MgHRBYSrhpyl4rvsOmAWcQ',
+              properties: 'properties',
+              assign: {
+                id0: 'AFhW-fMzdCiz6bUZscp1Lf',
+                id1: 'mv6w8rID8lQxLsje1EHQMY',
               },
+              _hash: 'QB2JC6X_-rUAoixuldzWP-',
+            },
+          ],
+        },
 
-              // Lemon cheese cake
-              {
-                table: 'cakes',
-                ref: 'cc',
+        cakes: {
+          _type: 'cakes',
+          _data: [
+            {
+              idSet: 'MgHRBYSrhpyl4rvsOmAWcQ',
+              collections: 'collections',
+              layers: {
+                layer0: 'sxv2NCM6UNOcX-i9FhOs5W',
+                layer1: 'QB2JC6X_-rUAoixuldzWP-',
               },
-            ],
-          },
-        ],
-      } as BuffetsTable,
-    };
-  }
-
-  /**
-   * Returns an Rljson object with one row containing all JSON types
-   */
-  static withAllJsonTypes(): Rljson {
-    return {
-      table: {
-        _type: 'properties',
-        _data: [exampleJsonObject()],
+              _hash: 'QlTVJL3uoXO1L_fw2evLPe',
+            },
+          ],
+        },
+
+        buffets: {
+          _type: 'buffets',
+          _data: [
+            {
+              items: [
+                {
+                  table: 'cakes',
+                  ref: 'QlTVJL3uoXO1L_fw2evLPe',
+                },
+                {
+                  table: 'collections',
+                  ref: 'QB2JC6X_-rUAoixuldzWP-',
+                },
+              ],
+            },
+          ],
+        },
+      };
+    },
+  };
+
+  static readonly broken = {
+    brokenTableName: () => {
+      return {
+        brok$en: {
+          _type: 'properties',
+          _data: [],
+        },
+      };
+    },
+
+    missingData: () => {
+      return {
+        table: {
+          _type: 'properties',
+        },
+      } as unknown as Rljson;
+    },
+
+    dataNotBeingAnArray: () => {
+      return {
+        table: {
+          _type: 'properties',
+          _data: {},
+        },
+      } as unknown as Rljson;
+    },
+
+    missingRef: (): Rljson => {
+      return {
+        tableA: {
+          _type: 'properties',
+          _data: [
+            {
+              keyA0: 'a0',
+            },
+            {
+              keyA1: 'a1',
+            },
+          ],
+        },
+        tableB: {
+          _type: 'properties',
+          _data: [
+            {
+              tableARef: 'MISSINGREF', // MISSINGREF does not exist in tableA
+            },
+          ],
+        },
+      };
+    },
+
+    missingReferencedTable: (): Rljson => {
+      return {
+        tableB: {
+          _type: 'properties',
+          _data: [
+            {
+              tableARef: 'MISSINGREF', // tableA is missing
+            },
+          ],
+        },
+      };
+    },
+
+    collections: {
+      missingBase: (): Rljson => {
+        const result = Example.ok.complete();
+        const collection1 = result.collections._data[1];
+        collection1.base = 'MISSING'; // Missing base
+
+        // Recalculate hashes
+        return hip(result, true, false);
       },
-    };
-  }
-
-  /**
-   * Returns an empty Rljson object
-   */
-  static empty(): Rljson {
-    return {};
-  }
-
-  /**
-   * Returns an Rljson with a table containing all combinations of true and
-   * false. This is useful for testing search operators.
-   */
-  static binary(): Rljson {
-    return {
-      table: {
-        _type: 'properties',
-        _data: [
-          { a: false, b: false },
-          { a: false, b: true },
-          { a: true, b: false },
-          { a: true, b: true },
-        ],
+
+      missingIdSet: (): Rljson => {
+        const result = Example.ok.complete();
+        const collection1 = result.collections._data[1];
+
+        collection1.idSet = 'MISSING1';
+
+        // Recalculate hashes
+        return hip(result, true, false);
       },
-    };
-  }
-
-  /**
-   * An more complex example containing an table with multiple rows
-   */
-  static multiRow(): Rljson {
-    return {
-      table: {
-        _type: 'properties',
-        _data: [
-          {
-            string: 'str0',
-            boolean: true,
-            number: 1,
-            array: [1, 'str0', true, { a: { b: 'c' } }],
-            object: { a: { b: 'c' } },
-          },
-
-          {
-            string: 'str1',
-            boolean: true,
-            number: 1,
-            array: [1, 'str1', true, { a: { b: 'c' } }],
-            object: { a: { b: 'c' } },
-          },
-
-          {
-            string: 'str2',
-            boolean: false,
-            number: 1,
-            array: [1, 'str1', true, { a: { b: 'c' } }],
-            object: { d: { e: 'f' } },
-          },
-        ],
+
+      missingAssignedPropertyTable: (): Rljson => {
+        const result = Example.ok.complete();
+        delete result.properties; // Remove properties table
+        return result;
+      },
+
+      missingAssignedProperty: (): Rljson => {
+        const result = Example.ok.complete();
+        result.properties._data.splice(1, 2); // Remove an property that is assigne
+        return result;
       },
-    };
-  }
-
-  /**
-   * Returns an Rljson object with a broken table name
-   */
-  static withBrokenTableName(): Rljson {
-    return {
-      brok$en: {
-        _type: 'properties',
-        _data: [],
+    },
+
+    cakes: {
+      missingIdSet: (): Rljson => {
+        const result = Example.ok.complete();
+        result.cakes._data[0].idSet = 'MISSING'; // Missing ID set
+        hip(result.cakes, true, false);
+        return result;
+      },
+
+      missingCollectionsTable: (): Rljson => {
+        const result = Example.ok.complete();
+        result.cakes._data[0].collections = 'MISSING'; // Missing collections table
+        hip(result.cakes, true, false);
+        return result;
+      },
+
+      missingLayerCollection: (): Rljson => {
+        const result = Example.ok.complete();
+        result.cakes._data[0].layers['layer0'] = 'MISSING0';
+        result.cakes._data[0].layers['layer1'] = 'MISSING1';
+        hip(result.cakes, true, false);
+        return result;
+      },
+    },
+
+    buffets: {
+      missingTable: (): Rljson => {
+        const result = Example.ok.complete();
+        const buffet = result.buffets._data[0];
+        buffet.items[0].table = 'MISSING0';
+        buffet.items[1].table = 'MISSING1';
+        hip(buffet, true, false);
+        return result;
+      },
+
+      missingItems: (): Rljson => {
+        const result = Example.ok.complete();
+        const buffet = result.buffets._data[0];
+        buffet.items[0].ref = 'MISSING0';
+        buffet.items[1].ref = 'MISSING1';
+        hip(buffet, true, false);
+        return result;
       },
-    };
-  }
+    },
+  };
 }

package/dist/typedefs.d.ts

@@ -22,7 +22,10 @@ export type TableName = ItemId;
  * - `properties` Tables containing item properties
  */
 export type ContentType = 'buffets' | 'cakes' | 'collections' | 'idSets' | 'properties';
-export declare const exampleTypedefs: {
+/**
+ * An example object using the typedefs
+ */
+export declare const exampleTypedefs: () => {
     ref: Ref;
     itemId: ItemId;
     tableName: TableName;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rljson/rljson",
-  "version": "0.0.12",
-  "packageManager": "pnpm@10.6.2",
+  "version": "0.0.14",
+  "packageManager": "pnpm@10.6.3",
   "description": "The RLJSON data format specification",
   "homepage": "https://github.com/rljson/rljson",
   "bugs": "https://github.com/rljson/rljson/issues",
@@ -32,10 +32,10 @@
     "@types/node": "^22.13.10",
     "@typescript-eslint/eslint-plugin": "^8.26.1",
     "@typescript-eslint/parser": "^8.26.1",
-    "@vitest/coverage-v8": "^3.0.8",
+    "@vitest/coverage-v8": "^3.0.9",
     "cross-env": "^7.0.3",
     "eslint": "^9.22.0",
-    "eslint-plugin-jsdoc": "^50.6.6",
+    "eslint-plugin-jsdoc": "^50.6.8",
     "eslint-plugin-tsdoc": "^0.4.0",
     "globals": "^16.0.0",
     "jsdoc": "^4.0.4",
@@ -43,15 +43,15 @@
     "typescript": "~5.8.2",
     "typescript-eslint": "^8.26.1",
     "vite": "^6.2.2",
-    "vite-node": "^3.0.8",
+    "vite-node": "^3.0.9",
     "vite-plugin-dts": "^4.5.3",
     "vite-tsconfig-paths": "^5.1.4",
-    "vitest": "^3.0.8",
+    "vitest": "^3.0.9",
     "vitest-dom": "^0.1.1"
   },
   "dependencies": {
-    "@rljson/hash": "^0.0.11",
-    "@rljson/json": "^0.0.13"
+    "@rljson/hash": "^0.0.12",
+    "@rljson/json": "^0.0.15"
   },
   "pnpm": {
     "onlyBuiltDependencies": [