@revisium/schema-toolkit 0.2.0 → 0.2.2

package/dist/chunk-22K22MMD.js

@@ -0,0 +1,112 @@
+// 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
+};
+
+export { fileSchema, rowCreatedAtSchema, rowCreatedIdSchema, rowHashSchema, rowIdSchema, rowPublishedAtSchema, rowSchemaHashSchema, rowUpdatedAtSchema, rowVersionIdSchema };
+//# sourceMappingURL=chunk-22K22MMD.js.map
+//# sourceMappingURL=chunk-22K22MMD.js.map

package/dist/chunk-22K22MMD.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/plugins/row-id.schema.ts","../src/plugins/row-version-id.schema.ts","../src/plugins/row-created-id.schema.ts","../src/plugins/row-created-at.schema.ts","../src/plugins/row-published-at.schema.ts","../src/plugins/row-updated-at.schema.ts","../src/plugins/row-hash.schema.ts","../src/plugins/row-schema-hash.schema.ts","../src/plugins/file-schema.ts"],"names":[],"mappings":";AAEO,IAAM,WAAA,GAAgC;AAAA,EAC3C,IAAA,EAAA,QAAA;AAAA,EACA,OAAA,EAAS,EAAA;AAAA,EACT,QAAA,EAAU;AACZ;;;ACJO,IAAM,kBAAA,GAAuC;AAAA,EAClD,IAAA,EAAA,QAAA;AAAA,EACA,OAAA,EAAS,EAAA;AAAA,EACT,QAAA,EAAU;AACZ;;;ACJO,IAAM,kBAAA,GAAuC;AAAA,EAClD,IAAA,EAAA,QAAA;AAAA,EACA,OAAA,EAAS,EAAA;AAAA,EACT,QAAA,EAAU;AACZ;;;ACJO,IAAM,kBAAA,GAAuC;AAAA,EAClD,IAAA,EAAA,QAAA;AAAA,EACA,OAAA,EAAS,EAAA;AAAA,EACT,QAAA,EAAU;AACZ;;;ACJO,IAAM,oBAAA,GAAyC;AAAA,EACpD,IAAA,EAAA,QAAA;AAAA,EACA,OAAA,EAAS;AACX;;;ACHO,IAAM,kBAAA,GAAuC;AAAA,EAClD,IAAA,EAAA,QAAA;AAAA,EACA,OAAA,EAAS,EAAA;AAAA,EACT,QAAA,EAAU;AACZ;;;ACJO,IAAM,aAAA,GAAkC;AAAA,EAC7C,IAAA,EAAA,QAAA;AAAA,EACA,OAAA,EAAS,EAAA;AAAA,EACT,QAAA,EAAU;AACZ;;;ACJO,IAAM,mBAAA,GAAwC;AAAA,EACnD,IAAA,EAAA,QAAA;AAAA,EACA,OAAA,EAAS,EAAA;AAAA,EACT,QAAA,EAAU;AACZ;;;ACJO,IAAM,UAAA,GAA+B;AAAA,EAC1C,IAAA,EAAA,QAAA;AAAA,EACA,UAAA,EAAY;AAAA,IACV,QAAQ,EAAE,IAAA,EAAA,QAAA,eAAiC,OAAA,EAAS,EAAA,EAAI,UAAU,IAAA,EAAK;AAAA,IACvE,QAAQ,EAAE,IAAA,EAAA,QAAA,eAAiC,OAAA,EAAS,EAAA,EAAI,UAAU,IAAA,EAAK;AAAA,IACvE,KAAK,EAAE,IAAA,EAAA,QAAA,eAAiC,OAAA,EAAS,EAAA,EAAI,UAAU,IAAA,EAAK;AAAA,IACpE,QAAA,EAAU,EAAE,IAAA,EAAA,QAAA,eAAiC,OAAA,EAAS,EAAA,EAAG;AAAA,IACzD,IAAA,EAAM;AAAA,MACJ,IAAA,EAAA,QAAA;AAAA,MACA,OAAA,EAAS,EAAA;AAAA,MACT,QAAA,EAAU;AAAA,KACZ;AAAA,IACA,SAAA,EAAW;AAAA,MACT,IAAA,EAAA,QAAA;AAAA,MACA,OAAA,EAAS,EAAA;AAAA,MACT,QAAA,EAAU;AAAA,KACZ;AAAA,IACA,QAAA,EAAU;AAAA,MACR,IAAA,EAAA,QAAA;AAAA,MACA,OAAA,EAAS,EAAA;AAAA,MACT,QAAA,EAAU;AAAA,KACZ;AAAA,IACA,IAAA,EAAM;AAAA,MACJ,IAAA,EAAA,QAAA;AAAA,MACA,OAAA,EAAS,CAAA;AAAA,MACT,QAAA,EAAU;AAAA,KACZ;AAAA,IACA,KAAA,EAAO;AAAA,MACL,IAAA,EAAA,QAAA;AAAA,MACA,OAAA,EAAS,CAAA;AAAA,MACT,QAAA,EAAU;AAAA,KACZ;AAAA,IACA,MAAA,EAAQ;AAAA,MACN,IAAA,EAAA,QAAA;AAAA,MACA,OAAA,EAAS,CAAA;AAAA,MACT,QAAA,EAAU;AAAA;AACZ,GACF;AAAA,EACA,QAAA,EAAU;AAAA,IACR,QAAA;AAAA,IACA,QAAA;AAAA,IACA,KAAA;AAAA,IACA,UAAA;AAAA,IACA,MAAA;AAAA,IACA,WAAA;AAAA,IACA,UAAA;AAAA,IACA,MAAA;AAAA,IACA,OAAA;AAAA,IACA;AAAA,GACF;AAAA,EACA,oBAAA,EAAsB;AACxB","file":"chunk-22K22MMD.js","sourcesContent":["import { JsonStringSchema, JsonSchemaTypeName } from '../types/schema.types.js';\n\nexport const rowIdSchema: JsonStringSchema = {\n  type: JsonSchemaTypeName.String,\n  default: '',\n  readOnly: true,\n};\n","import { JsonStringSchema, JsonSchemaTypeName } from '../types/schema.types.js';\n\nexport const rowVersionIdSchema: JsonStringSchema = {\n  type: JsonSchemaTypeName.String,\n  default: '',\n  readOnly: true,\n};\n","import { JsonStringSchema, JsonSchemaTypeName } from '../types/schema.types.js';\n\nexport const rowCreatedIdSchema: JsonStringSchema = {\n  type: JsonSchemaTypeName.String,\n  default: '',\n  readOnly: true,\n};\n","import { JsonStringSchema, JsonSchemaTypeName } from '../types/schema.types.js';\n\nexport const rowCreatedAtSchema: JsonStringSchema = {\n  type: JsonSchemaTypeName.String,\n  default: '',\n  readOnly: true,\n};\n","import { JsonStringSchema, JsonSchemaTypeName } from '../types/schema.types.js';\n\nexport const rowPublishedAtSchema: JsonStringSchema = {\n  type: JsonSchemaTypeName.String,\n  default: '',\n};\n","import { JsonStringSchema, JsonSchemaTypeName } from '../types/schema.types.js';\n\nexport const rowUpdatedAtSchema: JsonStringSchema = {\n  type: JsonSchemaTypeName.String,\n  default: '',\n  readOnly: true,\n};\n","import { JsonStringSchema, JsonSchemaTypeName } from '../types/schema.types.js';\n\nexport const rowHashSchema: JsonStringSchema = {\n  type: JsonSchemaTypeName.String,\n  default: '',\n  readOnly: true,\n};\n","import { JsonStringSchema, JsonSchemaTypeName } from '../types/schema.types.js';\n\nexport const rowSchemaHashSchema: JsonStringSchema = {\n  type: JsonSchemaTypeName.String,\n  default: '',\n  readOnly: true,\n};\n","import { JsonObjectSchema, JsonSchemaTypeName } from '../types/schema.types.js';\n\nexport const fileSchema: JsonObjectSchema = {\n  type: JsonSchemaTypeName.Object,\n  properties: {\n    status: { type: JsonSchemaTypeName.String, default: '', readOnly: true },\n    fileId: { type: JsonSchemaTypeName.String, default: '', readOnly: true },\n    url: { type: JsonSchemaTypeName.String, default: '', readOnly: true },\n    fileName: { type: JsonSchemaTypeName.String, default: '' },\n    hash: {\n      type: JsonSchemaTypeName.String,\n      default: '',\n      readOnly: true,\n    },\n    extension: {\n      type: JsonSchemaTypeName.String,\n      default: '',\n      readOnly: true,\n    },\n    mimeType: {\n      type: JsonSchemaTypeName.String,\n      default: '',\n      readOnly: true,\n    },\n    size: {\n      type: JsonSchemaTypeName.Number,\n      default: 0,\n      readOnly: true,\n    },\n    width: {\n      type: JsonSchemaTypeName.Number,\n      default: 0,\n      readOnly: true,\n    },\n    height: {\n      type: JsonSchemaTypeName.Number,\n      default: 0,\n      readOnly: true,\n    },\n  },\n  required: [\n    'status',\n    'fileId',\n    'url',\n    'fileName',\n    'hash',\n    'extension',\n    'mimeType',\n    'size',\n    'width',\n    'height',\n  ],\n  additionalProperties: false,\n};\n"]}

