@rljson/rljson 0.0.70 → 0.0.72

package/dist/content/cake.d.ts

@@ -1,6 +1,6 @@
 import { Json } from '@rljson/json';
 import { RljsonTable } from '../rljson.ts';
-import { TableKey } from '../typedefs.ts';
+import { Ref, SliceId, TableKey } from '../typedefs.ts';
 import { LayerRef } from './layer.ts';
 import { SliceIdsRef } from './slice-ids.ts';
 import { TableCfg } from './table-cfg.ts';
@@ -8,6 +8,15 @@ import { TableCfg } from './table-cfg.ts';
  * A `CakeLayerId` assigns an id or name to a cake layer
  */
 export type CakeLayerId = string;
+/**
+ * A reference to a cake
+ *
+ * A cake reference can optionally restrict the slice ids that are used in the cake.
+ */
+export interface CakeReference extends Json {
+    ref: Ref;
+    sliceIds?: SliceId[];
+}
 /**
  * A cake is a collection of layers.
  *

package/dist/content/slice-ids.d.ts

@@ -1,6 +1,7 @@
 import { Json } from '@rljson/json';
 import { RljsonTable } from '../rljson.ts';
 import { Ref, SliceId } from '../typedefs.ts';
+import { TableCfg } from './table-cfg.ts';
 /**
  * An SliceIdsRef is a hash pointing to an Ids
  */
@@ -30,3 +31,9 @@ export type SliceIdsTable = RljsonTable<SliceIds, 'sliceIds'>;
  * Returns one of the layers of the example cake
  */
 export declare const exampleSliceIdsTable: () => SliceIdsTable;
+/**
+ * Creates a table configuration for slice ids table
+ * @param tableKey - the table key
+ * @returns the table configuration
+ */
+export declare const createSliceIdsTableCfg: (tableKey: string) => TableCfg;

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

