@revisium/schema-toolkit 0.21.4 → 0.22.0

package/dist/{chunk-QKA7DJDN.cjs → chunk-WY3CL7KH.cjs}

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

package/dist/{chunk-7JWCZZPJ.cjs → chunk-YZEJKK4O.cjs}

@@ -2,6 +2,12 @@
 
 var chunkITYABUR5_cjs = require('./chunk-ITYABUR5.cjs');
 var chunkONW2OVNQ_cjs = require('./chunk-ONW2OVNQ.cjs');
+var chunkWY3CL7KH_cjs = require('./chunk-WY3CL7KH.cjs');
+var Ajv = require('ajv/dist/2020');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var Ajv__default = /*#__PURE__*/_interopDefault(Ajv);
 
 // src/lib/createJsonSchemaStore.ts
 var createJsonSchemaStore = (schema, refs = {}) => {
@@ -731,13 +737,242 @@ var SchemaTable = class {
     this.store = nextStore;
   }
 };
+var mapErrors = (errors) => {
+  if (!errors || errors.length === 0) {
+    return null;
+  }
+  return errors.map((err) => ({
+    instancePath: err.instancePath,
+    message: err.message,
+    keyword: err.keyword,
+    params: err.params
+  }));
+};
+var wrapValidateFn = (ajvFn) => {
+  const fn = ((data) => {
+    const result = ajvFn(data);
+    fn.errors = mapErrors(ajvFn.errors);
+    return result;
+  });
+  fn.errors = null;
+  return fn;
+};
+var RevisiumValidator = class {
+  validateMetaSchema;
+  validateJsonPatch;
+  validateMigrations;
+  validateHistoryPatches;
+  validateTableViews;
+  ajv;
+  cache = /* @__PURE__ */ new Map();
+  constructor() {
+    this.ajv = new Ajv__default.default();
+    this.ajv.addKeyword({
+      keyword: "foreignKey",
+      type: "string"
+    });
+    this.ajv.addKeyword({
+      keyword: "x-formula"
+    });
+    this.ajv.addFormat("regex", {
+      type: "string",
+      validate: (str) => {
+        try {
+          new RegExp(str);
+          return true;
+        } catch {
+          return false;
+        }
+      }
+    });
+    this.ajv.compile(chunkITYABUR5_cjs.ajvRowIdSchema);
+    this.ajv.compile(chunkITYABUR5_cjs.ajvRowCreatedIdSchema);
+    this.ajv.compile(chunkITYABUR5_cjs.ajvRowVersionIdSchema);
+    this.ajv.compile(chunkITYABUR5_cjs.ajvRowCreatedAtSchema);
+    this.ajv.compile(chunkITYABUR5_cjs.ajvRowPublishedAtSchema);
+    this.ajv.compile(chunkITYABUR5_cjs.ajvRowUpdatedAtSchema);
+    this.ajv.compile(chunkITYABUR5_cjs.ajvRowHashSchema);
+    this.ajv.compile(chunkITYABUR5_cjs.ajvRowSchemaHashSchema);
+    this.ajv.compile(chunkITYABUR5_cjs.ajvFileSchema);
+    this.validateMetaSchema = wrapValidateFn(this.ajv.compile(chunkWY3CL7KH_cjs.metaSchema));
+    this.validateJsonPatch = wrapValidateFn(this.ajv.compile(chunkWY3CL7KH_cjs.jsonPatchSchema));
+    this.validateMigrations = wrapValidateFn(
+      this.ajv.compile(chunkWY3CL7KH_cjs.tableMigrationsSchema)
+    );
+    this.validateHistoryPatches = wrapValidateFn(
+      this.ajv.compile(chunkWY3CL7KH_cjs.historyPatchesSchema)
+    );
+    this.validateTableViews = wrapValidateFn(
+      this.ajv.compile(chunkWY3CL7KH_cjs.tableViewsSchema)
+    );
+  }
+  compile(schema) {
+    const key = JSON.stringify(schema);
+    const cached = this.cache.get(key);
+    if (cached) {
+      return cached;
+    }
+    const fn = wrapValidateFn(
+      this.ajv.compile(schema)
+    );
+    this.cache.set(key, fn);
+    return fn;
+  }
+};
+
+// src/lib/validateRevisiumSchema.ts
+var cachedValidator = null;
+var getValidator = () => {
+  if (cachedValidator) {
+    return cachedValidator;
+  }
+  cachedValidator = new RevisiumValidator();
+  return cachedValidator;
+};
+var validateRevisiumSchema = (schema) => {
+  const validator = getValidator();
+  const valid = validator.validateMetaSchema(schema);
+  if (valid) {
+    return { valid: true };
+  }
+  const errors = (validator.validateMetaSchema.errors ?? []).map((err) => {
+    const path = err.instancePath || "/";
+    return `${path}: ${err.message ?? "unknown error"}`;
+  });
+  return { valid: false, errors };
+};
+
+// src/lib/calculateSchemaWeight.ts
+var calculateSchemaWeight = (schema) => {
+  const result = {
+    totalFields: 0,
+    maxDepth: 0,
+    fieldNames: 0,
+    totalArrays: 0,
+    maxArrayDepth: 0
+  };
+  walkSchema(schema, 0, 0, result);
+  return result;
+};
+var walkSchema = (schema, depth, arrayDepth, result) => {
+  if (result.maxDepth < depth) {
+    result.maxDepth = depth;
+  }
+  if ("$ref" in schema) {
+    return;
+  }
+  if (schema.type === "object" && schema.properties) {
+    for (const [fieldName, fieldSchema] of Object.entries(schema.properties)) {
+      result.totalFields++;
+      result.fieldNames += fieldName.length;
+      walkSchema(fieldSchema, depth + 1, arrayDepth, result);
+    }
+  }
+  if (schema.type === "array" && schema.items) {
+    const nextArrayDepth = arrayDepth + 1;
+    result.totalArrays++;
+    if (nextArrayDepth > result.maxArrayDepth) {
+      result.maxArrayDepth = nextArrayDepth;
+    }
+    walkSchema(schema.items, depth + 1, nextArrayDepth, result);
+  }
+};
+
+// src/lib/calculateDataWeight.ts
+var calculateDataWeight = (data) => {
+  const result = {
+    totalBytes: 0,
+    totalNodes: 0,
+    maxDepth: 0,
+    maxArrayLength: 0,
+    maxStringLength: 0,
+    totalStringsLength: 0
+  };
+  result.totalBytes = JSON.stringify(data).length;
+  walkValue(data, 0, result);
+  return result;
+};
+var walkValue = (value, depth, result) => {
+  result.totalNodes++;
+  if (result.maxDepth < depth) {
+    result.maxDepth = depth;
+  }
+  if (value === null || value === void 0) {
+    return;
+  }
+  if (typeof value === "string") {
+    if (value.length > result.maxStringLength) {
+      result.maxStringLength = value.length;
+    }
+    result.totalStringsLength += value.length;
+    return;
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return;
+  }
+  if (Array.isArray(value)) {
+    if (value.length > result.maxArrayLength) {
+      result.maxArrayLength = value.length;
+    }
+    for (const item of value) {
+      walkValue(item, depth + 1, result);
+    }
+    return;
+  }
+  if (typeof value === "object") {
+    for (const val of Object.values(value)) {
+      walkValue(val, depth + 1, result);
+    }
+  }
+};
+var calculateDataWeightFromStore = (store) => {
+  const result = {
+    totalBytes: 0,
+    totalNodes: 0,
+    maxDepth: 0,
+    maxArrayLength: 0,
+    maxStringLength: 0,
+    totalStringsLength: 0
+  };
+  result.totalBytes = JSON.stringify(store.getPlainValue()).length;
+  walkStore(store, 0, result);
+  return result;
+};
+var walkStore = (store, depth, result) => {
+  result.totalNodes++;
+  if (result.maxDepth < depth) {
+    result.maxDepth = depth;
+  }
+  if (store.type === "string") {
+    const val = store.getPlainValue();
+    if (val.length > result.maxStringLength) {
+      result.maxStringLength = val.length;
+    }
+    result.totalStringsLength += val.length;
+  } else if (store.type === "object") {
+    for (const child of Object.values(store.value)) {
+      walkStore(child, depth + 1, result);
+    }
+  } else if (store.type === "array") {
+    if (store.value.length > result.maxArrayLength) {
+      result.maxArrayLength = store.value.length;
+    }
+    for (const child of store.value) {
+      walkStore(child, depth + 1, result);
+    }
+  }
+};
 
+exports.RevisiumValidator = RevisiumValidator;
 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.calculateDataWeight = calculateDataWeight;
+exports.calculateDataWeightFromStore = calculateDataWeightFromStore;
+exports.calculateSchemaWeight = calculateSchemaWeight;
 exports.convertJsonPathToSchemaPath = convertJsonPathToSchemaPath;
 exports.convertSchemaPathToJsonPath = convertSchemaPathToJsonPath;
 exports.createJsonObjectSchemaStore = createJsonObjectSchemaStore;
@@ -764,3 +999,4 @@ exports.setValueByPath = setValueByPath;
 exports.traverseStore = traverseStore;
 exports.traverseValue = traverseValue;
 exports.validateJsonFieldName = validateJsonFieldName;
+exports.validateRevisiumSchema = validateRevisiumSchema;