@revisium/schema-toolkit 0.2.0

package/dist/lib/index.cjs

@@ -0,0 +1,1346 @@
+'use strict';
+
+var nanoid = require('nanoid');
+var events = require('events');
+
+// src/lib/addSharedFieldsFromStore.ts
+var addSharedFieldsFromState = (schema, state) => {
+  if (state.title) {
+    schema.title = state.title;
+  }
+  if (state.description) {
+    schema.description = state.description;
+  }
+  if (state.deprecated) {
+    schema.deprecated = state.deprecated;
+  }
+  return schema;
+};
+var JsonArrayStore = class {
+  constructor(_items, nodeId = nanoid.nanoid()) {
+    this._items = _items;
+    this.nodeId = nodeId;
+    this.items.parent = this;
+  }
+  type = "array" /* Array */;
+  $ref = "";
+  name = "";
+  parent = null;
+  default = [];
+  title;
+  description;
+  deprecated;
+  valuesMap = /* @__PURE__ */ new Map();
+  get items() {
+    return this._items;
+  }
+  registerValue(value) {
+    const length = this.getOrCreateValues(value.rowId).push(value);
+    return length - 1;
+  }
+  getValue(rowId, index = 0) {
+    return this.getOrCreateValues(rowId)[index];
+  }
+  migrateItems(items) {
+    const previousItems = this._items;
+    previousItems.parent = null;
+    this._items = items;
+    this._items.parent = this;
+    const event = { items, previousItems };
+    for (const value of this.iterValues()) {
+      value.migrateItems(event);
+    }
+  }
+  replaceItems(items) {
+    const previousItems = this._items;
+    previousItems.parent = null;
+    this._items = items;
+    this._items.parent = this;
+    const event = { items, previousItems };
+    for (const value of this.iterValues()) {
+      value.replaceItems(event);
+    }
+  }
+  getPlainSchema(options) {
+    if (this.$ref && options?.skip$Ref !== true) {
+      return addSharedFieldsFromState({ $ref: this.$ref }, this);
+    }
+    return addSharedFieldsFromState(
+      {
+        type: this.type,
+        items: this.items.getPlainSchema(options)
+      },
+      this
+    );
+  }
+  getOrCreateValues(rowId) {
+    let values = this.valuesMap.get(rowId);
+    if (!values) {
+      values = [];
+      this.valuesMap.set(rowId, values);
+    }
+    return values;
+  }
+  *iterValues() {
+    for (const values of this.valuesMap.values()) {
+      for (const value of values) {
+        yield value;
+      }
+    }
+  }
+};
+var JsonBooleanStore = class extends events.EventEmitter {
+  constructor(nodeId = nanoid.nanoid()) {
+    super();
+    this.nodeId = nodeId;
+  }
+  type = "boolean" /* Boolean */;
+  $ref = "";
+  name = "";
+  parent = null;
+  default = false;
+  readOnly;
+  title;
+  description;
+  deprecated;
+  valuesMap = /* @__PURE__ */ new Map();
+  registerValue(value) {
+    const length = this.getOrCreateValues(value.rowId).push(value);
+    return length - 1;
+  }
+  getValue(rowId, index = 0) {
+    return this.getOrCreateValues(rowId)[index];
+  }
+  getPlainSchema(options) {
+    if (this.$ref && options?.skip$Ref !== true) {
+      return addSharedFieldsFromState({ $ref: this.$ref }, this);
+    }
+    return addSharedFieldsFromState(
+      {
+        type: this.type,
+        default: this.default,
+        ...this.readOnly ? { readOnly: this.readOnly } : {}
+      },
+      this
+    );
+  }
+  getOrCreateValues(rowId) {
+    let values = this.valuesMap.get(rowId);
+    if (!values) {
+      values = [];
+      this.valuesMap.set(rowId, values);
+    }
+    return values;
+  }
+};
+var JsonNumberStore = class extends events.EventEmitter {
+  constructor(nodeId = nanoid.nanoid()) {
+    super();
+    this.nodeId = nodeId;
+  }
+  type = "number" /* Number */;
+  $ref = "";
+  name = "";
+  parent = null;
+  default = 0;
+  readOnly;
+  title;
+  description;
+  deprecated;
+  valuesMap = /* @__PURE__ */ new Map();
+  registerValue(value) {
+    const length = this.getOrCreateValues(value.rowId).push(value);
+    return length - 1;
+  }
+  getValue(rowId, index = 0) {
+    return this.getOrCreateValues(rowId)[index];
+  }
+  getPlainSchema(options) {
+    if (this.$ref && options?.skip$Ref !== true) {
+      return addSharedFieldsFromState({ $ref: this.$ref }, this);
+    }
+    return addSharedFieldsFromState(
+      {
+        type: this.type,
+        default: this.default,
+        ...this.readOnly ? { readOnly: this.readOnly } : {}
+      },
+      this
+    );
+  }
+  getOrCreateValues(rowId) {
+    let values = this.valuesMap.get(rowId);
+    if (!values) {
+      values = [];
+      this.valuesMap.set(rowId, values);
+    }
+    return values;
+  }
+};
+var JsonStringStore = class extends events.EventEmitter {
+  constructor(nodeId = nanoid.nanoid()) {
+    super();
+    this.nodeId = nodeId;
+  }
+  type = "string" /* String */;
+  $ref = "";
+  name = "";
+  parent = null;
+  default = "";
+  readOnly;
+  title;
+  description;
+  deprecated;
+  foreignKey;
+  pattern;
+  enum;
+  format;
+  contentMediaType;
+  valuesMap = /* @__PURE__ */ new Map();
+  registerValue(value) {
+    const length = this.getOrCreateValues(value.rowId).push(value);
+    return length - 1;
+  }
+  getValue(rowId, index = 0) {
+    return this.getOrCreateValues(rowId)[index];
+  }
+  getPlainSchema(options) {
+    if (this.$ref && options?.skip$Ref !== true) {
+      return addSharedFieldsFromState({ $ref: this.$ref }, this);
+    }
+    return addSharedFieldsFromState(
+      {
+        type: this.type,
+        default: this.default,
+        ...this.foreignKey ? { foreignKey: this.foreignKey } : {},
+        ...this.readOnly ? { readOnly: this.readOnly } : {},
+        ...this.pattern ? { pattern: this.pattern } : {},
+        ...this.enum ? { enum: this.enum } : {},
+        ...this.format ? { format: this.format } : {},
+        ...this.contentMediaType ? { contentMediaType: this.contentMediaType } : {}
+      },
+      this
+    );
+  }
+  getOrCreateValues(rowId) {
+    let values = this.valuesMap.get(rowId);
+    if (!values) {
+      values = [];
+      this.valuesMap.set(rowId, values);
+    }
+    return values;
+  }
+};
+var JsonObjectStore = class {
+  constructor(nodeId = nanoid.nanoid()) {
+    this.nodeId = nodeId;
+  }
+  type = "object" /* Object */;
+  $ref = "";
+  name = "";
+  parent = null;
+  default = {};
+  title;
+  description;
+  deprecated;
+  additionalProperties = false;
+  required = [];
+  properties = {};
+  valuesMap = /* @__PURE__ */ new Map();
+  get empty() {
+    return Object.keys(this.properties).length === 0;
+  }
+  registerValue(value) {
+    const length = this.getOrCreateValues(value.rowId).push(value);
+    return length - 1;
+  }
+  getValue(rowId, index = 0) {
+    return this.getOrCreateValues(rowId)[index];
+  }
+  addPropertyWithStore(name, store) {
+    if (this.properties[name] || this.required.includes(name)) {
+      throw new Error("this name already exists");
+    }
+    store.parent = this;
+    store.name = name;
+    this.required.push(name);
+    this.required.sort((a, b) => a.localeCompare(b));
+    this.properties[name] = store;
+    this.default[name] = store.default;
+    const event = { name, property: store };
+    for (const value of this.iterValues()) {
+      value.addProperty(event);
+    }
+    return store;
+  }
+  migratePropertyWithStore(name, store) {
+    const item = this.properties[name];
+    if (!item) {
+      throw new Error("this name does not exist");
+    }
+    item.parent = null;
+    store.parent = this;
+    store.name = name;
+    this.properties[name] = store;
+    this.default[name] = store.default;
+    const event = {
+      name,
+      property: store,
+      previousProperty: item
+    };
+    for (const value of this.iterValues()) {
+      value.migrateProperty(event);
+    }
+    return store;
+  }
+  changeName(fromName, toName) {
+    const item = this.properties[fromName];
+    if (!item) {
+      throw new Error("this fromName does not exist");
+    }
+    delete this.properties[fromName];
+    delete this.default[fromName];
+    const foundRequiredIndex = this.required.findIndex(
+      (required) => required === fromName
+    );
+    if (foundRequiredIndex !== -1) {
+      this.required.splice(foundRequiredIndex, 1);
+    }
+    if (!this.required.includes(toName)) {
+      this.required.push(toName);
+      this.required.sort((a, b) => a.localeCompare(b));
+    }
+    this.properties[toName] = item;
+    this.default[toName] = item.default;
+    const event = {
+      fromName,
+      toName,
+      property: item
+    };
+    for (const value of this.iterValues()) {
+      value.changeName(event);
+    }
+  }
+  removeProperty(name) {
+    const item = this.properties[name];
+    if (!item) {
+      throw new Error("this name does not exist");
+    }
+    item.parent = null;
+    item.name = "";
+    delete this.properties[name];
+    delete this.default[name];
+    const foundRequiredIndex = this.required.findIndex(
+      (required) => required === name
+    );
+    if (foundRequiredIndex !== -1) {
+      this.required.splice(foundRequiredIndex, 1);
+    }
+    const event = {
+      name,
+      property: item
+    };
+    for (const value of this.iterValues()) {
+      value.removeProperty(event);
+    }
+  }
+  getProperty(name) {
+    return this.properties[name];
+  }
+  getPlainSchema(options) {
+    if (this.$ref && options?.skip$Ref !== true) {
+      return addSharedFieldsFromState({ $ref: this.$ref }, this);
+    }
+    return addSharedFieldsFromState(
+      {
+        type: this.type,
+        additionalProperties: this.additionalProperties,
+        required: this.required,
+        properties: Object.entries(this.properties).reduce((result, [name, store]) => {
+          result[name] = store.getPlainSchema(options);
+          return result;
+        }, {})
+      },
+      this
+    );
+  }
+  getOrCreateValues(rowId) {
+    let values = this.valuesMap.get(rowId);
+    if (!values) {
+      values = [];
+      this.valuesMap.set(rowId, values);
+    }
+    return values;
+  }
+  *iterValues() {
+    for (const values of this.valuesMap.values()) {
+      for (const value of values) {
+        yield value;
+      }
+    }
+  }
+};
+
+// src/lib/createJsonSchemaStore.ts
+var createJsonSchemaStore = (schema, refs = {}) => {
+  if ("$ref" in schema) {
+    const refSchema = refs[schema.$ref];
+    if (!refSchema) {
+      throw new Error(`Not found schema for $ref="${schema.$ref}"`);
+    }
+    const refStore = createJsonSchemaStore(refSchema, refs);
+    saveSharedFields(refStore, schema);
+    refStore.$ref = schema.$ref;
+    return refStore;
+  } else if (schema.type === "object" /* Object */) {
+    const objectStore = createJsonObjectSchemaStore(schema, refs);
+    saveSharedFields(objectStore, schema);
+    return objectStore;
+  } else if (schema.type === "array" /* Array */) {
+    const itemsStore = createJsonSchemaStore(schema.items, refs);
+    const arrayStore = new JsonArrayStore(itemsStore);
+    saveSharedFields(arrayStore, schema);
+    return arrayStore;
+  } else {
+    const primitivesStore = createPrimitiveStoreBySchema(schema);
+    saveSharedFields(primitivesStore, schema);
+    primitivesStore.readOnly = schema.readOnly;
+    return primitivesStore;
+  }
+};
+var createJsonObjectSchemaStore = (value, refs) => {
+  const store = new JsonObjectStore();
+  for (const requiredField of value.required) {
+    if (!value.properties[requiredField]) {
+      throw new Error(
+        `Not found required field "${requiredField}" in "properties"`
+      );
+    }
+  }
+  Object.entries(value.properties).forEach(([name, item]) => {
+    store.addPropertyWithStore(name, createJsonSchemaStore(item, refs));
+  });
+  return store;
+};
+var createPrimitiveStoreBySchema = (schema) => {
+  if (schema.type === "string" /* String */) {
+    const stringStore = new JsonStringStore();
+    stringStore.foreignKey = schema.foreignKey;
+    stringStore.format = schema.format;
+    stringStore.enum = schema.enum;
+    stringStore.contentMediaType = schema.contentMediaType;
+    stringStore.pattern = schema.pattern;
+    return stringStore;
+  } else if (schema.type === "number" /* Number */) {
+    return new JsonNumberStore();
+  } else if (schema.type === "boolean" /* Boolean */) {
+    return new JsonBooleanStore();
+  } else {
+    throw new Error("this type is not allowed");
+  }
+};
+var saveSharedFields = (store, schema) => {
+  store.title = schema.title;
+  store.description = schema.description;
+  store.deprecated = schema.deprecated;
+};
+
+// src/lib/getJsonSchemaStoreByPath.ts
+var getJsonSchemaStoreByPath = (store, path) => {
+  if (path === "") {
+    return store;
+  }
+  if (path === "/") {
+    throw new Error(
+      'invalid root path, need to use path="" instead of path="/"'
+    );
+  }
+  const tokens = path.split("/");
+  tokens.shift();
+  let currentStore = store;
+  let currentToken = tokens.shift();
+  let currentPath = "";
+  while (currentToken) {
+    if (currentStore.type === "object" /* Object */) {
+      if (currentToken !== "properties") {
+        throw new Error(
+          `Expected "${currentPath}/properties/*" instead of ${currentPath}/${currentToken}/*`
+        );
+      }
+      currentPath = `${currentPath}/${currentToken}`;
+      currentToken = tokens.shift();
+      if (!currentToken) {
+        throw new Error(`Expected property name after "${currentPath}"`);
+      }
+      const foundCurrentStore = currentStore.getProperty(currentToken);
+      if (!foundCurrentStore) {
+        throw new Error(`Not found "${currentToken}" in "${currentPath}"`);
+      }
+      currentStore = foundCurrentStore;
+      currentPath = `${currentPath}/${currentToken}`;
+      currentToken = tokens.shift();
+    } else if (currentStore.type === "array" /* Array */) {
+      if (currentToken !== "items") {
+        throw new Error(
+          `Expected "${currentPath}/items/*" instead of ${currentPath}/${currentToken}/*`
+        );
+      }
+      currentPath = `${currentPath}/${currentToken}`;
+      currentStore = currentStore.items;
+      currentToken = tokens.shift();
+    } else {
+      throw new Error(`Unexpected "${currentToken}" in "${currentPath}"`);
+    }
+  }
+  return currentStore;
+};
+
+// src/lib/getParentForPath.ts
+var getParentForPath = (path) => {
+  if (path === "" || path === "/") {
+    throw new Error("Invalid path");
+  }
+  const tokens = path.split("/");
+  tokens.shift();
+  let currentToken = tokens.shift();
+  let parentPath = "";
+  let field = "";
+  while (currentToken) {
+    if (currentToken === "properties") {
+      currentToken = tokens.shift();
+      if (!currentToken) {
+        throw new Error("Invalid path");
+      }
+      field = currentToken;
+      currentToken = tokens.shift();
+      if (currentToken) {
+        parentPath = `${parentPath}/properties/${field}`;
+      }
+    } else if (currentToken === "items") {
+      field = currentToken;
+      currentToken = tokens.shift();
+      if (currentToken && !["items", "properties"].includes(currentToken)) {
+        throw new Error("Invalid path");
+      } else if (currentToken) {
+        parentPath = `${parentPath}/items`;
+      }
+    } else {
+      throw new Error("Invalid path");
+    }
+  }
+  return {
+    parentPath,
+    field
+  };
+};
+
+// src/lib/validateJsonFieldName.ts
+var maxLength = 64;
+var VALIDATE_JSON_FIELD_NAME_ERROR_MESSAGE = `It must contain between 1 and ${maxLength} characters, start with a letter or underscore (_), cannot start with two underscores (__), and can only include letters (a-z, A-Z), numbers (0-9), hyphens (-), and underscores (_).`;
+var validPattern = /^(?!__)[a-zA-Z_][a-zA-Z0-9-_]*$/;
+var validateJsonFieldName = (id) => {
+  const isInvalid = id.length < 1 || id.length > maxLength || !validPattern.test(id);
+  return !isInvalid;
+};
+
+// src/lib/applyPatches.ts
+var applyReplacePatch = (store, patch, refs = {}) => {
+  const patchStore = createJsonSchemaStore(patch.value, refs);
+  const foundStore = getJsonSchemaStoreByPath(store, patch.path);
+  const parent = foundStore.parent;
+  if (!parent) {
+    return patchStore;
+  }
+  if (parent.type === "object" /* Object */) {
+    parent.migratePropertyWithStore(foundStore.name, patchStore);
+  } else if (parent.type === "array" /* Array */) {
+    parent.migrateItems(patchStore);
+  } else {
+    throw new Error("Invalid parent");
+  }
+  return store;
+};
+var applyRemovePatch = (rootStore, patch) => {
+  const foundStore = getJsonSchemaStoreByPath(rootStore, patch.path);
+  const parent = foundStore.parent;
+  if (!parent) {
+    throw new Error("Parent does not exist");
+  }
+  if (parent.type !== "object" /* Object */) {
+    throw new Error("Cannot remove from non-object");
+  }
+  parent.removeProperty(foundStore.name);
+};
+var applyAddPatch = (rootStore, patch, refs = {}) => {
+  const patchStore = createJsonSchemaStore(patch.value, refs);
+  const { parentPath, field } = getParentForPath(patch.path);
+  const foundParent = getJsonSchemaStoreByPath(rootStore, parentPath);
+  if (!foundParent) {
+    throw new Error("Parent does not exist");
+  }
+  if (foundParent.type !== "object" /* Object */) {
+    throw new Error("Cannot add to non-object");
+  }
+  if (foundParent.getProperty(field)) {
+    throw new Error(`Field "${field}" already exists in parent`);
+  }
+  foundParent.addPropertyWithStore(field, patchStore);
+};
+var applyMovePatch = (store, patch) => {
+  const { parentPath: fromParentPath, field: fromField } = getParentForPath(
+    patch.from
+  );
+  const { parentPath: toParentPath, field: toField } = getParentForPath(
+    patch.path
+  );
+  const foundFromParent = getJsonSchemaStoreByPath(store, fromParentPath);
+  const foundToParent = getJsonSchemaStoreByPath(store, toParentPath);
+  const isValidToField = validateJsonFieldName(toField);
+  if (!isValidToField) {
+    throw new Error(
+      `Invalid name: ${toField}. ${VALIDATE_JSON_FIELD_NAME_ERROR_MESSAGE}`
+    );
+  }
+  if (!foundFromParent || !foundToParent) {
+    throw new Error("Cannot move from or to non-existent parent");
+  }
+  if (foundFromParent.type !== "object" /* Object */) {
+    throw new Error("Cannot move from non-object parent");
+  }
+  const foundFromField = getJsonSchemaStoreByPath(store, patch.from);
+  const isMovedPropertyInSameParentPatch = foundFromParent === foundToParent && foundFromParent.type === "object" /* Object */ && foundFromParent.getProperty(fromField);
+  if (isMovedPropertyInSameParentPatch) {
+    return foundFromParent.changeName(fromField, toField);
+  }
+  if (foundToParent.type === "object" /* Object */) {
+    foundFromParent.removeProperty(fromField);
+    if (foundToParent.getProperty(toField)) {
+      foundToParent.removeProperty(toField);
+    }
+    foundToParent.addPropertyWithStore(toField, foundFromField);
+    return;
+  }
+  if (foundToParent.type === "array" /* Array */) {
+    foundFromParent.removeProperty(fromField);
+    foundToParent.replaceItems(foundFromField);
+    return;
+  }
+  throw new Error('Invalid type of "to" parent');
+};
+
+// src/model/value/value-transformation.ts
+var equel = (value) => value;
+var fromNumberToString = (value, defaultValue = "") => value.toString() || defaultValue;
+var fromBooleanToString = (value, defaultValue = "") => value.toString() || defaultValue;
+var fromStringToBoolean = (value, defaultValue = false) => {
+  if (!value) {
+    return defaultValue;
+  }
+  if (value.toLowerCase() === "false") {
+    return false;
+  }
+  return true;
+};
+var fromStringToNumber = (value, defaultValue = 0) => {
+  const number = Number.parseFloat(value);
+  if (Number.isNaN(number)) {
+    return defaultValue;
+  }
+  return number;
+};
+var fromBooleanToNumber = (value) => {
+  return Number(value);
+};
+var fromNumberToBoolean = (value) => {
+  return Boolean(value);
+};
+var toArrayTransformation = (transformation) => (value) => {
+  const result = transformation(value);
+  return [result];
+};
+var fromArrayTransformation = (transformation) => (value) => {
+  if (Array.isArray(value) && value.length) {
+    return transformation(value[0]);
+  }
+  return void 0;
+};
+var replaceTransformationsMapper = [
+  {
+    fromType: "number" /* Number */,
+    toType: "string" /* String */,
+    transformation: fromNumberToString
+  },
+  {
+    fromType: "string" /* String */,
+    toType: "number" /* Number */,
+    transformation: fromStringToNumber
+  },
+  {
+    fromType: "boolean" /* Boolean */,
+    toType: "string" /* String */,
+    transformation: fromBooleanToString
+  },
+  {
+    fromType: "string" /* String */,
+    toType: "boolean" /* Boolean */,
+    transformation: fromStringToBoolean
+  },
+  {
+    fromType: "boolean" /* Boolean */,
+    toType: "number" /* Number */,
+    transformation: fromBooleanToNumber
+  },
+  {
+    fromType: "number" /* Number */,
+    toType: "boolean" /* Boolean */,
+    transformation: fromNumberToBoolean
+  }
+];
+var getTransformation = (from, to) => {
+  if (to instanceof JsonArrayStore) {
+    const transformation = findTransformation(from.type, to.items.type);
+    if (!transformation) {
+      return;
+    }
+    return toArrayTransformation(transformation);
+  } else if (from instanceof JsonArrayStore) {
+    const transformation = findTransformation(from.items.type, to.type);
+    if (!transformation) {
+      return;
+    }
+    return fromArrayTransformation(transformation);
+  }
+  return findTransformation(from.type, to.type);
+};
+var findTransformation = (from, to) => {
+  if (from === to) {
+    return equel;
+  }
+  for (const item of replaceTransformationsMapper) {
+    if (item.fromType === from && item.toType === to) {
+      return item.transformation;
+    }
+  }
+  return void 0;
+};
+
+// src/model/value/json-array-value.store.ts
+var JsonArrayValueStore = class {
+  constructor(schema, rowId, value) {
+    this.schema = schema;
+    this.rowId = rowId;
+    this.value = value;
+    this.index = this.schema.registerValue(this);
+    this.init();
+  }
+  type = "array" /* Array */;
+  index;
+  parent = null;
+  getPlainValue() {
+    return this.value.map((item) => item.getPlainValue());
+  }
+  migrateItems(event) {
+    const transformation = getTransformation(event.previousItems, event.items);
+    this.value = this.value.map((valueItem) => {
+      const rawValue = transformation ? transformation(
+        valueItem.getPlainValue(),
+        event.items.default
+      ) : event.items.default;
+      return createJsonValueStore(event.items, this.rowId, rawValue);
+    });
+  }
+  replaceItems(event) {
+    this.value = this.value.map(() => {
+      const rawValue = this.getReplacedValue(event);
+      return createJsonValueStore(event.items, this.rowId, rawValue);
+    });
+  }
+  getReplacedValue(event) {
+    const previousValue = event.items.getValue(this.rowId);
+    if (previousValue) {
+      return previousValue.getPlainValue();
+    }
+    return event.items.default;
+  }
+  init() {
+    for (const value of this.value) {
+      value.parent = this;
+    }
+  }
+};
+
+// src/model/value/json-boolean-value.store.ts
+var JsonBooleanValueStore = class {
+  constructor(schema, rowId, value = null) {
+    this.schema = schema;
+    this.rowId = rowId;
+    this.value = value;
+    this.index = this.schema.registerValue(this);
+  }
+  type = "boolean" /* Boolean */;
+  index;
+  parent = null;
+  getPlainValue() {
+    return this.value ?? this.schema.default;
+  }
+};
+
+// src/model/value/json-number-value.store.ts
+var JsonNumberValueStore = class {
+  constructor(schema, rowId, value = null) {
+    this.schema = schema;
+    this.rowId = rowId;
+    this.value = value;
+    this.index = this.schema.registerValue(this);
+  }
+  type = "number" /* Number */;
+  index;
+  parent = null;
+  getPlainValue() {
+    return this.value ?? this.schema.default;
+  }
+};
+
+// src/model/value/json-object-value.store.ts
+var JsonObjectValueStore = class {
+  constructor(schema, rowId, value) {
+    this.schema = schema;
+    this.rowId = rowId;
+    this.value = value;
+    this.index = this.schema.registerValue(this);
+    this.init();
+  }
+  type = "object" /* Object */;
+  index;
+  parent = null;
+  getPlainValue() {
+    return Object.entries(this.value).reduce(
+      (result, [name, store]) => {
+        result[name] = store.getPlainValue();
+        return result;
+      },
+      {}
+    );
+  }
+  migrateProperty(event) {
+    const rawValue = this.getMigratedValue(event);
+    this.value[event.name] = createJsonValueStore(
+      event.property,
+      this.rowId,
+      rawValue
+    );
+  }
+  addProperty(event) {
+    const rawValue = this.getAddedValue(event);
+    this.value[event.name] = createJsonValueStore(
+      event.property,
+      this.rowId,
+      rawValue
+    );
+  }
+  removeProperty(event) {
+    delete this.value[event.name];
+  }
+  changeName(event) {
+    const itemValue = this.value[event.fromName];
+    if (itemValue !== void 0) {
+      delete this.value[event.fromName];
+      this.value[event.toName] = itemValue;
+    }
+  }
+  getAddedValue(event) {
+    const previousValue = event.property.getValue(this.rowId, this.index);
+    if (previousValue) {
+      return previousValue.getPlainValue();
+    }
+    return event.property.default;
+  }
+  getMigratedValue(event) {
+    const transformation = getTransformation(
+      event.previousProperty,
+      event.property
+    );
+    const valueStore = this.value[event.name];
+    if (transformation && valueStore) {
+      return transformation(
+        valueStore.getPlainValue(),
+        event.property.default
+      );
+    }
+    return event.property.default;
+  }
+  init() {
+    for (const value of Object.values(this.value)) {
+      value.parent = this;
+    }
+  }
+};
+
+// src/model/value/json-string-value.store.ts
+var JsonStringValueStore = class {
+  constructor(schema, rowId, value = null) {
+    this.schema = schema;
+    this.rowId = rowId;
+    this.value = value;
+    this.index = this.schema.registerValue(this);
+  }
+  type = "string" /* String */;
+  index;
+  parent = null;
+  get foreignKey() {
+    return this.schema.foreignKey;
+  }
+  getPlainValue() {
+    return this.value ?? this.schema.default;
+  }
+};
+
+// src/lib/createJsonValueStore.ts
+var createJsonValueStore = (schema, rowId, rawValue) => {
+  if (schema.type === "object" /* Object */) {
+    return createJsonObjectValueStore(schema, rowId, rawValue);
+  } else if (schema.type === "array" /* Array */) {
+    return createJsonArrayValueStore(schema, rowId, rawValue);
+  } else {
+    return createPrimitiveValueStore(schema, rowId, rawValue);
+  }
+};
+var createJsonObjectValueStore = (schema, rowId, rawValue) => {
+  const value = Object.entries(rawValue).reduce(
+    (reduceValue, [key, itemValue]) => {
+      const itemSchema = schema.getProperty(key);
+      if (itemSchema === void 0 || itemValue === void 0) {
+        throw new Error("Invalid item");
+      }
+      reduceValue[key] = createJsonValueStore(itemSchema, rowId, itemValue);
+      return reduceValue;
+    },
+    {}
+  );
+  return new JsonObjectValueStore(schema, rowId, value);
+};
+var createJsonArrayValueStore = (schema, rowId, rawValue) => {
+  const value = rawValue.map(
+    (value2) => createJsonValueStore(schema.items, rowId, value2)
+  );
+  return new JsonArrayValueStore(schema, rowId, value);
+};
+var createPrimitiveValueStore = (schema, rowId, rawValue) => {
+  if (schema.type === "string" /* String */) {
+    return new JsonStringValueStore(schema, rowId, rawValue);
+  } else if (schema.type === "number" /* Number */) {
+    return new JsonNumberValueStore(schema, rowId, rawValue);
+  } else if (schema.type === "boolean" /* Boolean */) {
+    return new JsonBooleanValueStore(schema, rowId, rawValue);
+  } else {
+    throw new Error("this type is not allowed");
+  }
+};
+
+// src/lib/getDBJsonPathByJsonSchemaStore.ts
+var getDBJsonPathByJsonSchemaStore = (store) => {
+  let node = store;
+  let path = "";
+  while (node.parent) {
+    if (node.parent.type === "object" /* Object */) {
+      path = `.${node.name}${path}`;
+    } else if (node.parent.type === "array" /* Array */) {
+      path = `[*]${path}`;
+    }
+    node = node.parent;
+  }
+  if (!path) {
+    return "$";
+  }
+  return `$${path}`;
+};
+
+// src/lib/getPathByStore.ts
+var getPathByStore = (store) => {
+  let node = store;
+  let path = "";
+  while (node.parent) {
+    if (node.parent.type === "object" /* Object */) {
+      path = `/properties/${node.name}${path}`;
+    } else if (node.parent.type === "array" /* Array */) {
+      path = `/items${path}`;
+    }
+    node = node.parent;
+  }
+  if (!path) {
+    return "/";
+  }
+  return `${path}`;
+};
+
+// src/lib/traverseStore.ts
+var traverseStore = (store, callback) => {
+  callback(store);
+  if (store.type === "object" /* Object */) {
+    Object.values(store.properties).forEach((item) => {
+      traverseStore(item, callback);
+    });
+  } else if (store.type === "array" /* Array */) {
+    traverseStore(store.items, callback);
+  }
+};
+
+// src/lib/getForeignKeyPatchesFromSchema.ts
+var getForeignKeyPatchesFromSchema = (store, options) => {
+  const stores = [];
+  traverseStore(store, (item) => {
+    if (item.type === "string" /* String */ && item.foreignKey === options.tableId) {
+      item.foreignKey = options.nextTableId;
+      const patch = {
+        op: "replace",
+        path: getPathByStore(item),
+        value: item.getPlainSchema()
+      };
+      stores.push(patch);
+    }
+  });
+  return stores;
+};
+
+// src/lib/getForeignKeysFromSchema.ts
+var getForeignKeysFromSchema = (store) => {
+  const foreignKeys = /* @__PURE__ */ new Set();
+  traverseStore(store, (item) => {
+    if (item.type === "string" /* String */ && item.foreignKey) {
+      foreignKeys.add(item.foreignKey);
+    }
+  });
+  return [...foreignKeys].sort((a, b) => a.localeCompare(b));
+};
+
+// src/lib/traverseValue.ts
+var traverseValue = (store, callback) => {
+  callback(store);
+  if (store.type === "object" /* Object */) {
+    Object.values(store.value).forEach((item) => {
+      traverseValue(item, callback);
+    });
+  } else if (store.type === "array" /* Array */) {
+    store.value.forEach((itemValue) => {
+      traverseValue(itemValue, callback);
+    });
+  }
+};
+
+// src/lib/getForeignKeysFromValue.ts
+var getForeignKeysFromValue = (value) => {
+  const foreignKeys = /* @__PURE__ */ new Map();
+  traverseValue(value, (item) => {
+    if (item.type === "string" /* String */ && item.foreignKey) {
+      let tableForeignKey = foreignKeys.get(item.foreignKey);
+      if (!tableForeignKey) {
+        tableForeignKey = /* @__PURE__ */ new Set();
+        foreignKeys.set(item.foreignKey, tableForeignKey);
+      }
+      tableForeignKey.add(item.getPlainValue());
+    }
+  });
+  return [...foreignKeys].map(([tableId, rowIds]) => ({
+    tableId,
+    rowIds: [...rowIds].sort((a, b) => a.localeCompare(b))
+  }));
+};
+
+// src/lib/getInvalidFieldNamesInSchema.ts
+var getInvalidFieldNamesInSchema = (schema, refs = {}) => {
+  const schemaStore = createJsonSchemaStore(schema, refs);
+  const invalidFields = [];
+  traverseStore(schemaStore, (item) => {
+    if (item.parent?.type === "object" /* Object */) {
+      if (!validateJsonFieldName(item.name)) {
+        invalidFields.push(item);
+      }
+    }
+  });
+  return invalidFields;
+};
+
+// src/lib/getJsonValueByPath.ts
+var getJsonValueStoreByPath = (root, path) => {
+  if (!path) {
+    return root;
+  }
+  const segments = getSegments(path);
+  let current = root;
+  for (const seg of segments) {
+    if (current instanceof JsonObjectValueStore) {
+      const next = current.value[String(seg)];
+      if (!next) {
+        throw new Error(`Path not found at segment "${seg}"`);
+      }
+      current = next;
+    } else if (current instanceof JsonArrayValueStore) {
+      if (typeof seg !== "number") {
+        throw new Error(`Invalid array index "${seg}"`);
+      }
+      const next = current.value[seg];
+      if (!next) {
+        throw new Error(`Path not found at segment "${seg}"`);
+      }
+      current = next;
+    } else {
+      throw new Error(`Cannot navigate into primitive at segment "${seg}"`);
+    }
+  }
+  return current;
+};
+var regex = /([^.[\]]+)|\[(\d+)]/g;
+var getSegments = (path) => {
+  const segments = [];
+  let match;
+  while (match = regex.exec(path)) {
+    if (match[1] !== void 0) {
+      segments.push(match[1]);
+    } else if (match[2] !== void 0) {
+      segments.push(Number(match[2]));
+    }
+  }
+  return segments;
+};
+
+// src/lib/replaceForeignKeyValue.ts
+var replaceForeignKeyValue = (options) => {
+  let wasUpdated = false;
+  traverseValue(options.valueStore, (item) => {
+    if (item.type === "string" /* String */ && item.foreignKey === options.foreignKey && item.value === options.value) {
+      item.value = options.nextValue;
+      wasUpdated = true;
+    }
+  });
+  return wasUpdated;
+};
+
+// src/plugins/row-id.schema.ts
+var rowIdSchema = {
+  type: "string" /* String */,
+  default: "",
+  readOnly: true
+};
+
+// src/plugins/row-version-id.schema.ts
+var rowVersionIdSchema = {
+  type: "string" /* String */,
+  default: "",
+  readOnly: true
+};
+
+// src/plugins/row-created-id.schema.ts
+var rowCreatedIdSchema = {
+  type: "string" /* String */,
+  default: "",
+  readOnly: true
+};
+
+// src/plugins/row-created-at.schema.ts
+var rowCreatedAtSchema = {
+  type: "string" /* String */,
+  default: "",
+  readOnly: true
+};
+
+// src/plugins/row-published-at.schema.ts
+var rowPublishedAtSchema = {
+  type: "string" /* String */,
+  default: ""
+};
+
+// src/plugins/row-updated-at.schema.ts
+var rowUpdatedAtSchema = {
+  type: "string" /* String */,
+  default: "",
+  readOnly: true
+};
+
+// src/plugins/row-hash.schema.ts
+var rowHashSchema = {
+  type: "string" /* String */,
+  default: "",
+  readOnly: true
+};
+
+// src/plugins/row-schema-hash.schema.ts
+var rowSchemaHashSchema = {
+  type: "string" /* String */,
+  default: "",
+  readOnly: true
+};
+
+// src/plugins/file-schema.ts
+var fileSchema = {
+  type: "object" /* Object */,
+  properties: {
+    status: { type: "string" /* String */, default: "", readOnly: true },
+    fileId: { type: "string" /* String */, default: "", readOnly: true },
+    url: { type: "string" /* String */, default: "", readOnly: true },
+    fileName: { type: "string" /* String */, default: "" },
+    hash: {
+      type: "string" /* String */,
+      default: "",
+      readOnly: true
+    },
+    extension: {
+      type: "string" /* String */,
+      default: "",
+      readOnly: true
+    },
+    mimeType: {
+      type: "string" /* String */,
+      default: "",
+      readOnly: true
+    },
+    size: {
+      type: "number" /* Number */,
+      default: 0,
+      readOnly: true
+    },
+    width: {
+      type: "number" /* Number */,
+      default: 0,
+      readOnly: true
+    },
+    height: {
+      type: "number" /* Number */,
+      default: 0,
+      readOnly: true
+    }
+  },
+  required: [
+    "status",
+    "fileId",
+    "url",
+    "fileName",
+    "hash",
+    "extension",
+    "mimeType",
+    "size",
+    "width",
+    "height"
+  ],
+  additionalProperties: false
+};
+
+// src/lib/resolveRefs.ts
+var pluginRefs = {
+  ["urn:jsonschema:io:revisium:row-id-schema:1.0.0" /* RowId */]: rowIdSchema,
+  ["urn:jsonschema:io:revisium:row-version-id-schema:1.0.0" /* RowVersionId */]: rowVersionIdSchema,
+  ["urn:jsonschema:io:revisium:row-created-id-schema:1.0.0" /* RowCreatedId */]: rowCreatedIdSchema,
+  ["urn:jsonschema:io:revisium:row-created-at-schema:1.0.0" /* RowCreatedAt */]: rowCreatedAtSchema,
+  ["urn:jsonschema:io:revisium:row-published-at-schema:1.0.0" /* RowPublishedAt */]: rowPublishedAtSchema,
+  ["urn:jsonschema:io:revisium:row-updated-at-schema:1.0.0" /* RowUpdatedAt */]: rowUpdatedAtSchema,
+  ["urn:jsonschema:io:revisium:row-hash-schema:1.0.0" /* RowHash */]: rowHashSchema,
+  ["urn:jsonschema:io:revisium:row-schema-hash-schema:1.0.0" /* RowSchemaHash */]: rowSchemaHashSchema,
+  ["urn:jsonschema:io:revisium:file-schema:1.0.0" /* File */]: fileSchema
+};
+var resolveRefs = (schema) => {
+  const store = createJsonSchemaStore(schema, pluginRefs);
+  return store.getPlainSchema({ skip$Ref: true });
+};
+
+// src/lib/schema-table.ts
+var SchemaTable = class {
+  constructor(schema, refs = {}) {
+    this.refs = refs;
+    this.store = createJsonSchemaStore(schema, refs);
+  }
+  rows = /* @__PURE__ */ new Map();
+  store;
+  applyPatches(patches) {
+    patches.forEach((patch) => {
+      switch (patch.op) {
+        case "replace": {
+          const nextStore = applyReplacePatch(this.store, patch, this.refs);
+          if (nextStore !== this.store) {
+            this.migrateRows(nextStore);
+          }
+          break;
+        }
+        case "remove": {
+          applyRemovePatch(this.store, patch);
+          break;
+        }
+        case "add": {
+          applyAddPatch(this.store, patch, this.refs);
+          break;
+        }
+        case "move": {
+          applyMovePatch(this.store, patch);
+          break;
+        }
+        default:
+          throw new Error(`Unsupported patch operation`);
+      }
+    });
+  }
+  getSchema() {
+    return this.store.getPlainSchema();
+  }
+  addRow(rowId, data) {
+    const row = createJsonValueStore(this.store, rowId, data);
+    this.rows.set(rowId, row);
+  }
+  getRow(id) {
+    const row = this.rows.get(id);
+    if (!row) {
+      throw new Error("Invalid id");
+    }
+    return row.getPlainValue();
+  }
+  getRows() {
+    return [...this.rows].map(([id, data]) => ({
+      id,
+      data: data.getPlainValue()
+    }));
+  }
+  migrateRows(nextStore) {
+    const transformation = getTransformation(this.store, nextStore);
+    if (transformation) {
+      for (const [rowId, row] of this.rows) {
+        const rawNextValue = transformation(
+          row.getPlainValue(),
+          nextStore.default
+        );
+        const nextRow = createJsonValueStore(nextStore, rowId, rawNextValue);
+        this.rows.set(rowId, nextRow);
+      }
+    }
+    this.store = nextStore;
+  }
+};
+
+exports.SchemaTable = SchemaTable;
+exports.VALIDATE_JSON_FIELD_NAME_ERROR_MESSAGE = VALIDATE_JSON_FIELD_NAME_ERROR_MESSAGE;
+exports.addSharedFieldsFromState = addSharedFieldsFromState;
+exports.applyAddPatch = applyAddPatch;
+exports.applyMovePatch = applyMovePatch;
+exports.applyRemovePatch = applyRemovePatch;
+exports.applyReplacePatch = applyReplacePatch;
+exports.createJsonArrayValueStore = createJsonArrayValueStore;
+exports.createJsonObjectSchemaStore = createJsonObjectSchemaStore;
+exports.createJsonObjectValueStore = createJsonObjectValueStore;
+exports.createJsonSchemaStore = createJsonSchemaStore;
+exports.createJsonValueStore = createJsonValueStore;
+exports.createPrimitiveStoreBySchema = createPrimitiveStoreBySchema;
+exports.createPrimitiveValueStore = createPrimitiveValueStore;
+exports.getDBJsonPathByJsonSchemaStore = getDBJsonPathByJsonSchemaStore;
+exports.getForeignKeyPatchesFromSchema = getForeignKeyPatchesFromSchema;
+exports.getForeignKeysFromSchema = getForeignKeysFromSchema;
+exports.getForeignKeysFromValue = getForeignKeysFromValue;
+exports.getInvalidFieldNamesInSchema = getInvalidFieldNamesInSchema;
+exports.getJsonSchemaStoreByPath = getJsonSchemaStoreByPath;
+exports.getJsonValueStoreByPath = getJsonValueStoreByPath;
+exports.getParentForPath = getParentForPath;
+exports.getPathByStore = getPathByStore;
+exports.pluginRefs = pluginRefs;
+exports.replaceForeignKeyValue = replaceForeignKeyValue;
+exports.resolveRefs = resolveRefs;
+exports.saveSharedFields = saveSharedFields;
+exports.traverseStore = traverseStore;
+exports.traverseValue = traverseValue;
+exports.validateJsonFieldName = validateJsonFieldName;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map