@rljson/rljson 0.0.31 → 0.0.32

package/dist/rljson.js

@@ -6,7 +6,7 @@ import { exampleJsonObject, jsonValueTypes, jsonValueMatchesType } from "@rljson
 // @license
 const bakeryExample = () => {
   const nutritionalValues = hip({
-    _type: "properties",
+    _type: "ingredients",
     _data: [
       {
         energy: 364,
@@ -19,7 +19,7 @@ const bakeryExample = () => {
     _hash: ""
   });
   const ingredients = hip({
-    _type: "properties",
+    _type: "ingredients",
     _data: [
       {
         name: "flour",
@@ -31,7 +31,7 @@ const bakeryExample = () => {
     _hash: ""
   });
   const recipeIngredients = hip({
-    _type: "properties",
+    _type: "ingredients",
     _data: [
       {
         ingredientsRef: ingredients._data[0]._hash,
@@ -42,10 +42,10 @@ const bakeryExample = () => {
     _hash: ""
   });
   const recipes = hip({
-    _type: "collections",
+    _type: "layers",
     _data: [
       {
-        propertiesTable: "recipeIngredients",
+        ingredientsTable: "recipeIngredients",
         assign: {
           flour: recipeIngredients._data[0]._hash
         },
@@ -54,10 +54,10 @@ const bakeryExample = () => {
     ]
   });
   const layers = hip({
-    _type: "collections",
+    _type: "layers",
     _data: [
       {
-        propertiesTable: "recipes",
+        ingredientsTable: "recipes",
         assign: {
           slice0: recipes._data[0]._hash,
           slice1: recipes._data[0]._hash
@@ -66,7 +66,7 @@ const bakeryExample = () => {
     ]
   });
   const slices = hip({
-    _type: "idSets",
+    _type: "sliceIds",
     _data: [
       {
         add: ["slice0", "slice1"],
@@ -80,9 +80,9 @@ const bakeryExample = () => {
     _type: "cakes",
     _data: [
       {
-        idSetsTable: "slices",
+        sliceIdsTable: "slices",
         idSet: slices._data[0]._hash,
-        collectionsTable: "layers",
+        layersTable: "layers",
         layers: {
           flour: layers._data[0]._hash
         },
@@ -120,11 +120,11 @@ const exampleBuffetsTable = () => bakeryExample().buffets;
 // @license
 const exampleCakesTable = () => bakeryExample().cakes;
 // @license
-const exampleCollectionsTable = () => bakeryExample().layers;
+const exampleIngredientsTable = () => bakeryExample().nutritionalValues;
 // @license
-const exampleIdSetsTable = () => bakeryExample().slices;
+const exampleLayersTable = () => bakeryExample().layers;
 // @license
-const examplePropertiesTable = () => bakeryExample().nutritionalValues;
+const exampleSliceIdsTable = () => bakeryExample().slices;
 // @license
 const _Example = class _Example {
 };
@@ -136,7 +136,7 @@ __publicField(_Example, "ok", {
   binary: () => {
     return {
       table: {
-        _type: "properties",
+        _type: "ingredients",
         _data: [
           { a: false, b: false },
           { a: false, b: true },
@@ -149,13 +149,13 @@ __publicField(_Example, "ok", {
   singleRow: () => {
     const tableCfgs = hip({
       _hash: "",
-      _type: "properties",
+      _type: "ingredients",
       _data: [
         {
           version: 0,
           _hash: "",
           key: "table",
-          type: "properties",
+          type: "ingredients",
           columns: {
             int: {
               key: "int",
@@ -196,7 +196,7 @@ __publicField(_Example, "ok", {
     const result = {
       tableCfgs,
       table: {
-        _type: "properties",
+        _type: "ingredients",
         _tableCfg: tableCfgs._data[0]._hash,
         _data: [exampleJsonObject()],
         _hash: ""
@@ -207,7 +207,7 @@ __publicField(_Example, "ok", {
   multipleRows: () => {
     return {
       table: {
-        _type: "properties",
+        _type: "ingredients",
         _data: [
           {
             string: "str0",
@@ -237,7 +237,7 @@ __publicField(_Example, "ok", {
   singleRef: () => {
     return {
       tableA: {
-        _type: "properties",
+        _type: "ingredients",
         _data: [
           {
             keyA0: "a0"
@@ -248,7 +248,7 @@ __publicField(_Example, "ok", {
         ]
       },
       tableB: {
-        _type: "properties",
+        _type: "ingredients",
         _data: [
           {
             tableARef: "KFQrf4mEz0UPmUaFHwH4T6"
@@ -258,47 +258,47 @@ __publicField(_Example, "ok", {
     };
   },
   complete: () => {
-    const idSets = hip({
-      _type: "idSets",
+    const sliceIds = hip({
+      _type: "sliceIds",
       _data: [
         {
           add: ["id0", "id1"]
         }
       ]
     });
-    const properties = hip({
-      _type: "properties",
+    const ingredients = hip({
+      _type: "ingredients",
       _data: [{ a: "0" }, { a: "1" }]
     });
-    const property0 = properties._data[0];
-    const property1 = properties._data[1];
-    const collection0 = hip({
-      idSetsTable: "idSets",
+    const ingredient0 = ingredients._data[0];
+    const ingredient1 = ingredients._data[1];
+    const layer0 = hip({
+      sliceIdsTable: "sliceIds",
       idSet: "MgHRBYSrhpyl4rvsOmAWcQ",
-      propertiesTable: "properties",
+      ingredientsTable: "ingredients",
       assign: {}
     });
-    const collection1 = hip({
-      base: collection0._hash,
-      idSetsTable: "idSets",
+    const layer1 = hip({
+      base: layer0._hash,
+      sliceIdsTable: "sliceIds",
       idSet: "MgHRBYSrhpyl4rvsOmAWcQ",
-      propertiesTable: "properties",
+      ingredientsTable: "ingredients",
       assign: {
-        id0: property0._hash,
-        id1: property1._hash
+        id0: ingredient0._hash,
+        id1: ingredient1._hash
       }
     });
-    const collections = hip({
-      _type: "collections",
-      _data: [collection0, collection1]
+    const layers = hip({
+      _type: "layers",
+      _data: [layer0, layer1]
     });
     const cake = hip({
-      idSetsTable: "idSets",
-      idSet: idSets._data[0]._hash,
-      collectionsTable: "collections",
+      sliceIdsTable: "sliceIds",
+      idSet: sliceIds._data[0]._hash,
+      layersTable: "layers",
       layers: {
-        layer0: collection0._hash,
-        layer1: collection1._hash
+        layer0: layer0._hash,
+        layer1: layer1._hash
       }
     });
     const cakes = hip({
@@ -315,17 +315,17 @@ __publicField(_Example, "ok", {
               ref: cakes._data[0]._hash
             },
             {
-              table: "collections",
-              ref: collection0._hash
+              table: "layers",
+              ref: layer0._hash
             }
           ]
         }
       ]
     });
     return {
-      idSets,
-      properties,
-      collections,
+      sliceIds,
+      ingredients,
+      layers,
       cakes,
       buffets
     };
@@ -336,7 +336,7 @@ __publicField(_Example, "broken", {
     brokenTableKey: () => {
       return {
         brok$en: {
-          _type: "properties",
+          _type: "ingredients",
           _data: []
         }
       };
@@ -344,14 +344,14 @@ __publicField(_Example, "broken", {
     missingData: () => {
       return {
         table: {
-          _type: "properties"
+          _type: "ingredients"
         }
       };
     },
     dataNotBeingAnArray: () => {
       return {
         table: {
-          _type: "properties",
+          _type: "ingredients",
           _data: {}
         }
       };
@@ -359,7 +359,7 @@ __publicField(_Example, "broken", {
     missingRef: () => {
       return {
         tableA: {
-          _type: "properties",
+          _type: "ingredients",
           _data: [
             {
               keyA0: "a0"
@@ -370,7 +370,7 @@ __publicField(_Example, "broken", {
           ]
         },
         tableB: {
-          _type: "properties",
+          _type: "ingredients",
           _data: [
             {
               tableARef: "MISSINGREF"
@@ -383,7 +383,7 @@ __publicField(_Example, "broken", {
     missingReferencedTable: () => {
       return {
         tableB: {
-          _type: "properties",
+          _type: "ingredients",
           _data: [
             {
               tableARef: "MISSINGREF"
@@ -402,44 +402,44 @@ __publicField(_Example, "broken", {
       return hip(result, true, false);
     }
   },
-  collections: {
+  layers: {
     missingBase: () => {
       const result = _Example.ok.complete();
-      const collection1 = result.collections._data[1];
-      collection1.base = "MISSING";
+      const layer1 = result.layers._data[1];
+      layer1.base = "MISSING";
       return hip(result, true, false);
     },
-    missingIdSet: () => {
+    missingSliceIdSet: () => {
       const result = _Example.ok.complete();
-      const collection1 = result.collections._data[1];
-      collection1.idSet = "MISSING1";
+      const layer1 = result.layers._data[1];
+      layer1.idSet = "MISSING1";
       return hip(result, true, false);
     },
-    missingAssignedPropertyTable: () => {
+    missingAssignedIngredientTable: () => {
       const result = _Example.ok.complete();
-      delete result.properties;
+      delete result.ingredients;
       return result;
     },
-    missingAssignedProperty: () => {
+    missingAssignedIngredient: () => {
       const result = _Example.ok.complete();
-      result.properties._data.splice(1, 2);
+      result.ingredients._data.splice(1, 2);
       return hip(result, true, false);
     }
   },
   cakes: {
-    missingIdSet: () => {
+    missingSliceIdSet: () => {
       const result = _Example.ok.complete();
       result.cakes._data[0].idSet = "MISSING";
       hip(result.cakes, true, false);
       return result;
     },
-    missingCollectionsTable: () => {
+    missingLayersTable: () => {
       const result = _Example.ok.complete();
-      result.cakes._data[0].collectionsTable = "MISSING";
+      result.cakes._data[0].layersTable = "MISSING";
       hip(result.cakes, true, false);
       return result;
     },
-    missingLayerCollection: () => {
+    missingCakeLayer: () => {
       const result = _Example.ok.complete();
       result.cakes._data[0].layers["layer0"] = "MISSING0";
       result.cakes._data[0].layers["layer1"] = "MISSING1";
@@ -483,24 +483,24 @@ const exampleTableCfg = (tableCfg = void 0) => {
         type: "number"
       }
     },
-    type: (tableCfg == null ? void 0 : tableCfg.type) ?? "properties"
+    type: (tableCfg == null ? void 0 : tableCfg.type) ?? "ingredients"
   };
 };
 // @license
 const rljsonIndexed = (rljson) => {
   const result = {};
   for (const key in rljson) {
-    const item = rljson[key];
-    if (typeof item != "object") {
-      result[key] = item;
+    const slice = rljson[key];
+    if (typeof slice != "object") {
+      result[key] = slice;
       continue;
     }
     const dataIndexed = {};
-    result[key] = { ...item };
-    if (!Array.isArray(item._data)) {
+    result[key] = { ...slice };
+    if (!Array.isArray(slice._data)) {
       continue;
     }
-    for (const row of item._data) {
+    for (const row of slice._data) {
       const hashedRow = row._hash ? row : hsh(row);
       const hash = hashedRow._hash;
       dataIndexed[hash] = hashedRow;
@@ -511,7 +511,7 @@ const rljsonIndexed = (rljson) => {
 };
 // @license
 const reservedFieldNames = ["_type", "_data"];
-const reservedTableKeys = ["_hash", "idSets", "tableCfgs"];
+const reservedTableKeys = ["_hash", "sliceIds", "tableCfgs"];
 const exampleRljson = () => Example.ok.singleRow();
 const iterateTables = (rljson, callback) => {
   for (const tableKey in rljson) {
@@ -526,16 +526,16 @@ const iterateTables = (rljson, callback) => {
 const contentTypes = [
   "buffets",
   "cakes",
-  "collections",
-  "idSets",
-  "properties"
+  "layers",
+  "sliceIds",
+  "ingredients"
 ];
 const exampleTypedefs = () => {
   return {
     ref: "ref",
-    itemId: "itemId",
+    sliceId: "sliceId",
     tableKey: "tableKey",
-    contentType: "collections"
+    contentType: "layers"
   };
 };
 // @license
@@ -589,15 +589,15 @@ class _BaseValidator {
       () => this._tableTypesDoNotMatch(),
       // Check references
       () => this._refsNotFound(),
-      // Check collections
-      () => this._collectionBasesNotFound(),
-      () => this._collectionIdSetsTableNotFound(),
-      () => this._collectionIdSetNotFound(),
-      () => this._collectionPropertyAssignmentsNotFound(),
+      // Check layers
+      () => this._layerBasesNotFound(),
+      () => this._layerSliceIdsTableNotFound(),
+      () => this._layerSliceIdsNotFound(),
+      () => this._layerIngredientAssignmentsNotFound(),
       // Check cakes
-      () => this._cakeIdSetsTableNotFound(),
-      () => this._cakeIdSetNotFound(),
-      () => this._cakeCollectionTablesNotFound(),
+      () => this._cakeSliceIdsTableNotFound(),
+      () => this._cakeSliceIdsNotFound(),
+      () => this._cakeLayerTablesNotFound(),
       // Check buffets
       () => this._buffetReferencedTableNotFound()
     ];
@@ -976,147 +976,147 @@ class _BaseValidator {
       };
     }
   }
-  _collectionBasesNotFound() {
-    const brokenCollections = [];
+  _layerBasesNotFound() {
+    const brokenLayers = [];
     iterateTables(this.rljson, (tableKey, table) => {
-      if (table._type !== "collections") {
+      if (table._type !== "layers") {
         return;
       }
-      const collectionsIndexed = this.rljsonIndexed[tableKey];
-      const collectionsTable = table;
-      for (const collection of collectionsTable._data) {
-        const baseRef = collection.base;
+      const layersIndexed = this.rljsonIndexed[tableKey];
+      const layersTable = table;
+      for (const layer of layersTable._data) {
+        const baseRef = layer.base;
         if (!baseRef) {
           continue;
         }
-        const baseCollection = collectionsIndexed._data[baseRef];
-        if (!baseCollection) {
-          brokenCollections.push({
-            collectionsTable: tableKey,
-            brokenCollection: collection._hash,
-            missingBaseCollection: baseRef
+        const baseLayer = layersIndexed._data[baseRef];
+        if (!baseLayer) {
+          brokenLayers.push({
+            layersTable: tableKey,
+            brokenLayer: layer._hash,
+            missingBaseLayer: baseRef
           });
         }
       }
     });
-    if (brokenCollections.length > 0) {
-      this.errors.collectionBasesNotFound = {
-        error: "Base collections are missing",
-        brokenCollections
+    if (brokenLayers.length > 0) {
+      this.errors.layerBasesNotFound = {
+        error: "Base layers are missing",
+        brokenLayers
       };
     }
   }
-  _collectionIdSetsTableNotFound() {
-    const brokenCollections = [];
+  _layerSliceIdsTableNotFound() {
+    const brokenLayers = [];
     iterateTables(this.rljson, (tableKey, table) => {
-      if (table._type !== "collections") {
+      if (table._type !== "layers") {
         return;
       }
-      const collectionsTable = table;
-      for (const collection of collectionsTable._data) {
-        const idSets = collection.idSetsTable;
-        if (!idSets) {
+      const layersTable = table;
+      for (const layer of layersTable._data) {
+        const sliceIds = layer.sliceIdsTable;
+        if (!sliceIds) {
           continue;
         }
-        const idSetsTable = this.rljsonIndexed[idSets];
-        if (!idSetsTable) {
-          brokenCollections.push({
-            collectionsTable: tableKey,
-            collectionHash: collection._hash,
-            missingIdSetsTable: idSets
+        const sliceIdsTable = this.rljsonIndexed[sliceIds];
+        if (!sliceIdsTable) {
+          brokenLayers.push({
+            layersTable: tableKey,
+            layerHash: layer._hash,
+            missingSliceIdsTable: sliceIds
           });
         }
       }
     });
-    if (brokenCollections.length > 0) {
-      this.errors.collectionIdSetsTableNotFound = {
+    if (brokenLayers.length > 0) {
+      this.errors.layerSliceIdsTableNotFound = {
         error: "Id sets tables are missing",
-        brokenCollections
+        brokenLayers
       };
     }
   }
-  _collectionIdSetNotFound() {
-    const brokenCollections = [];
+  _layerSliceIdsNotFound() {
+    const brokenLayers = [];
     iterateTables(this.rljson, (tableKey, table) => {
-      if (table._type !== "collections") {
+      if (table._type !== "layers") {
         return;
       }
-      const collectionsTable = table;
-      for (const collection of collectionsTable._data) {
-        const idSetRef = collection.idSet;
+      const layersTable = table;
+      for (const layer of layersTable._data) {
+        const idSetRef = layer.idSet;
         if (!idSetRef) {
           continue;
         }
-        const idSets = collection.idSetsTable;
-        const idSetsTable = this.rljsonIndexed[idSets];
-        const idSet = idSetsTable._data[idSetRef];
+        const sliceIds = layer.sliceIdsTable;
+        const sliceIdsTable = this.rljsonIndexed[sliceIds];
+        const idSet = sliceIdsTable._data[idSetRef];
         if (!idSet) {
-          brokenCollections.push({
-            collectionsTable: tableKey,
-            collectionHash: collection._hash,
-            missingIdSet: idSetRef
+          brokenLayers.push({
+            layersTable: tableKey,
+            layerHash: layer._hash,
+            missingSliceIds: idSetRef
           });
         }
       }
     });
-    if (brokenCollections.length > 0) {
-      this.errors.collectionIdSetNotFound = {
-        error: "Id sets of collections are missing",
-        brokenCollections
+    if (brokenLayers.length > 0) {
+      this.errors.layerSliceIdsNotFound = {
+        error: "Id sets of layers are missing",
+        brokenLayers
       };
     }
   }
-  _collectionPropertyAssignmentsNotFound() {
-    const missingPropertyTables = [];
+  _layerIngredientAssignmentsNotFound() {
+    const missingIngredientTables = [];
     const brokenAssignments = [];
     iterateTables(this.rljson, (tableKey, table) => {
-      if (table._type !== "collections") {
+      if (table._type !== "layers") {
         return;
       }
-      const collectionsTable = table;
-      for (const collection of collectionsTable._data) {
-        const propertyTableKey = collection.propertiesTable;
-        const propertiesTable = this.rljsonIndexed[propertyTableKey];
-        if (!propertiesTable) {
-          missingPropertyTables.push({
-            brokenCollection: collection._hash,
-            collectionsTable: tableKey,
-            missingPropertyTable: propertyTableKey
+      const layersTable = table;
+      for (const layer of layersTable._data) {
+        const ingredientTableKey = layer.ingredientsTable;
+        const ingredientsTable = this.rljsonIndexed[ingredientTableKey];
+        if (!ingredientsTable) {
+          missingIngredientTables.push({
+            brokenLayer: layer._hash,
+            layersTable: tableKey,
+            missingIngredientTable: ingredientTableKey
           });
           continue;
         }
-        const assignments = collection.assign;
-        for (const itemId in assignments) {
-          if (itemId.startsWith("_")) {
+        const assignments = layer.assign;
+        for (const sliceId in assignments) {
+          if (sliceId.startsWith("_")) {
             continue;
           }
-          const propertyHash = assignments[itemId];
-          if (!propertiesTable._data[propertyHash]) {
+          const ingredientHash = assignments[sliceId];
+          if (!ingredientsTable._data[ingredientHash]) {
             brokenAssignments.push({
-              collectionsTable: tableKey,
-              brokenCollection: collection._hash,
-              referencedPropertyTable: propertyTableKey,
-              brokenAssignment: itemId,
-              missingProperty: propertyHash
+              layersTable: tableKey,
+              brokenLayer: layer._hash,
+              referencedIngredientTable: ingredientTableKey,
+              brokenAssignment: sliceId,
+              missingIngredient: ingredientHash
             });
           }
         }
       }
     });
-    if (missingPropertyTables.length > 0) {
-      this.errors.collectionPropertyTablesNotFound = {
-        error: "Collection property tables do not exist",
-        collections: missingPropertyTables
+    if (missingIngredientTables.length > 0) {
+      this.errors.layerIngredientTablesNotFound = {
+        error: "Layer ingredient tables do not exist",
+        layers: missingIngredientTables
       };
     }
     if (brokenAssignments.length > 0) {
-      this.errors.collectionPropertyAssignmentsNotFound = {
-        error: "Collection property assignments are broken",
+      this.errors.layerIngredientAssignmentsNotFound = {
+        error: "Layer ingredient assignments are broken",
         brokenAssignments
       };
     }
   }
-  _cakeIdSetsTableNotFound() {
+  _cakeSliceIdsTableNotFound() {
     const brokenCakes = [];
     iterateTables(this.rljson, (tableKey, table) => {
       if (table._type !== "cakes") {
@@ -1124,28 +1124,28 @@ class _BaseValidator {
       }
       const cakesTable = table;
       for (const cake of cakesTable._data) {
-        const idSetsRef = cake.idSetsTable;
-        if (!idSetsRef) {
+        const sliceIdsRef = cake.sliceIdsTable;
+        if (!sliceIdsRef) {
           continue;
         }
-        const idSets = this.rljsonIndexed[idSetsRef];
-        if (!idSets) {
+        const sliceIds = this.rljsonIndexed[sliceIdsRef];
+        if (!sliceIds) {
           brokenCakes.push({
             cakeTable: tableKey,
             brokenCake: cake._hash,
-            missingIdSets: idSetsRef
+            missingSliceIds: sliceIdsRef
           });
         }
       }
     });
     if (brokenCakes.length > 0) {
-      this.errors.cakeIdSetsTableNotFound = {
+      this.errors.cakeSliceIdsTableNotFound = {
         error: "Id sets tables referenced by cakes are missing",
         brokenCakes
       };
     }
   }
-  _cakeIdSetNotFound() {
+  _cakeSliceIdsNotFound() {
     const brokenCakes = [];
     iterateTables(this.rljson, (tableKey, table) => {
       if (table._type !== "cakes") {
@@ -1157,72 +1157,72 @@ class _BaseValidator {
         if (!idSetRef) {
           continue;
         }
-        const idSetsRef = cake.idSetsTable;
-        const idSets = this.rljsonIndexed[idSetsRef];
-        const idSet = idSets._data[idSetRef];
+        const sliceIdsRef = cake.sliceIdsTable;
+        const sliceIds = this.rljsonIndexed[sliceIdsRef];
+        const idSet = sliceIds._data[idSetRef];
         if (!idSet) {
           brokenCakes.push({
             cakeTable: tableKey,
             brokenCake: cake._hash,
-            missingIdSet: idSetRef
+            missingSliceIds: idSetRef
           });
         }
       }
     });
     if (brokenCakes.length > 0) {
-      this.errors.cakeIdSetNotFound = {
+      this.errors.cakeSliceIdsNotFound = {
         error: "Id sets of cakes are missing",
         brokenCakes
       };
     }
   }
-  _cakeCollectionTablesNotFound() {
-    const missingCollectionTables = [];
-    const missingLayerCollections = [];
+  _cakeLayerTablesNotFound() {
+    const missingLayerTables = [];
+    const missingCakeLayers = [];
     iterateTables(this.rljson, (tableKey, table) => {
       if (table._type !== "cakes") {
         return;
       }
       const cakesTable = table;
       for (const cake of cakesTable._data) {
-        const collectionsTableKey = cake.collectionsTable;
-        const collectionsTable = this.rljsonIndexed[collectionsTableKey];
-        if (!collectionsTable) {
-          missingCollectionTables.push({
+        const layersTableKey = cake.layersTable;
+        const layersTable = this.rljsonIndexed[layersTableKey];
+        if (!layersTable) {
+          missingLayerTables.push({
             cakeTable: tableKey,
             brokenCake: cake._hash,
-            missingCollectionsTable: collectionsTableKey
+            missingLayersTable: layersTableKey
           });
           continue;
         }
-        for (const layer in cake.layers) {
-          if (layer.startsWith("_")) {
+        for (const layerKey in cake.layers) {
+          if (layerKey.startsWith("_")) {
             continue;
           }
-          const collectionRef = cake.layers[layer];
-          const collection = collectionsTable._data[collectionRef];
-          if (!collection) {
-            missingLayerCollections.push({
+          const layerRef = cake.layers[layerKey];
+          const layer = layersTable._data[layerRef];
+          if (!layer) {
+            missingCakeLayers.push({
               cakeTable: tableKey,
               brokenCake: cake._hash,
-              brokenLayerName: layer,
-              collectionsTable: collectionsTableKey,
-              missingCollection: collectionRef
+              brokenLayerName: layerKey,
+              layersTable: layersTableKey,
+              missingLayer: layerRef
             });
           }
         }
       }
     });
-    if (missingCollectionTables.length > 0) {
-      this.errors.cakeCollectionTablesNotFound = {
-        error: "Collection tables of cakes are missing",
-        brokenCakes: missingCollectionTables
+    if (missingLayerTables.length > 0) {
+      this.errors.cakeLayerTablesNotFound = {
+        error: "Layer tables of cakes are missing",
+        brokenCakes: missingLayerTables
       };
     }
-    if (missingLayerCollections.length > 0) {
-      this.errors.cakeLayerCollectionsNotFound = {
-        error: "Layer collections of cakes are missing",
-        brokenCakes: missingLayerCollections
+    if (missingCakeLayers.length > 0) {
+      this.errors.cakeLayersNotFound = {
+        error: "Layer layers of cakes are missing",
+        brokenCakes: missingCakeLayers
       };
     }
   }
@@ -1319,10 +1319,10 @@ export {
   contentTypes,
   exampleBuffetsTable,
   exampleCakesTable,
-  exampleCollectionsTable,
-  exampleIdSetsTable,
-  examplePropertiesTable,
+  exampleIngredientsTable,
+  exampleLayersTable,
   exampleRljson,
+  exampleSliceIdsTable,
   exampleTableCfg,
   exampleTableCfgTable,
   exampleTypedefs,