@rljson/rljson 0.0.14 → 0.0.15

package/dist/example.d.ts

@@ -10,16 +10,21 @@ export declare class Example {
         complete: () => Rljson;
     };
     static readonly broken: {
-        brokenTableName: () => {
-            brok$en: {
-                _type: string;
-                _data: never[];
+        base: {
+            brokenTableName: () => {
+                brok$en: {
+                    _type: string;
+                    _data: never[];
+                };
             };
+            missingData: () => Rljson;
+            dataNotBeingAnArray: () => Rljson;
+            missingRef: () => Rljson;
+            missingReferencedTable: () => Rljson;
+        };
+        tableCfg: {
+            wrongType: () => import('@rljson/hash').Hashed<Rljson>;
         };
-        missingData: () => Rljson;
-        dataNotBeingAnArray: () => Rljson;
-        missingRef: () => Rljson;
-        missingReferencedTable: () => Rljson;
         collections: {
             missingBase: () => Rljson;
             missingIdSet: () => Rljson;

package/dist/rljson.d.ts

@@ -4,6 +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 { TableCfgRef, TablesCfgTable } from './content/table-cfg.ts';
 import { ContentType, Ref, TableName } from './typedefs.ts';
 export declare const reservedFieldNames: string[];
 export declare const reservedTableNames: string[];
@@ -19,15 +20,26 @@ export interface Rljson extends Json {
  * Rljson set with private fields
  */
 export type RljsonPrivate = {
+    /**
+     * The hash of the Rljson object
+     */
+    _hash: string;
     /**
      * Contains id sets used accross the Rljson object
      */
-    _idSets: IdSetsTable;
+    _idSet?: IdSetsTable;
+    /**
+     * References that are not part of the Rljson object
+     */
+    _externalRefs?: Ref[];
+    /**
+     * Referenced tables that are not part of the Rljson object
+     */
+    _externalTables?: Ref[];
     /**
-     * Used by validation. If external references are not present,
-     * validation does not throw an error.
+     * Column configurations used accross the Rljson object
      */
-    _externalRefs: Ref[];
+    _tableCfgs?: TablesCfgTable;
 };
 /** An example rljson object */
 export declare const exampleRljson: () => Rljson;
@@ -37,6 +49,8 @@ export interface RljsonTable<Data extends Json, Type extends ContentType> extend
     _data: Data[];
     /**  The type of the table. If not set, the type is "properties" */
     _type: Type;
+    /** The columns configuration of the table */
+    _tableCfg?: TableCfgRef;
 }
 /**
  * Iterates over all tables of an Rljson object.

package/dist/rljson.js

@@ -5,96 +5,89 @@ import { hip, hsh } from "@rljson/hash";
 import { exampleJsonObject } from "@rljson/json";
 // @license
 const bakeryExample = () => {
-  return {
-    // Every rljson object has a list of id-sets other objects can refer to
+  const result = {
     _idSets: {
       _type: "idSets",
       _data: [
         {
           add: ["slice0", "slice1"],
-          _hash: "KAwCRFD4mdx8b1bzxBb2_O"
+          _hash: "Ko990SJfgPJvNGxC63CRf7"
         }
-      ]
+      ],
+      _hash: "NiojsJvZ7iEU7WeMWttzyJ"
     },
-    // A bakery offers a variety of buffets containing different pastries
     buffets: {
       _type: "buffets",
       _data: [
         {
-          items: [{ table: "cakes", ref: "fw8IrV05Z1ZekPXTdUdmt8" }]
+          items: [
+            {
+              table: "cakes",
+              ref: "KdLv3zTftqKKUeqYrTtO2r"
+            }
+          ]
         }
       ]
     },
-    // 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",
+          idSet: "Ko990SJfgPJvNGxC63CRf7",
           collections: "layers",
           layers: {
-            _hash: "50ZHxZ8KeUYJ3NC7ax5CbR"
+            _hash: "RBNvo1WzZ4oRRq0W9-hknp"
           },
-          _hash: "gMqFPTkYU66L32jDYZiZ79"
+          _hash: "KdLv3zTftqKKUeqYrTtO2r"
         }
-      ],
-      _hash: "fw8IrV05Z1ZekPXTdUdmt8"
+      ]
     },
-    // Cakes are cut into slices. The cake layers are shared among the slices.
     slices: {
       _type: "idSets",
       _data: [
         {
           add: ["slice0", "slice1"],
-          remove: []
+          remove: [],
+          _hash: "wyYfK5E4ArrMKQ_zvi2-EE"
         }
-      ]
+      ],
+      _hash: "Qt6FzyzwHdEdYC3fKUXaAm"
     },
-    // 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"
-          },
-          _hash: "IIg0e-6Qr73s7sNZe0RhKs"
+            slice0: "uRTo_Jmt9lOA09e2QnwB9W",
+            slice1: "uRTo_Jmt9lOA09e2QnwB9W"
+          }
         }
-      ],
-      _hash: "e3utfEf_VS1-ljAMgqesua"
+      ]
     },
-    // Recipes are sets of ingredients
     recipes: {
       _type: "collections",
       _data: [
         {
           properties: "recipeIngredients",
           assign: {
-            flour: "mqLl7Q44V1t2MotJvaVRM_",
-            _hash: "UImWlyWZTSGhNAMC1JUzF1"
+            flour: "RCA4yzQe6mYOqquoLijKop"
           },
-          _hash: "G1YV_P8-_vTxtkXXHJeNBI"
+          _hash: "uRTo_Jmt9lOA09e2QnwB9W"
         }
-      ],
-      _hash: "r3lw7VsnywyasRmtynZqIt"
+      ]
     },
-    // A recipe ingredient combines an ingredient type with a quantity
     recipeIngredients: {
       _type: "properties",
       _data: [
         {
-          ingredientTypesRef: "WOfnFT1svec3iJ6x",
+          ingredientsRef: "CdSJV-WOfnFT1svec3iJ6x",
           quantity: 500,
-          _hash: "mqLl7Q44V1t2MotJvaVRM_"
+          _hash: "RCA4yzQe6mYOqquoLijKop"
         }
       ],
-      _hash: "J7GJEjCRXLNfdAHARg_fzx"
+      _hash: "R6dJq4ZJ3QDa9Bz8QJDhNq"
     },
-    // A table describing basic properties of ingredients
     ingredients: {
       _type: "properties",
       _data: [
@@ -107,7 +100,6 @@ const bakeryExample = () => {
       ],
       _hash: "FgJeTM0NcZvXwFcU-PD8Jf"
     },
-    // A table with nutritive values of ingredients
     nutritiveValues: {
       _type: "properties",
       _data: [
@@ -122,6 +114,7 @@ const bakeryExample = () => {
       _hash: "7k4OqQtk71w3yVGMoA9F6p"
     }
   };
+  return result;
 };
 // @license
 const exampleBuffetsTable = () => bakeryExample().buffets;
@@ -155,12 +148,77 @@ __publicField(_Example, "ok", {
     };
   },
   singleRow: () => {
-    return {
+    const tableCfgs = {
+      _hash: "",
+      _type: "properties",
+      _data: [
+        {
+          _hash: "R-rCQ4YwYYJAp6uAo6S_6n",
+          name: "Single Row Table",
+          jsonKey: "table",
+          columns: {
+            int: {
+              jsonKey: "int",
+              type: "number",
+              name: "Integer",
+              nameShort: "Int"
+            },
+            double: {
+              jsonKey: "double",
+              type: "number",
+              name: "Double",
+              nameShort: "Dbl"
+            },
+            string: {
+              jsonKey: "string",
+              type: "string",
+              name: "String",
+              nameShort: "Str"
+            },
+            boolean: {
+              jsonKey: "boolean",
+              type: "boolean",
+              name: "Boolean",
+              nameShort: "Bool"
+            },
+            null: {
+              jsonKey: "null",
+              type: "null",
+              name: "null",
+              nameShort: "null"
+            },
+            jsonArray: {
+              jsonKey: "jsonArray",
+              type: "jsonArray",
+              name: "Json Array",
+              nameShort: "Jarray"
+            },
+            json: {
+              jsonKey: "json",
+              type: "json",
+              name: "Json",
+              nameShort: "Json"
+            },
+            jsonValue: {
+              jsonKey: "jsonValue",
+              type: "jsonValue",
+              name: "Json Value",
+              nameShort: "Jval"
+            }
+          }
+        }
+      ]
+    };
+    const result = {
+      _tableCfgs: tableCfgs,
       table: {
         _type: "properties",
-        _data: [exampleJsonObject()]
+        _tableCfg: "R-rCQ4YwYYJAp6uAo6S_6n",
+        _data: [exampleJsonObject()],
+        _hash: ""
       }
     };
+    return result;
   },
   multipleRows: () => {
     return {
@@ -289,65 +347,75 @@ __publicField(_Example, "ok", {
   }
 });
 __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
-          }
-        ]
-      }
-    };
+  base: {
+    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
+            }
+          ]
+        }
+      };
+    }
   },
-  missingReferencedTable: () => {
-    return {
-      tableB: {
-        _type: "properties",
-        _data: [
-          {
-            tableARef: "MISSINGREF"
-            // tableA is missing
-          }
-        ]
-      }
-    };
+  tableCfg: {
+    wrongType: () => {
+      const result = _Example.ok.singleRow();
+      const tableCfg = result._tableCfgs._data[0];
+      tableCfg.columns["int"].type = "numberBroken";
+      return hip(result, true, false);
+    }
   },
   collections: {
     missingBase: () => {

package/dist/src/example.ts

@@ -7,6 +7,7 @@
 import { hip } from '@rljson/hash';
 import { exampleJsonObject } from '@rljson/json';
 
+import { TablesCfgTable } from './content/table-cfg.ts';
 import { bakeryExample } from './example/bakery-example.ts';
 import { Rljson } from './rljson.ts';
 
@@ -33,12 +34,78 @@ export class Example {
     },
 
     singleRow: (): Rljson => {
-      return {
+      const tableCfgs: TablesCfgTable = {
+        _hash: '',
+        _type: 'properties',
+        _data: [
+          {
+            _hash: 'R-rCQ4YwYYJAp6uAo6S_6n',
+            name: 'Single Row Table',
+            jsonKey: 'table',
+            columns: {
+              int: {
+                jsonKey: 'int',
+                type: 'number',
+                name: 'Integer',
+                nameShort: 'Int',
+              },
+              double: {
+                jsonKey: 'double',
+                type: 'number',
+                name: 'Double',
+                nameShort: 'Dbl',
+              },
+              string: {
+                jsonKey: 'string',
+                type: 'string',
+                name: 'String',
+                nameShort: 'Str',
+              },
+              boolean: {
+                jsonKey: 'boolean',
+                type: 'boolean',
+                name: 'Boolean',
+                nameShort: 'Bool',
+              },
+              null: {
+                jsonKey: 'null',
+                type: 'null',
+                name: 'null',
+                nameShort: 'null',
+              },
+              jsonArray: {
+                jsonKey: 'jsonArray',
+                type: 'jsonArray',
+                name: 'Json Array',
+                nameShort: 'Jarray',
+              },
+              json: {
+                jsonKey: 'json',
+                type: 'json',
+                name: 'Json',
+                nameShort: 'Json',
+              },
+              jsonValue: {
+                jsonKey: 'jsonValue',
+                type: 'jsonValue',
+                name: 'Json Value',
+                nameShort: 'Jval',
+              },
+            },
+          },
+        ],
+      };
+
+      const result: Rljson = {
+        _tableCfgs: tableCfgs,
         table: {
           _type: 'properties',
+          _tableCfg: 'R-rCQ4YwYYJAp6uAo6S_6n',
           _data: [exampleJsonObject()],
+          _hash: '',
         },
       };
+      return result as Rljson;
     },
 
     multipleRows: (): Rljson => {
@@ -177,67 +244,78 @@ export class Example {
   };
 
   static readonly broken = {
-    brokenTableName: () => {
-      return {
-        brok$en: {
-          _type: 'properties',
-          _data: [],
-        },
-      };
-    },
+    base: {
+      brokenTableName: () => {
+        return {
+          brok$en: {
+            _type: 'properties',
+            _data: [],
+          },
+        };
+      },
 
-    missingData: () => {
-      return {
-        table: {
-          _type: 'properties',
-        },
-      } as unknown as Rljson;
-    },
+      missingData: () => {
+        return {
+          table: {
+            _type: 'properties',
+          },
+        } as unknown as Rljson;
+      },
 
-    dataNotBeingAnArray: () => {
-      return {
-        table: {
-          _type: 'properties',
-          _data: {},
-        },
-      } 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
-            },
-          ],
-        },
-      };
+      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
+              },
+            ],
+          },
+        };
+      },
     },
 
-    missingReferencedTable: (): Rljson => {
-      return {
-        tableB: {
-          _type: 'properties',
-          _data: [
-            {
-              tableARef: 'MISSINGREF', // tableA is missing
-            },
-          ],
-        },
-      };
+    tableCfg: {
+      wrongType: () => {
+        const result = Example.ok.singleRow();
+        const tableCfg = result._tableCfgs._data[0];
+        tableCfg.columns['int'].type = 'numberBroken'; // Break one of the types
+        return hip(result, true, false);
+      },
     },
 
     collections: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rljson/rljson",
-  "version": "0.0.14",
+  "version": "0.0.15",
   "packageManager": "pnpm@10.6.3",
   "description": "The RLJSON data format specification",
   "homepage": "https://github.com/rljson/rljson",
@@ -51,7 +51,7 @@
   },
   "dependencies": {
     "@rljson/hash": "^0.0.12",
-    "@rljson/json": "^0.0.15"
+    "@rljson/json": "^0.0.18"
   },
   "pnpm": {
     "onlyBuiltDependencies": [