@@ -29,6 +29,7 @@ export interface ColumnCfg extends Json {
      * Defines if the column is reference column to another table (foreign key)
      */
     ref?: {
+        type: ContentType;
         tableKey: TableKey;
         columnKey?: ColumnKey;
     };

package/dist/example/bakery-example.d.ts

@@ -4,7 +4,7 @@ import { CakesTable } from '../content/cake.ts';
 import { ComponentsTable } from '../content/components.ts';
 import { LayersTable } from '../content/layer.ts';
 import { SliceIdsTable } from '../content/slice-ids.ts';
-import { InsertHistory } from '../insertHistory/insertHistory.ts';
+import { InsertHistoryTable } from '../insertHistory/insertHistory.ts';
 import { Rljson } from '../rljson.ts';
 import { Ref } from '../typedefs.ts';
 export interface Ingredient extends Json {
@@ -32,6 +32,6 @@ export interface Bakery extends Rljson {
     recipeIngredients: ComponentsTable<RecipIngredient>;
     ingredients: ComponentsTable<Ingredient>;
     nutritionalValues: ComponentsTable<NutritionalValues>;
-    ingredientsInsertHistory: InsertHistory<'Ingredients'>;
+    ingredientsInsertHistory: InsertHistoryTable<'Ingredients'>;
 }
 export declare const bakeryExample: () => Bakery;

package/dist/index.d.ts

@@ -5,6 +5,9 @@ export * from './content/layer.ts';
 export * from './content/revision.ts';
 export * from './content/slice-ids.ts';
 export * from './content/table-cfg.ts';
+export * from './edit/edit-history.ts';
+export * from './edit/edit.ts';
+export * from './edit/multi-edit.ts';
 export * from './example.ts';
 export * from './example/bakery-example.ts';
 export * from './insert/insert-validator.ts';

package/dist/insertHistory/insertHistory.d.ts

@@ -11,7 +11,7 @@ export type InsertHistoryRow<Str extends string> = {
     origin?: Ref;
     previous?: InsertHistoryTimeId[];
 };
-export type InsertHistory<Str extends string> = RljsonTable<InsertHistoryRow<Str>, 'insertHistory'>;
+export type InsertHistoryTable<Str extends string> = RljsonTable<InsertHistoryRow<Str>, 'insertHistory'>;
 /**
  * Creates a TableCfg for a InsertHistory table for the given table configuration
  * @param tableCfg - The table configuration to create the InsertHistory table for
@@ -21,4 +21,4 @@ export declare const createInsertHistoryTableCfg: (tableCfg: TableCfg) => TableC
 /**
  * Provides an example insertHistory table for test purposes
  */
-export declare const exampleInsertHistoryTable: () => InsertHistory<any>;
+export declare const exampleInsertHistoryTable: () => InsertHistoryTable<any>;

package/dist/rljson.d.ts

@@ -6,16 +6,17 @@ import { LayersTable } from './content/layer.ts';
 import { RevisionsTable } from './content/revision.ts';
 import { SliceIdsTable } from './content/slice-ids.ts';
 import { TableCfgRef, TablesCfgTable } from './content/table-cfg.ts';
+import { EditHistoryTable } from './edit/edit-history.ts';
 import { EditsTable } from './edit/edit.ts';
 import { MultiEditsTable } from './edit/multi-edit.ts';
-import { InsertHistory } from './insertHistory/insertHistory.ts';
+import { InsertHistoryTable } from './insertHistory/insertHistory.ts';
 import { ContentType, Ref, TableKey } from './typedefs.ts';
 export declare const reservedFieldNames: string[];
 export declare const reservedTableKeys: string[];
 /**
  * One of the supported Rljson table types
  */
-export type TableType = BuffetsTable | ComponentsTable<any> | LayersTable | SliceIdsTable | CakesTable | RevisionsTable | TablesCfgTable | InsertHistory<any> | EditsTable | MultiEditsTable;
+export type TableType = BuffetsTable | ComponentsTable<any> | LayersTable | SliceIdsTable | CakesTable | RevisionsTable | TablesCfgTable | InsertHistoryTable<any> | EditsTable | MultiEditsTable | EditHistoryTable;
 /** The rljson data format */
 export interface Rljson extends Json {
     [tableId: TableKey]: TableType;

package/dist/rljson.js

@@ -1,6 +1,9 @@
 import { hip, hsh } from "@rljson/hash";
 import { exampleJsonObject, jsonValueTypes, jsonValueMatchesType, jsonValueType } from "@rljson/json";
 import { nanoid } from "nanoid";
+const routeRefSeperator = "@";
+const routeSliceIdIndicators = ["(", ")"];
+const routeSliceIdSeperator = ",";
 class Route {
   constructor(_segments) {
     this._segments = _segments;
@@ -16,12 +19,20 @@ class Route {
     const segmentsFlat = route.split("/").filter((s) => s.length > 0);
     const segments = [];
     for (const segmentFlat of segmentsFlat) {
-      const [tableKey, refFlat] = segmentFlat.split("@");
+      const [tableKeyAndSliceId, refFlat] = segmentFlat.split(routeRefSeperator);
+      const sliceIds = tableKeyAndSliceId.substring(
+        tableKeyAndSliceId.indexOf(routeSliceIdIndicators[0]) + 1,
+        tableKeyAndSliceId.indexOf(routeSliceIdIndicators[1])
+      ).split(routeSliceIdSeperator).filter((s) => s.length > 0);
+      const tableKey = tableKeyAndSliceId.split(routeSliceIdIndicators[0])[0];
       const ref = !!refFlat ? refFlat.split(":").length == 2 ? { [tableKey + "InsertHistoryRef"]: refFlat } : { [tableKey + "Ref"]: refFlat } : {};
       const segment = {
         tableKey,
         ...ref
       };
+      if (sliceIds.length > 0) {
+        segment.sliceIds = sliceIds;
+      }
       segments.push(segment);
     }
     return new Route(segments);
@@ -46,8 +57,9 @@ class Route {
    * @returns A new Route that is one level deeper or 'steps' levels deeper
    */
   deeper(steps) {
+    let deeperRoute;
     if (steps === void 0) {
-      return new Route(this._segments.slice(1, this._segments.length));
+      deeperRoute = new Route(this._segments.slice(1, this._segments.length));
     } else {
       if (steps < 1) {
         throw new Error("Steps must be greater than 0");
@@ -55,8 +67,14 @@ class Route {
       if (steps >= this._segments.length) {
         throw new Error("Cannot go deeper than the root");
       }
-      return new Route(this._segments.slice(steps, this._segments.length));
+      deeperRoute = new Route(
+        this._segments.slice(steps, this._segments.length)
+      );
+    }
+    if (!!this.propertyKey) {
+      deeperRoute.propertyKey = this.propertyKey;
     }
+    return deeperRoute;
   }
   // .............................................................................
   /**
@@ -159,8 +177,13 @@ class Route {
     let flat = "";
     for (const segment of this._segments) {
       const tableKey = segment.tableKey;
-      const ref = Object.keys(segment).filter((k) => k !== "tableKey")[0];
-      flat += `/${tableKey}${ref ? `@${segment[ref]}` : ""}`;
+      const tableKeyAndSliceId = segment.sliceIds ? `${tableKey}${routeSliceIdIndicators[0]}${segment.sliceIds.join(
+        routeSliceIdSeperator
+      )}${routeSliceIdIndicators[1]}` : tableKey;
+      const ref = Object.keys(segment).filter(
+        (k) => ["tableKey", "sliceIds"].indexOf(k) === -1
+      )[0];
+      flat += `/${tableKeyAndSliceId}${ref ? `${routeRefSeperator}${segment[ref]}` : ""}`;
     }
     return flat;
   }
@@ -544,6 +567,34 @@ const exampleRevision = () => ({
   timestamp: 1743558427
 });
 const exampleSliceIdsTable = () => bakeryExample().slices;
+const createSliceIdsTableCfg = (tableKey) => ({
+  key: tableKey,
+  type: "sliceIds",
+  columns: [
+    { key: "_hash", type: "string", titleLong: "Hash", titleShort: "Hash" },
+    {
+      key: "base",
+      type: "string",
+      titleLong: "Base SliceId",
+      titleShort: "Base SliceId"
+    },
+    {
+      key: "add",
+      type: "jsonArray",
+      titleLong: "Added SliceIds",
+      titleShort: "Add"
+    },
+    {
+      key: "remove",
+      type: "jsonArray",
+      titleLong: "Removed SliceIds",
+      titleShort: "Remove"
+    }
+  ],
+  isHead: false,
+  isRoot: false,
+  isShared: true
+});
 class Example {
   static ok = {
     bakery: () => bakeryExample(),
@@ -1436,6 +1487,99 @@ const exampleTableCfg = (tableCfg = void 0) => {
     isShared: false
   };
 };
+const createEditHistoryTableCfg = (cakeKey) => ({
+  key: `${cakeKey}EditHistory`,
+  type: "editHistory",
+  columns: [
+    {
+      key: "_hash",
+      type: "string",
+      titleLong: "Hash",
+      titleShort: "Hash"
+    },
+    {
+      key: "timeId",
+      type: "string",
+      titleLong: "Time Identifier",
+      titleShort: "Time ID"
+    },
+    {
+      key: "multiEditRef",
+      type: "string",
+      titleLong: "Multi Edit Reference",
+      titleShort: "Multi Edit Ref",
+      ref: {
+        tableKey: `${cakeKey}MultiEdit`
+      }
+    },
+    {
+      key: "dataRef",
+      type: "string",
+      titleLong: "Data Reference",
+      titleShort: "Data Ref",
+      ref: {
+        tableKey: cakeKey
+      }
+    },
+    {
+      key: "previous",
+      type: "jsonArray",
+      titleLong: "Previous Values",
+      titleShort: "Previous"
+    }
+  ]
+});
+const createEditTableCfg = (cakeKey) => ({
+  key: `${cakeKey}Edits`,
+  type: "edits",
+  columns: [
+    {
+      key: "_hash",
+      type: "string",
+      titleLong: "Hash",
+      titleShort: "Hash"
+    },
+    {
+      key: "name",
+      type: "string",
+      titleLong: "Name of the Edit",
+      titleShort: "Name"
+    },
+    {
+      key: "action",
+      type: "json",
+      titleLong: "Edit Action Data",
+      titleShort: "Action"
+    }
+  ]
+});
+const createMultiEditTableCfg = (cakeKey) => ({
+  key: `${cakeKey}MultiEdits`,
+  type: "multiEdits",
+  columns: [
+    {
+      key: "_hash",
+      type: "string",
+      titleLong: "Hash",
+      titleShort: "Hash"
+    },
+    {
+      key: "previous",
+      type: "string",
+      titleLong: "Previous Value",
+      titleShort: "Previous"
+    },
+    {
+      key: "edit",
+      type: "string",
+      titleLong: "Edit Reference",
+      titleShort: "Edit Ref",
+      ref: {
+        tableKey: `${cakeKey}Edits`
+      }
+    }
+  ]
+});
 const objectDepth = (o) => Object(o) === o ? 1 + Math.max(-1, ...Object.values(o).map(objectDepth)) : 0;
 class InsertValidator {
   constructor(_insert) {
@@ -2517,8 +2661,12 @@ export {
   bakeryExample,
   contentTypes,
   createCakeTableCfg,
+  createEditHistoryTableCfg,
+  createEditTableCfg,
   createInsertHistoryTableCfg,
   createLayerTableCfg,
+  createMultiEditTableCfg,
+  createSliceIdsTableCfg,
   exampleBuffetsTable,
   exampleCakesTable,
   exampleComponentsTable,
@@ -2540,6 +2688,9 @@ export {
   removeDuplicates,
   reservedFieldNames,
   reservedTableKeys,
+  routeRefSeperator,
+  routeSliceIdIndicators,
+  routeSliceIdSeperator,
   throwOnInvalidTableCfg,
   timeId,
   validateInsert,

package/dist/route/route.d.ts

@@ -1,10 +1,14 @@
-import { TableKey } from '../typedefs.ts';
+import { SliceId, TableKey } from '../typedefs.ts';
 export type RouteRef = string;
 export type RouteSegment<Str extends string> = {
     [key in Str as `${Uncapitalize<string & key>}Ref`]: string;
 } & {
     tableKey: TableKey;
+    sliceIds?: SliceId[];
 };
+export declare const routeRefSeperator = "@";
+export declare const routeSliceIdIndicators: readonly ["(", ")"];
+export declare const routeSliceIdSeperator: ",";
 export type RouteSegmentFlat<N extends string> = `${N}` | `${N}@${string}` | `${N}@${string}:${string}`;
 /**
  * A class to handle routes in an Rljson object.

package/package.json

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