@revisium/schema-toolkit 0.2.0

package/dist/index.cjs

@@ -0,0 +1,1874 @@
+'use strict';
+
+var nanoid = require('nanoid');
+var events = require('events');
+
+// src/types/schema.types.ts
+var JsonSchemaTypeName = /* @__PURE__ */ ((JsonSchemaTypeName2) => {
+  JsonSchemaTypeName2["String"] = "string";
+  JsonSchemaTypeName2["Number"] = "number";
+  JsonSchemaTypeName2["Boolean"] = "boolean";
+  JsonSchemaTypeName2["Object"] = "object";
+  JsonSchemaTypeName2["Array"] = "array";
+  return JsonSchemaTypeName2;
+})(JsonSchemaTypeName || {});
+
+// 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/mocks/schema.mocks.ts
+var getReplacePatch = ({
+  path,
+  value
+}) => ({
+  op: "replace",
+  path,
+  value
+});
+var getRemovePatch = ({
+  path
+}) => ({
+  op: "remove",
+  path
+});
+var getAddPatch = ({
+  path,
+  value
+}) => ({
+  op: "add",
+  path,
+  value
+});
+var getMovePatch = ({
+  from,
+  path
+}) => ({
+  op: "move",
+  from,
+  path
+});
+var getStringSchema = (params = {}) => {
+  const schema = {
+    type: "string" /* String */,
+    default: params.default ?? ""
+  };
+  if (params.foreignKey) {
+    schema.foreignKey = params.foreignKey;
+  }
+  if (params.readOnly) {
+    schema.readOnly = params.readOnly;
+  }
+  return schema;
+};
+var getNumberSchema = (defaultValue = 0, readOnly) => {
+  const schema = {
+    type: "number" /* Number */,
+    default: defaultValue
+  };
+  if (readOnly) {
+    schema.readOnly = readOnly;
+  }
+  return schema;
+};
+var getBooleanSchema = (defaultValue = false, readOnly) => {
+  const schema = {
+    type: "boolean" /* Boolean */,
+    default: defaultValue
+  };
+  if (readOnly) {
+    schema.readOnly = readOnly;
+  }
+  return schema;
+};
+var getObjectSchema = (properties) => ({
+  type: "object" /* Object */,
+  additionalProperties: false,
+  required: Object.keys(properties).sort((a, b) => a.localeCompare(b)),
+  properties
+});
+var getArraySchema = (items) => ({
+  type: "array" /* Array */,
+  items
+});
+var getRefSchema = ($ref) => ({
+  $ref
+});
+
+// src/consts/system-schema-ids.ts
+var SystemSchemaIds = /* @__PURE__ */ ((SystemSchemaIds2) => {
+  SystemSchemaIds2["RowId"] = "urn:jsonschema:io:revisium:row-id-schema:1.0.0";
+  SystemSchemaIds2["RowCreatedId"] = "urn:jsonschema:io:revisium:row-created-id-schema:1.0.0";
+  SystemSchemaIds2["RowVersionId"] = "urn:jsonschema:io:revisium:row-version-id-schema:1.0.0";
+  SystemSchemaIds2["RowCreatedAt"] = "urn:jsonschema:io:revisium:row-created-at-schema:1.0.0";
+  SystemSchemaIds2["RowPublishedAt"] = "urn:jsonschema:io:revisium:row-published-at-schema:1.0.0";
+  SystemSchemaIds2["RowUpdatedAt"] = "urn:jsonschema:io:revisium:row-updated-at-schema:1.0.0";
+  SystemSchemaIds2["RowHash"] = "urn:jsonschema:io:revisium:row-hash-schema:1.0.0";
+  SystemSchemaIds2["RowSchemaHash"] = "urn:jsonschema:io:revisium:row-schema-hash-schema:1.0.0";
+  SystemSchemaIds2["File"] = "urn:jsonschema:io:revisium:file-schema:1.0.0";
+  return SystemSchemaIds2;
+})(SystemSchemaIds || {});
+
+// src/consts/index.ts
+var CustomSchemeKeywords = /* @__PURE__ */ ((CustomSchemeKeywords2) => {
+  CustomSchemeKeywords2["ForeignKey"] = "foreignKey";
+  return CustomSchemeKeywords2;
+})(CustomSchemeKeywords || {});
+
+// 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;
+};
+
+// src/model/schema/json-string.store.ts
+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 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 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 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;
+      }
+    }
+  }
+};
+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;
+      }
+    }
+  }
+};
+
+// 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/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-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/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/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/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/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/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/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;
+  }
+};
+
+// src/validation-schemas/shared-fields.ts
+var sharedFields = {
+  deprecated: {
+    type: "boolean"
+  },
+  title: {
+    type: "string"
+  },
+  description: {
+    type: "string"
+  }
+};
+
+// src/validation-schemas/meta-schema.ts
+var refMetaSchema = {
+  type: "object",
+  properties: {
+    ...sharedFields,
+    $ref: {
+      type: "string"
+    }
+  },
+  additionalProperties: false,
+  required: ["$ref"]
+};
+var baseStringFields = {
+  type: {
+    const: "string"
+  },
+  default: {
+    type: "string"
+  },
+  readOnly: {
+    type: "boolean"
+  },
+  pattern: {
+    type: "string",
+    format: "regex"
+  },
+  enum: {
+    type: "array",
+    items: { type: "string" },
+    minItems: 1,
+    uniqueItems: true
+  },
+  format: {
+    type: "string",
+    enum: ["date-time", "date", "time", "email", "regex"]
+  },
+  contentMediaType: {
+    type: "string",
+    enum: [
+      "text/plain",
+      "text/markdown",
+      "text/html",
+      "application/json",
+      "application/schema+json",
+      "application/yaml"
+    ]
+  },
+  ...sharedFields
+};
+var stringMetaSchema = {
+  type: "object",
+  properties: {
+    ...baseStringFields,
+    foreignKey: {
+      type: "string"
+    }
+  },
+  additionalProperties: false,
+  required: ["type", "default"]
+};
+var noForeignKeyStringMetaSchema = {
+  type: "object",
+  properties: {
+    ...baseStringFields
+  },
+  additionalProperties: false,
+  required: ["type", "default"]
+};
+var numberMetaSchema = {
+  type: "object",
+  properties: {
+    type: {
+      const: "number"
+    },
+    default: {
+      type: "number"
+    },
+    readOnly: {
+      type: "boolean"
+    },
+    ...sharedFields
+  },
+  additionalProperties: false,
+  required: ["type", "default"]
+};
+var booleanMetaSchema = {
+  type: "object",
+  properties: {
+    type: {
+      const: "boolean"
+    },
+    default: {
+      type: "boolean"
+    },
+    readOnly: {
+      type: "boolean"
+    },
+    ...sharedFields
+  },
+  additionalProperties: false,
+  required: ["type", "default"]
+};
+var objectMetaSchema = {
+  type: "object",
+  properties: {
+    type: {
+      const: "object"
+    },
+    ...sharedFields,
+    properties: {
+      type: "object",
+      additionalProperties: { $dynamicRef: "#meta" },
+      default: {}
+    },
+    additionalProperties: { const: false },
+    required: { $ref: "#/$defs/stringArray" }
+  },
+  additionalProperties: false,
+  required: ["type", "properties", "additionalProperties", "required"]
+};
+var arrayMetaSchema = {
+  type: "object",
+  properties: {
+    type: {
+      const: "array"
+    },
+    ...sharedFields,
+    items: {
+      oneOf: [
+        { $ref: "#/$defs/refSchema" },
+        { $ref: "#/$defs/objectSchema" },
+        { $ref: "#/$defs/arraySchema" },
+        { $ref: "#/$defs/stringSchema" },
+        { $ref: "#/$defs/numberSchema" },
+        { $ref: "#/$defs/booleanSchema" }
+      ]
+    }
+  },
+  additionalProperties: false,
+  required: ["type", "items"]
+};
+var metaSchema = {
+  $id: "meta-schema.json",
+  type: "object",
+  $dynamicAnchor: "meta",
+  oneOf: [
+    { $ref: "#/$defs/refSchema" },
+    { $ref: "#/$defs/objectSchema" },
+    { $ref: "#/$defs/arraySchema" },
+    { $ref: "#/$defs/stringSchema" },
+    { $ref: "#/$defs/numberSchema" },
+    { $ref: "#/$defs/booleanSchema" }
+  ],
+  $defs: {
+    stringArray: {
+      type: "array",
+      items: { type: "string" },
+      uniqueItems: true,
+      default: []
+    },
+    refSchema: refMetaSchema,
+    objectSchema: objectMetaSchema,
+    stringSchema: stringMetaSchema,
+    numberSchema: numberMetaSchema,
+    booleanSchema: booleanMetaSchema,
+    arraySchema: arrayMetaSchema
+  }
+};
+var notForeignKeyMetaSchema = {
+  type: "object",
+  $dynamicAnchor: "meta",
+  oneOf: [
+    { $ref: "#/$defs/refSchema" },
+    { $ref: "#/$defs/objectSchema" },
+    { $ref: "#/$defs/arraySchema" },
+    { $ref: "#/$defs/stringSchema" },
+    { $ref: "#/$defs/numberSchema" },
+    { $ref: "#/$defs/booleanSchema" }
+  ],
+  $defs: {
+    stringArray: {
+      type: "array",
+      items: { type: "string" },
+      uniqueItems: true,
+      default: []
+    },
+    refSchema: refMetaSchema,
+    objectSchema: objectMetaSchema,
+    stringSchema: noForeignKeyStringMetaSchema,
+    numberSchema: numberMetaSchema,
+    booleanSchema: booleanMetaSchema,
+    arraySchema: arrayMetaSchema
+  }
+};
+
+// src/validation-schemas/json-patch-schema.ts
+var jsonPatchSchema = {
+  $id: "json-patch-schema.json",
+  definitions: {
+    path: {
+      description: "A JSON Pointer path.",
+      type: "string"
+    },
+    objectSchema: objectMetaSchema,
+    stringSchema: stringMetaSchema,
+    numberSchema: numberMetaSchema,
+    booleanSchema: booleanMetaSchema,
+    arraySchema: arrayMetaSchema
+  },
+  minItems: 1,
+  items: {
+    oneOf: [
+      {
+        type: "object",
+        additionalProperties: false,
+        required: ["value", "op", "path"],
+        properties: {
+          path: {
+            $ref: "#/definitions/path"
+          },
+          op: {
+            description: "The operation to perform.",
+            type: "string",
+            enum: ["add", "replace"]
+          },
+          value: {
+            $ref: "meta-schema.json",
+            description: "The value to add, replace or test."
+          }
+        }
+      },
+      {
+        type: "object",
+        additionalProperties: false,
+        required: ["op", "path"],
+        properties: {
+          path: {
+            $ref: "#/definitions/path"
+          },
+          op: {
+            description: "The operation to perform.",
+            type: "string",
+            enum: ["remove"]
+          }
+        }
+      },
+      {
+        type: "object",
+        additionalProperties: false,
+        required: ["from", "op", "path"],
+        properties: {
+          path: {
+            $ref: "#/definitions/path"
+          },
+          op: {
+            description: "The operation to perform.",
+            type: "string",
+            enum: ["move", "copy"]
+          },
+          from: {
+            $ref: "#/definitions/path",
+            description: "A JSON Pointer path pointing to the location to move/copy from."
+          }
+        }
+      }
+    ]
+  },
+  title: "JSON schema for JSONPatch files",
+  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",
+  oneOf: [
+    { $ref: "#/definitions/InitMigration" },
+    { $ref: "#/definitions/UpdateMigration" },
+    { $ref: "#/definitions/RenameMigration" },
+    { $ref: "#/definitions/RemoveMigration" }
+  ],
+  definitions: {
+    InitMigration: {
+      type: "object",
+      additionalProperties: false,
+      required: ["changeType", "tableId", "hash", "id", "schema"],
+      properties: {
+        changeType: { type: "string", const: "init" },
+        tableId: { type: "string" },
+        hash: { type: "string" },
+        id: { type: "string" },
+        schema: { $ref: "meta-schema.json" }
+      }
+    },
+    UpdateMigration: {
+      type: "object",
+      additionalProperties: false,
+      required: ["changeType", "tableId", "hash", "id", "patches"],
+      properties: {
+        changeType: { type: "string", const: "update" },
+        tableId: { type: "string" },
+        hash: { type: "string" },
+        id: { type: "string" },
+        patches: { $ref: "json-patch-schema.json" }
+      }
+    },
+    RenameMigration: {
+      type: "object",
+      additionalProperties: false,
+      required: ["changeType", "id", "tableId", "nextTableId"],
+      properties: {
+        changeType: { type: "string", const: "rename" },
+        id: { type: "string" },
+        tableId: { type: "string" },
+        nextTableId: { type: "string" }
+      }
+    },
+    RemoveMigration: {
+      type: "object",
+      additionalProperties: false,
+      required: ["changeType", "id", "tableId"],
+      properties: {
+        changeType: { type: "string", const: "remove" },
+        id: { type: "string" },
+        tableId: { type: "string" }
+      }
+    }
+  },
+  title: "JSON Schema for a Single Migration"
+};
+
+exports.CustomSchemeKeywords = CustomSchemeKeywords;
+exports.JsonArrayStore = JsonArrayStore;
+exports.JsonArrayValueStore = JsonArrayValueStore;
+exports.JsonBooleanStore = JsonBooleanStore;
+exports.JsonBooleanValueStore = JsonBooleanValueStore;
+exports.JsonNumberStore = JsonNumberStore;
+exports.JsonNumberValueStore = JsonNumberValueStore;
+exports.JsonObjectStore = JsonObjectStore;
+exports.JsonObjectValueStore = JsonObjectValueStore;
+exports.JsonSchemaTypeName = JsonSchemaTypeName;
+exports.JsonStringStore = JsonStringStore;
+exports.JsonStringValueStore = JsonStringValueStore;
+exports.SchemaTable = SchemaTable;
+exports.SystemSchemaIds = SystemSchemaIds;
+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.arrayMetaSchema = arrayMetaSchema;
+exports.baseStringFields = baseStringFields;
+exports.booleanMetaSchema = booleanMetaSchema;
+exports.createJsonArrayValueStore = createJsonArrayValueStore;
+exports.createJsonObjectSchemaStore = createJsonObjectSchemaStore;
+exports.createJsonObjectValueStore = createJsonObjectValueStore;
+exports.createJsonSchemaStore = createJsonSchemaStore;
+exports.createJsonValueStore = createJsonValueStore;
+exports.createPrimitiveStoreBySchema = createPrimitiveStoreBySchema;
+exports.createPrimitiveValueStore = createPrimitiveValueStore;
+exports.equel = equel;
+exports.fileSchema = fileSchema;
+exports.fromArrayTransformation = fromArrayTransformation;
+exports.fromBooleanToNumber = fromBooleanToNumber;
+exports.fromBooleanToString = fromBooleanToString;
+exports.fromNumberToBoolean = fromNumberToBoolean;
+exports.fromNumberToString = fromNumberToString;
+exports.fromStringToBoolean = fromStringToBoolean;
+exports.fromStringToNumber = fromStringToNumber;
+exports.getAddPatch = getAddPatch;
+exports.getArraySchema = getArraySchema;
+exports.getBooleanSchema = getBooleanSchema;
+exports.getDBJsonPathByJsonSchemaStore = getDBJsonPathByJsonSchemaStore;
+exports.getForeignKeyPatchesFromSchema = getForeignKeyPatchesFromSchema;
+exports.getForeignKeysFromSchema = getForeignKeysFromSchema;
+exports.getForeignKeysFromValue = getForeignKeysFromValue;
+exports.getInvalidFieldNamesInSchema = getInvalidFieldNamesInSchema;
+exports.getJsonSchemaStoreByPath = getJsonSchemaStoreByPath;
+exports.getJsonValueStoreByPath = getJsonValueStoreByPath;
+exports.getMovePatch = getMovePatch;
+exports.getNumberSchema = getNumberSchema;
+exports.getObjectSchema = getObjectSchema;
+exports.getParentForPath = getParentForPath;
+exports.getPathByStore = getPathByStore;
+exports.getRefSchema = getRefSchema;
+exports.getRemovePatch = getRemovePatch;
+exports.getReplacePatch = getReplacePatch;
+exports.getStringSchema = getStringSchema;
+exports.getTransformation = getTransformation;
+exports.historyPatchesSchema = historyPatchesSchema;
+exports.jsonPatchSchema = jsonPatchSchema;
+exports.metaSchema = metaSchema;
+exports.noForeignKeyStringMetaSchema = noForeignKeyStringMetaSchema;
+exports.notForeignKeyMetaSchema = notForeignKeyMetaSchema;
+exports.numberMetaSchema = numberMetaSchema;
+exports.objectMetaSchema = objectMetaSchema;
+exports.pluginRefs = pluginRefs;
+exports.refMetaSchema = refMetaSchema;
+exports.replaceForeignKeyValue = replaceForeignKeyValue;
+exports.resolveRefs = resolveRefs;
+exports.rowCreatedAtSchema = rowCreatedAtSchema;
+exports.rowCreatedIdSchema = rowCreatedIdSchema;
+exports.rowHashSchema = rowHashSchema;
+exports.rowIdSchema = rowIdSchema;
+exports.rowPublishedAtSchema = rowPublishedAtSchema;
+exports.rowSchemaHashSchema = rowSchemaHashSchema;
+exports.rowUpdatedAtSchema = rowUpdatedAtSchema;
+exports.rowVersionIdSchema = rowVersionIdSchema;
+exports.saveSharedFields = saveSharedFields;
+exports.sharedFields = sharedFields;
+exports.stringMetaSchema = stringMetaSchema;
+exports.tableMigrationsSchema = tableMigrationsSchema;
+exports.toArrayTransformation = toArrayTransformation;
+exports.traverseStore = traverseStore;
+exports.traverseValue = traverseValue;
+exports.validateJsonFieldName = validateJsonFieldName;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map