@revisium/schema-toolkit 0.21.4 → 0.22.0

package/README.md

@@ -49,7 +49,41 @@ row.getValue('name');           // string (typed!)
 row.setValue('price', 19.99);   // OK
 row.setValue('price', 'wrong'); // TS Error!
 row.getPlainValue();            // { name: string, price: number }
-row.getPatches();               // JSON Patch operations
+row.patches;                    // JSON Patch operations
+row.root;                       // typed root node (InferNode<S>)
+row.reset({ name: 'New', price: 0 }); // reset to new data, commit
+row.reset();                    // reset to schema defaults
+```
+
+### Array Search
+
+Arrays expose `find` and `findIndex` for searching elements by node properties:
+
+```typescript
+import { obj, str, arr, createRowModel } from '@revisium/schema-toolkit';
+
+const schema = obj({
+  sorts: arr(obj({ field: str(), direction: str() })),
+});
+
+const row = createRowModel({
+  rowId: 'row-1',
+  schema,
+  data: { sorts: [
+    { field: 'name', direction: 'asc' },
+    { field: 'age', direction: 'desc' },
+  ]},
+});
+
+const sortsNode = row.get('sorts');
+// find returns the typed node
+const ageSort = sortsNode.find(
+  (node) => node.child('field').getPlainValue() === 'age',
+);
+// findIndex returns the index
+const idx = sortsNode.findIndex(
+  (node) => node.child('field').getPlainValue() === 'age',
+); // 1
 ```
 
 ### TableModel
@@ -215,6 +249,33 @@ See [ForeignKeyResolver docs](src/model/foreign-key-resolver/README.md) for cach
 | `createRowModel(options)` | Create a row model (typed overload when schema is typed) |
 | `createTableModel(options)` | Create a table model (typed overload when schema is typed) |
 
+#### RowModel
+
+| Property / Method | Description |
+|-------------------|-------------|
+| `root` | Typed root node (`InferNode<S>` for typed, `ValueNode` for untyped) |
+| `get(path)` | Get node at path |
+| `getValue(path)` | Get plain value at path |
+| `setValue(path, value)` | Set value at path |
+| `getPlainValue()` | Get full plain value |
+| `patches` | JSON Patch operations (`JsonValuePatch[]`) for current changes |
+| `reset(data?)` | Reset to given data (or schema defaults) and commit |
+| `commit()` | Commit current state as base |
+| `revert()` | Revert to last committed state |
+
+#### ArrayValueNode
+
+| Method | Description |
+|--------|-------------|
+| `at(index)` | Get element at index (supports negative) |
+| `find(predicate)` | Find first element matching predicate, or `undefined` |
+| `findIndex(predicate)` | Find index of first matching element, or `-1` |
+| `push(node)` | Append element |
+| `pushValue(value?)` | Create and append element from value |
+| `removeAt(index)` | Remove element at index |
+| `move(from, to)` | Move element between positions |
+| `clear()` | Remove all elements |
+
 ### Value Tree
 
 | Function | Description |
@@ -268,7 +329,7 @@ See [ForeignKeyResolver docs](src/model/foreign-key-resolver/README.md) for cach
 | `InferNode<S>` | Schema → typed ValueNode interface |
 | `SchemaFromValue<T>` | Plain TS type → virtual schema shape |
 | `SchemaPaths<S>` | Union of all valid dot-separated paths |
-| `TypedRowModel<S>` | RowModel with typed `getValue`, `setValue`, `getPlainValue` |
+| `TypedRowModel<S>` | RowModel with typed `root`, `getValue`, `setValue`, `getPlainValue`, `reset` |
 | `TypedTableModel<S>` | TableModel with typed rows, `addRow`, `getRow` |
 
 See [Typed API documentation](src/types/TYPED-API.md) for the full reference.

package/dist/{chunk-MXEQ5CBK.js → chunk-2GZ3M3RV.js}

@@ -1197,6 +1197,9 @@ function arePrimitivesEqual(current, base, context) {
   if (current.foreignKey() !== base.foreignKey()) {
     return false;
   }
+  if (current.contentMediaType() !== base.contentMediaType()) {
+    return false;
+  }
   const currentFormula = current.formula();
   const baseFormula = base.formula();
   if (currentFormula === void 0 && baseFormula === void 0) {

package/dist/chunk-5G3AVY57.js

@@ -0,0 +1 @@
+

package/dist/chunk-5M74TGFQ.cjs

@@ -0,0 +1,2 @@
+'use strict';
+

package/dist/{chunk-3MXYXTNF.js → chunk-B3W5BASK.js}

@@ -1,4 +1,4 @@
-import { AbstractBasePath, EMPTY_PATH, FormulaError, ResolvedDependency, FormulaSerializer, createRefNode, createObjectNode, createArrayNode, createStringNode, createNumberNode, createBooleanNode, observable, makeObservable, makeAutoObservable, runInAction, PatchBuilder, SchemaSerializer, createSchemaTree, NULL_NODE, validateSchema, validateFormulas, reaction } from './chunk-MXEQ5CBK.js';
+import { AbstractBasePath, EMPTY_PATH, FormulaError, ResolvedDependency, FormulaSerializer, createRefNode, createObjectNode, createArrayNode, createStringNode, createNumberNode, createBooleanNode, observable, makeObservable, makeAutoObservable, runInAction, PatchBuilder, SchemaSerializer, createSchemaTree, NULL_NODE, validateSchema, validateFormulas, reaction } from './chunk-2GZ3M3RV.js';
 import { obj, ref } from './chunk-IZMBM36H.js';
 import { nanoid } from 'nanoid';
 import { parseFormula, parseExpression, evaluateWithContext } from '@revisium/formula';
@@ -397,6 +397,7 @@ var SchemaParser = class {
     return createStringNode(nodeId, name, {
       defaultValue: schema.default,
       foreignKey: schema.foreignKey,
+      contentMediaType: schema.contentMediaType,
       metadata: this.extractMetadata(schema),
       ref: ref2
     });
@@ -1741,6 +1742,12 @@ var ArrayValueNode = class extends BaseValueNode {
     }
     return this._items[index];
   }
+  find(predicate) {
+    return this._items.find((node, index) => predicate(node, index));
+  }
+  findIndex(predicate) {
+    return this._items.findIndex((node, index) => predicate(node, index));
+  }
   push(node) {
     node.parent = this;
     this._items.push(node);
@@ -3136,12 +3143,16 @@ var ValueTree = class {
 // src/model/table/row/RowModelImpl.ts
 var UNSET_INDEX = -1;
 var RowModelImpl = class {
-  constructor(_rowId, _tree) {
+  constructor(_rowId, _tree, _schema, _refSchemas) {
     this._rowId = _rowId;
     this._tree = _tree;
+    this._schema = _schema;
+    this._refSchemas = _refSchemas;
     makeAutoObservable(this, {
       _rowId: false,
       _tree: false,
+      _schema: false,
+      _refSchemas: false,
       _tableModel: "observable.ref"
     });
   }
@@ -3155,6 +3166,9 @@ var RowModelImpl = class {
   get tree() {
     return this._tree;
   }
+  get root() {
+    return this._tree.root;
+  }
   get index() {
     if (!this._tableModel) {
       return UNSET_INDEX;
@@ -3214,6 +3228,11 @@ var RowModelImpl = class {
   revert() {
     this._tree.revert();
   }
+  reset(data) {
+    const value = data ?? generateDefaultValue(this._schema, { refSchemas: this._refSchemas });
+    this._tree.setValue("", value);
+    this._tree.commit();
+  }
   dispose() {
     this._tree.dispose();
   }
@@ -3231,7 +3250,7 @@ function createRowModel(options) {
   const valueTree = new ValueTree(rootNode);
   const formulaEngine = new FormulaEngine(valueTree);
   valueTree.setFormulaEngine(formulaEngine);
-  return new RowModelImpl(options.rowId, valueTree);
+  return new RowModelImpl(options.rowId, valueTree, options.schema, options.refSchemas);
 }
 
 // src/model/table/TableModelImpl.ts

package/dist/{chunk-JLXX3SGF.js → chunk-GAP5KNWN.js}

@@ -1,5 +1,7 @@
-import { fileSchema, rowSchemaHashSchema, rowHashSchema, rowUpdatedAtSchema, rowPublishedAtSchema, rowCreatedAtSchema, rowCreatedIdSchema, rowVersionIdSchema, rowIdSchema } from './chunk-4U2RZHMX.js';
+import { fileSchema, rowSchemaHashSchema, rowHashSchema, rowUpdatedAtSchema, rowPublishedAtSchema, rowCreatedAtSchema, rowCreatedIdSchema, rowVersionIdSchema, rowIdSchema, ajvRowIdSchema, ajvRowCreatedIdSchema, ajvRowVersionIdSchema, ajvRowCreatedAtSchema, ajvRowPublishedAtSchema, ajvRowUpdatedAtSchema, ajvRowHashSchema, ajvRowSchemaHashSchema, ajvFileSchema } from './chunk-4U2RZHMX.js';
 import { JsonArrayStore, JsonObjectStore, JsonStringStore, JsonNumberStore, JsonBooleanStore, JsonObjectValueStore, JsonArrayValueStore, createJsonValueStore, getTransformation } from './chunk-FTBRJODD.js';
+import { metaSchema, jsonPatchSchema, tableMigrationsSchema, historyPatchesSchema, tableViewsSchema } from './chunk-HOMXBUQB.js';
+import Ajv from 'ajv/dist/2020';
 
 // src/lib/createJsonSchemaStore.ts
 var createJsonSchemaStore = (schema, refs = {}) => {
@@ -729,5 +731,230 @@ var SchemaTable = class {
     this.store = nextStore;
   }
 };
+var mapErrors = (errors) => {
+  if (!errors || errors.length === 0) {
+    return null;
+  }
+  return errors.map((err) => ({
+    instancePath: err.instancePath,
+    message: err.message,
+    keyword: err.keyword,
+    params: err.params
+  }));
+};
+var wrapValidateFn = (ajvFn) => {
+  const fn = ((data) => {
+    const result = ajvFn(data);
+    fn.errors = mapErrors(ajvFn.errors);
+    return result;
+  });
+  fn.errors = null;
+  return fn;
+};
+var RevisiumValidator = class {
+  validateMetaSchema;
+  validateJsonPatch;
+  validateMigrations;
+  validateHistoryPatches;
+  validateTableViews;
+  ajv;
+  cache = /* @__PURE__ */ new Map();
+  constructor() {
+    this.ajv = new Ajv();
+    this.ajv.addKeyword({
+      keyword: "foreignKey",
+      type: "string"
+    });
+    this.ajv.addKeyword({
+      keyword: "x-formula"
+    });
+    this.ajv.addFormat("regex", {
+      type: "string",
+      validate: (str) => {
+        try {
+          new RegExp(str);
+          return true;
+        } catch {
+          return false;
+        }
+      }
+    });
+    this.ajv.compile(ajvRowIdSchema);
+    this.ajv.compile(ajvRowCreatedIdSchema);
+    this.ajv.compile(ajvRowVersionIdSchema);
+    this.ajv.compile(ajvRowCreatedAtSchema);
+    this.ajv.compile(ajvRowPublishedAtSchema);
+    this.ajv.compile(ajvRowUpdatedAtSchema);
+    this.ajv.compile(ajvRowHashSchema);
+    this.ajv.compile(ajvRowSchemaHashSchema);
+    this.ajv.compile(ajvFileSchema);
+    this.validateMetaSchema = wrapValidateFn(this.ajv.compile(metaSchema));
+    this.validateJsonPatch = wrapValidateFn(this.ajv.compile(jsonPatchSchema));
+    this.validateMigrations = wrapValidateFn(
+      this.ajv.compile(tableMigrationsSchema)
+    );
+    this.validateHistoryPatches = wrapValidateFn(
+      this.ajv.compile(historyPatchesSchema)
+    );
+    this.validateTableViews = wrapValidateFn(
+      this.ajv.compile(tableViewsSchema)
+    );
+  }
+  compile(schema) {
+    const key = JSON.stringify(schema);
+    const cached = this.cache.get(key);
+    if (cached) {
+      return cached;
+    }
+    const fn = wrapValidateFn(
+      this.ajv.compile(schema)
+    );
+    this.cache.set(key, fn);
+    return fn;
+  }
+};
+
+// src/lib/validateRevisiumSchema.ts
+var cachedValidator = null;
+var getValidator = () => {
+  if (cachedValidator) {
+    return cachedValidator;
+  }
+  cachedValidator = new RevisiumValidator();
+  return cachedValidator;
+};
+var validateRevisiumSchema = (schema) => {
+  const validator = getValidator();
+  const valid = validator.validateMetaSchema(schema);
+  if (valid) {
+    return { valid: true };
+  }
+  const errors = (validator.validateMetaSchema.errors ?? []).map((err) => {
+    const path = err.instancePath || "/";
+    return `${path}: ${err.message ?? "unknown error"}`;
+  });
+  return { valid: false, errors };
+};
+
+// src/lib/calculateSchemaWeight.ts
+var calculateSchemaWeight = (schema) => {
+  const result = {
+    totalFields: 0,
+    maxDepth: 0,
+    fieldNames: 0,
+    totalArrays: 0,
+    maxArrayDepth: 0
+  };
+  walkSchema(schema, 0, 0, result);
+  return result;
+};
+var walkSchema = (schema, depth, arrayDepth, result) => {
+  if (result.maxDepth < depth) {
+    result.maxDepth = depth;
+  }
+  if ("$ref" in schema) {
+    return;
+  }
+  if (schema.type === "object" && schema.properties) {
+    for (const [fieldName, fieldSchema] of Object.entries(schema.properties)) {
+      result.totalFields++;
+      result.fieldNames += fieldName.length;
+      walkSchema(fieldSchema, depth + 1, arrayDepth, result);
+    }
+  }
+  if (schema.type === "array" && schema.items) {
+    const nextArrayDepth = arrayDepth + 1;
+    result.totalArrays++;
+    if (nextArrayDepth > result.maxArrayDepth) {
+      result.maxArrayDepth = nextArrayDepth;
+    }
+    walkSchema(schema.items, depth + 1, nextArrayDepth, result);
+  }
+};
+
+// src/lib/calculateDataWeight.ts
+var calculateDataWeight = (data) => {
+  const result = {
+    totalBytes: 0,
+    totalNodes: 0,
+    maxDepth: 0,
+    maxArrayLength: 0,
+    maxStringLength: 0,
+    totalStringsLength: 0
+  };
+  result.totalBytes = JSON.stringify(data).length;
+  walkValue(data, 0, result);
+  return result;
+};
+var walkValue = (value, depth, result) => {
+  result.totalNodes++;
+  if (result.maxDepth < depth) {
+    result.maxDepth = depth;
+  }
+  if (value === null || value === void 0) {
+    return;
+  }
+  if (typeof value === "string") {
+    if (value.length > result.maxStringLength) {
+      result.maxStringLength = value.length;
+    }
+    result.totalStringsLength += value.length;
+    return;
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return;
+  }
+  if (Array.isArray(value)) {
+    if (value.length > result.maxArrayLength) {
+      result.maxArrayLength = value.length;
+    }
+    for (const item of value) {
+      walkValue(item, depth + 1, result);
+    }
+    return;
+  }
+  if (typeof value === "object") {
+    for (const val of Object.values(value)) {
+      walkValue(val, depth + 1, result);
+    }
+  }
+};
+var calculateDataWeightFromStore = (store) => {
+  const result = {
+    totalBytes: 0,
+    totalNodes: 0,
+    maxDepth: 0,
+    maxArrayLength: 0,
+    maxStringLength: 0,
+    totalStringsLength: 0
+  };
+  result.totalBytes = JSON.stringify(store.getPlainValue()).length;
+  walkStore(store, 0, result);
+  return result;
+};
+var walkStore = (store, depth, result) => {
+  result.totalNodes++;
+  if (result.maxDepth < depth) {
+    result.maxDepth = depth;
+  }
+  if (store.type === "string") {
+    const val = store.getPlainValue();
+    if (val.length > result.maxStringLength) {
+      result.maxStringLength = val.length;
+    }
+    result.totalStringsLength += val.length;
+  } else if (store.type === "object") {
+    for (const child of Object.values(store.value)) {
+      walkStore(child, depth + 1, result);
+    }
+  } else if (store.type === "array") {
+    if (store.value.length > result.maxArrayLength) {
+      result.maxArrayLength = store.value.length;
+    }
+    for (const child of store.value) {
+      walkStore(child, depth + 1, result);
+    }
+  }
+};
 
-export { SchemaTable, VALIDATE_JSON_FIELD_NAME_ERROR_MESSAGE, applyAddPatch, applyMovePatch, applyRemovePatch, applyReplacePatch, convertJsonPathToSchemaPath, convertSchemaPathToJsonPath, createJsonObjectSchemaStore, createJsonSchemaStore, createPrimitiveStoreBySchema, deepEqual, getDBJsonPathByJsonSchemaStore, getForeignKeyPatchesFromSchema, getForeignKeysFromSchema, getForeignKeysFromValue, getInvalidFieldNamesInSchema, getJsonSchemaStoreByPath, getJsonValueStoreByPath, getParentForPath, getPathByStore, getValueByPath, hasPath, parsePath, pluginRefs, replaceForeignKeyValue, resolveRefs, saveSharedFields, setValueByPath, traverseStore, traverseValue, validateJsonFieldName };
+export { RevisiumValidator, SchemaTable, VALIDATE_JSON_FIELD_NAME_ERROR_MESSAGE, applyAddPatch, applyMovePatch, applyRemovePatch, applyReplacePatch, calculateDataWeight, calculateDataWeightFromStore, calculateSchemaWeight, convertJsonPathToSchemaPath, convertSchemaPathToJsonPath, createJsonObjectSchemaStore, createJsonSchemaStore, createPrimitiveStoreBySchema, deepEqual, getDBJsonPathByJsonSchemaStore, getForeignKeyPatchesFromSchema, getForeignKeysFromSchema, getForeignKeysFromValue, getInvalidFieldNamesInSchema, getJsonSchemaStoreByPath, getJsonValueStoreByPath, getParentForPath, getPathByStore, getValueByPath, hasPath, parsePath, pluginRefs, replaceForeignKeyValue, resolveRefs, saveSharedFields, setValueByPath, traverseStore, traverseValue, validateJsonFieldName, validateRevisiumSchema };

package/dist/{chunk-XKWWCXGB.js → chunk-HOMXBUQB.js}

@@ -317,25 +317,6 @@ var jsonPatchSchema = {
   type: "array"
 };
 
-// src/validation-schemas/history-patches-schema.ts
-var historyPatchesSchema = {
-  $id: "history-patches-schema.json",
-  type: "array",
-  minItems: 1,
-  items: {
-    type: "object",
-    properties: {
-      patches: {
-        $ref: "json-patch-schema.json"
-      },
-      hash: {
-        type: "string"
-      }
-    },
-    required: ["patches", "hash"]
-  }
-};
-
 // src/validation-schemas/table-migrations-schema.ts
 var tableMigrationsSchema = {
   $id: "table-migrations-schema.json",
@@ -395,4 +376,146 @@ var tableMigrationsSchema = {
   title: "JSON Schema for a Single Migration"
 };
 
-export { arrayMetaSchema, baseStringFields, booleanMetaSchema, foreignKeyExcludesFormula, historyPatchesSchema, jsonPatchSchema, metaSchema, noForeignKeyStringMetaSchema, notForeignKeyMetaSchema, numberMetaSchema, objectMetaSchema, refMetaSchema, sharedFields, stringMetaSchema, tableMigrationsSchema, xFormulaRequiresReadOnly, xFormulaSchema };
+// src/validation-schemas/history-patches-schema.ts
+var historyPatchesSchema = {
+  $id: "history-patches-schema.json",
+  type: "array",
+  minItems: 1,
+  items: {
+    type: "object",
+    properties: {
+      patches: {
+        $ref: "json-patch-schema.json"
+      },
+      hash: {
+        type: "string"
+      }
+    },
+    required: ["patches", "hash"]
+  }
+};
+
+// src/validation-schemas/table-views-schema.ts
+var tableViewsSchema = {
+  $id: "table-views-schema.json",
+  type: "object",
+  additionalProperties: false,
+  required: ["version", "views"],
+  properties: {
+    version: {
+      type: "integer",
+      minimum: 1,
+      default: 1
+    },
+    defaultViewId: {
+      type: "string",
+      default: "default"
+    },
+    views: {
+      type: "array",
+      items: { $ref: "#/$defs/View" },
+      default: []
+    }
+  },
+  $defs: {
+    View: {
+      type: "object",
+      additionalProperties: false,
+      required: ["id", "name"],
+      properties: {
+        id: { type: "string", minLength: 1 },
+        name: { type: "string", minLength: 1, maxLength: 100 },
+        description: { type: "string", maxLength: 500, default: "" },
+        columns: {
+          oneOf: [
+            { type: "null" },
+            { type: "array", items: { $ref: "#/$defs/Column" } }
+          ],
+          default: null
+        },
+        filters: { $ref: "#/$defs/FilterGroup" },
+        sorts: {
+          type: "array",
+          items: { $ref: "#/$defs/Sort" },
+          default: []
+        },
+        search: {
+          type: "string",
+          default: ""
+        }
+      }
+    },
+    Column: {
+      type: "object",
+      additionalProperties: false,
+      required: ["field"],
+      properties: {
+        field: { type: "string", minLength: 1 },
+        width: { type: "number", minimum: 40 }
+      }
+    },
+    FilterGroup: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        logic: {
+          type: "string",
+          enum: ["and", "or"],
+          default: "and"
+        },
+        conditions: {
+          type: "array",
+          items: { $ref: "#/$defs/FilterCondition" },
+          default: []
+        },
+        groups: {
+          type: "array",
+          items: { $ref: "#/$defs/FilterGroup" },
+          default: []
+        }
+      }
+    },
+    FilterCondition: {
+      type: "object",
+      additionalProperties: false,
+      required: ["field", "operator"],
+      properties: {
+        field: { type: "string", minLength: 1 },
+        operator: {
+          type: "string",
+          enum: [
+            "equals",
+            "not_equals",
+            "contains",
+            "not_contains",
+            "starts_with",
+            "ends_with",
+            "is_empty",
+            "is_not_empty",
+            "gt",
+            "gte",
+            "lt",
+            "lte",
+            "is_true",
+            "is_false"
+          ]
+        },
+        value: {}
+      }
+    },
+    Sort: {
+      type: "object",
+      additionalProperties: false,
+      required: ["field", "direction"],
+      properties: {
+        field: { type: "string", minLength: 1 },
+        direction: {
+          type: "string",
+          enum: ["asc", "desc"]
+        }
+      }
+    }
+  }
+};
+
+export { arrayMetaSchema, baseStringFields, booleanMetaSchema, foreignKeyExcludesFormula, historyPatchesSchema, jsonPatchSchema, metaSchema, noForeignKeyStringMetaSchema, notForeignKeyMetaSchema, numberMetaSchema, objectMetaSchema, refMetaSchema, sharedFields, stringMetaSchema, tableMigrationsSchema, tableViewsSchema, xFormulaRequiresReadOnly, xFormulaSchema };