package/dist/chunk-2GCG6HJO.cjs

@@ -0,0 +1,545 @@
+'use strict';
+
+var chunk47AQWLHU_cjs = require('./chunk-47AQWLHU.cjs');
+var chunkJLIZ7QT2_cjs = require('./chunk-JLIZ7QT2.cjs');
+
+// 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 chunkJLIZ7QT2_cjs.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 chunkJLIZ7QT2_cjs.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 chunkJLIZ7QT2_cjs.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 chunkJLIZ7QT2_cjs.JsonNumberStore();
+  } else if (schema.type === "boolean" /* Boolean */) {
+    return new chunkJLIZ7QT2_cjs.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 */) {
+    if (foundToParent.getProperty(toField)) {
+      foundToParent.removeProperty(toField);
+    }
+    foundToParent.addPropertyWithStore(toField, foundFromField);
+    foundFromParent.removeProperty(fromField);
+    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 chunkJLIZ7QT2_cjs.JsonObjectValueStore) {
+      const next = current.value[String(seg)];
+      if (!next) {
+        throw new Error(`Path not found at segment "${seg}"`);
+      }
+      current = next;
+    } else if (current instanceof chunkJLIZ7QT2_cjs.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 */]: chunk47AQWLHU_cjs.rowIdSchema,
+  ["urn:jsonschema:io:revisium:row-version-id-schema:1.0.0" /* RowVersionId */]: chunk47AQWLHU_cjs.rowVersionIdSchema,
+  ["urn:jsonschema:io:revisium:row-created-id-schema:1.0.0" /* RowCreatedId */]: chunk47AQWLHU_cjs.rowCreatedIdSchema,
+  ["urn:jsonschema:io:revisium:row-created-at-schema:1.0.0" /* RowCreatedAt */]: chunk47AQWLHU_cjs.rowCreatedAtSchema,
+  ["urn:jsonschema:io:revisium:row-published-at-schema:1.0.0" /* RowPublishedAt */]: chunk47AQWLHU_cjs.rowPublishedAtSchema,
+  ["urn:jsonschema:io:revisium:row-updated-at-schema:1.0.0" /* RowUpdatedAt */]: chunk47AQWLHU_cjs.rowUpdatedAtSchema,
+  ["urn:jsonschema:io:revisium:row-hash-schema:1.0.0" /* RowHash */]: chunk47AQWLHU_cjs.rowHashSchema,
+  ["urn:jsonschema:io:revisium:row-schema-hash-schema:1.0.0" /* RowSchemaHash */]: chunk47AQWLHU_cjs.rowSchemaHashSchema,
+  ["urn:jsonschema:io:revisium:file-schema:1.0.0" /* File */]: chunk47AQWLHU_cjs.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 = chunkJLIZ7QT2_cjs.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 = chunkJLIZ7QT2_cjs.getTransformation(this.store, nextStore);
+    if (transformation) {
+      for (const [rowId, row] of this.rows) {
+        const rawNextValue = transformation(
+          row.getPlainValue(),
+          nextStore.default
+        );
+        const nextRow = chunkJLIZ7QT2_cjs.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.applyAddPatch = applyAddPatch;
+exports.applyMovePatch = applyMovePatch;
+exports.applyRemovePatch = applyRemovePatch;
+exports.applyReplacePatch = applyReplacePatch;
+exports.createJsonObjectSchemaStore = createJsonObjectSchemaStore;
+exports.createJsonSchemaStore = createJsonSchemaStore;
+exports.createPrimitiveStoreBySchema = createPrimitiveStoreBySchema;
+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=chunk-2GCG6HJO.cjs.map
+//# sourceMappingURL=chunk-2GCG6HJO.cjs.map