@basictech/schema 0.6.0 → 0.7.0-beta.0

package/dist/index.js

@@ -1,9 +1,7 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -17,14 +15,6 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // index.ts
@@ -38,7 +28,608 @@ __export(schema_exports, {
   validateUpdateSchema: () => validateUpdateSchema
 });
 module.exports = __toCommonJS(schema_exports);
-var import_ajv = __toESM(require("ajv"));
+
+// generated-validator.js
+var validate = validate10;
+var schema11 = { "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "properties": { "project_id": { "type": "string" }, "namespace": { "type": "string" }, "version": { "type": "integer", "minimum": 0 }, "tables": { "type": "object", "propertyNames": { "pattern": "^(?!id$|ID$|Id$|iD$)[a-zA-Z0-9][a-zA-Z0-9_]*$", "minLength": 1, "maxLength": 50, "type": "string" }, "patternProperties": { "^(?!id$|ID$|Id$|iD$)[a-zA-Z0-9][a-zA-Z0-9_]*$": { "type": "object", "propertyNames": { "pattern": "^(?!id$|ID$|Id$|iD$)[a-zA-Z0-9][a-zA-Z0-9_]*$", "minLength": 1, "maxLength": 50, "type": "string" }, "properties": { "name": { "type": "string" }, "type": { "type": "string", "enum": ["collection"] }, "origin": { "type": "object", "properties": { "type": { "type": "string", "enum": ["reference"] }, "project_id": { "type": "string" }, "table": { "type": "string" }, "version": { "type": "integer" } }, "if": { "properties": { "type": { "const": "reference" } } }, "then": { "required": ["project_id", "table"] } }, "fields": { "type": "object", "propertyNames": { "pattern": "^(?!id$|ID$|Id$|iD$)[a-zA-Z0-9][a-zA-Z0-9_]*$", "minLength": 1, "maxLength": 50, "type": "string" }, "patternProperties": { "^(?!id$|ID$|Id$|iD$)[a-zA-Z0-9][a-zA-Z0-9_]*$": { "type": "object", "properties": { "type": { "type": "string", "enum": ["string", "boolean", "number", "json"] }, "indexed": { "type": "boolean" }, "required": { "type": "boolean" } }, "required": ["type"] } }, "additionalProperties": true } }, "required": ["fields"] } }, "additionalProperties": true } }, "required": ["project_id", "version", "tables"] };
+var ucs2length = (str) => [...str].length;
+var func2 = ucs2length;
+var pattern0 = new RegExp("^(?!id$|ID$|Id$|iD$)[a-zA-Z0-9][a-zA-Z0-9_]*$", "u");
+function validate10(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
+  let vErrors = null;
+  let errors = 0;
+  const _errs0 = errors;
+  if (data && typeof data == "object" && !Array.isArray(data)) {
+    if (data.project_id === void 0) {
+      const err0 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "project_id" }, message: "must have required property 'project_id'" };
+      if (vErrors === null) {
+        vErrors = [err0];
+      } else {
+        vErrors.push(err0);
+      }
+      errors++;
+    }
+    if (data.version === void 0) {
+      const err1 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "version" }, message: "must have required property 'version'" };
+      if (vErrors === null) {
+        vErrors = [err1];
+      } else {
+        vErrors.push(err1);
+      }
+      errors++;
+    }
+    if (data.tables === void 0) {
+      const err2 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "tables" }, message: "must have required property 'tables'" };
+      if (vErrors === null) {
+        vErrors = [err2];
+      } else {
+        vErrors.push(err2);
+      }
+      errors++;
+    }
+    if (data.project_id !== void 0) {
+      let data0 = data.project_id;
+      const _errs1 = errors;
+      if (typeof data0 !== "string") {
+        const err3 = { instancePath: instancePath + "/project_id", schemaPath: "#/properties/project_id/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err3];
+        } else {
+          vErrors.push(err3);
+        }
+        errors++;
+      }
+      const _errs2 = errors;
+      var valid0 = _errs1 === errors;
+    }
+    if (data.namespace !== void 0) {
+      let data1 = data.namespace;
+      const _errs3 = errors;
+      if (typeof data1 !== "string") {
+        const err4 = { instancePath: instancePath + "/namespace", schemaPath: "#/properties/namespace/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err4];
+        } else {
+          vErrors.push(err4);
+        }
+        errors++;
+      }
+      const _errs4 = errors;
+      var valid0 = _errs3 === errors;
+    }
+    if (data.version !== void 0) {
+      let data2 = data.version;
+      const _errs5 = errors;
+      if (!(typeof data2 == "number" && (!(data2 % 1) && !isNaN(data2)))) {
+        const err5 = { instancePath: instancePath + "/version", schemaPath: "#/properties/version/type", keyword: "type", params: { type: "integer" }, message: "must be integer" };
+        if (vErrors === null) {
+          vErrors = [err5];
+        } else {
+          vErrors.push(err5);
+        }
+        errors++;
+      }
+      const _errs6 = errors;
+      if (typeof data2 == "number") {
+        if (data2 < 0 || isNaN(data2)) {
+          const err6 = { instancePath: instancePath + "/version", schemaPath: "#/properties/version/minimum", keyword: "minimum", params: { comparison: ">=", limit: 0 }, message: "must be >= 0" };
+          if (vErrors === null) {
+            vErrors = [err6];
+          } else {
+            vErrors.push(err6);
+          }
+          errors++;
+        }
+      }
+      var valid0 = _errs5 === errors;
+    }
+    if (data.tables !== void 0) {
+      let data3 = data.tables;
+      const _errs7 = errors;
+      const _errs8 = errors;
+      if (data3 && typeof data3 == "object" && !Array.isArray(data3)) {
+        for (const key0 in data3) {
+          const _errs9 = errors;
+          const _errs10 = errors;
+          if (typeof key0 === "string") {
+            if (func2(key0) > 50) {
+              const err7 = { instancePath: instancePath + "/tables", schemaPath: "#/properties/tables/propertyNames/maxLength", keyword: "maxLength", params: { limit: 50 }, message: "must NOT have more than 50 characters", propertyName: key0 };
+              if (vErrors === null) {
+                vErrors = [err7];
+              } else {
+                vErrors.push(err7);
+              }
+              errors++;
+            }
+            if (func2(key0) < 1) {
+              const err8 = { instancePath: instancePath + "/tables", schemaPath: "#/properties/tables/propertyNames/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters", propertyName: key0 };
+              if (vErrors === null) {
+                vErrors = [err8];
+              } else {
+                vErrors.push(err8);
+              }
+              errors++;
+            }
+            if (!pattern0.test(key0)) {
+              const err9 = { instancePath: instancePath + "/tables", schemaPath: "#/properties/tables/propertyNames/pattern", keyword: "pattern", params: { pattern: "^(?!id$|ID$|Id$|iD$)[a-zA-Z0-9][a-zA-Z0-9_]*$" }, message: 'must match pattern "^(?!id$|ID$|Id$|iD$)[a-zA-Z0-9][a-zA-Z0-9_]*$"', propertyName: key0 };
+              if (vErrors === null) {
+                vErrors = [err9];
+              } else {
+                vErrors.push(err9);
+              }
+              errors++;
+            }
+          } else {
+            const err10 = { instancePath: instancePath + "/tables", schemaPath: "#/properties/tables/propertyNames/type", keyword: "type", params: { type: "string" }, message: "must be string", propertyName: key0 };
+            if (vErrors === null) {
+              vErrors = [err10];
+            } else {
+              vErrors.push(err10);
+            }
+            errors++;
+          }
+          var valid1 = _errs9 === errors;
+          if (!valid1) {
+            const err11 = { instancePath: instancePath + "/tables", schemaPath: "#/properties/tables/propertyNames", keyword: "propertyNames", params: { propertyName: key0 }, message: "property name must be valid" };
+            if (vErrors === null) {
+              vErrors = [err11];
+            } else {
+              vErrors.push(err11);
+            }
+            errors++;
+          }
+        }
+        const _errs11 = errors;
+        for (const key1 in data3) {
+          if (pattern0.test(key1)) {
+            let data4 = data3[key1];
+            const _errs12 = errors;
+            const _errs13 = errors;
+            if (data4 && typeof data4 == "object" && !Array.isArray(data4)) {
+              if (data4.fields === void 0) {
+                const err12 = { instancePath: instancePath + "/tables/" + key1.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/properties/tables/patternProperties/%5E(%3F!id%24%7CID%24%7CId%24%7CiD%24)%5Ba-zA-Z0-9%5D%5Ba-zA-Z0-9_%5D*%24/required", keyword: "required", params: { missingProperty: "fields" }, message: "must have required property 'fields'" };
+                if (vErrors === null) {
+                  vErrors = [err12];
+                } else {
+                  vErrors.push(err12);
+                }
+                errors++;
+              }
+              for (const key2 in data4) {
+                const _errs14 = errors;
+                const _errs15 = errors;
+                if (typeof key2 === "string") {
+                  if (func2(key2) > 50) {
+                    const err13 = { instancePath: instancePath + "/tables/" + key1.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/properties/tables/patternProperties/%5E(%3F!id%24%7CID%24%7CId%24%7CiD%24)%5Ba-zA-Z0-9%5D%5Ba-zA-Z0-9_%5D*%24/propertyNames/maxLength", keyword: "maxLength", params: { limit: 50 }, message: "must NOT have more than 50 characters", propertyName: key2 };
+                    if (vErrors === null) {
+                      vErrors = [err13];
+                    } else {
+                      vErrors.push(err13);
+                    }
+                    errors++;
+                  }
+                  if (func2(key2) < 1) {
+                    const err14 = { instancePath: instancePath + "/tables/" + key1.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/properties/tables/patternProperties/%5E(%3F!id%24%7CID%24%7CId%24%7CiD%24)%5Ba-zA-Z0-9%5D%5Ba-zA-Z0-9_%5D*%24/propertyNames/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters", propertyName: key2 };
+                    if (vErrors === null) {
+                      vErrors = [err14];
+                    } else {
+                      vErrors.push(err14);
+                    }
+                    errors++;
+                  }
+                  if (!pattern0.test(key2)) {
+                    const err15 = { instancePath: instancePath + "/tables/" + key1.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/properties/tables/patternProperties/%5E(%3F!id%24%7CID%24%7CId%24%7CiD%24)%5Ba-zA-Z0-9%5D%5Ba-zA-Z0-9_%5D*%24/propertyNames/pattern", keyword: "pattern", params: { pattern: "^(?!id$|ID$|Id$|iD$)[a-zA-Z0-9][a-zA-Z0-9_]*$" }, message: 'must match pattern "^(?!id$|ID$|Id$|iD$)[a-zA-Z0-9][a-zA-Z0-9_]*$"', propertyName: key2 };
+                    if (vErrors === null) {
+                      vErrors = [err15];
+                    } else {
+                      vErrors.push(err15);
+                    }
+                    errors++;
+                  }
+                } else {
+                  const err16 = { instancePath: instancePath + "/tables/" + key1.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/properties/tables/patternProperties/%5E(%3F!id%24%7CID%24%7CId%24%7CiD%24)%5Ba-zA-Z0-9%5D%5Ba-zA-Z0-9_%5D*%24/propertyNames/type", keyword: "type", params: { type: "string" }, message: "must be string", propertyName: key2 };
+                  if (vErrors === null) {
+                    vErrors = [err16];
+                  } else {
+                    vErrors.push(err16);
+                  }
+                  errors++;
+                }
+                var valid3 = _errs14 === errors;
+                if (!valid3) {
+                  const err17 = { instancePath: instancePath + "/tables/" + key1.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/properties/tables/patternProperties/%5E(%3F!id%24%7CID%24%7CId%24%7CiD%24)%5Ba-zA-Z0-9%5D%5Ba-zA-Z0-9_%5D*%24/propertyNames", keyword: "propertyNames", params: { propertyName: key2 }, message: "property name must be valid" };
+                  if (vErrors === null) {
+                    vErrors = [err17];
+                  } else {
+                    vErrors.push(err17);
+                  }
+                  errors++;
+                }
+              }
+              if (data4.name !== void 0) {
+                let data5 = data4.name;
+                const _errs16 = errors;
+                if (typeof data5 !== "string") {
+                  const err18 = { instancePath: instancePath + "/tables/" + key1.replace(/~/g, "~0").replace(/\//g, "~1") + "/name", schemaPath: "#/properties/tables/patternProperties/%5E(%3F!id%24%7CID%24%7CId%24%7CiD%24)%5Ba-zA-Z0-9%5D%5Ba-zA-Z0-9_%5D*%24/properties/name/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                  if (vErrors === null) {
+                    vErrors = [err18];
+                  } else {
+                    vErrors.push(err18);
+                  }
+                  errors++;
+                }
+                const _errs17 = errors;
+                var valid4 = _errs16 === errors;
+              }
+              if (data4.type !== void 0) {
+                let data6 = data4.type;
+                const _errs18 = errors;
+                if (typeof data6 !== "string") {
+                  const err19 = { instancePath: instancePath + "/tables/" + key1.replace(/~/g, "~0").replace(/\//g, "~1") + "/type", schemaPath: "#/properties/tables/patternProperties/%5E(%3F!id%24%7CID%24%7CId%24%7CiD%24)%5Ba-zA-Z0-9%5D%5Ba-zA-Z0-9_%5D*%24/properties/type/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                  if (vErrors === null) {
+                    vErrors = [err19];
+                  } else {
+                    vErrors.push(err19);
+                  }
+                  errors++;
+                }
+                const _errs19 = errors;
+                const vSchema0 = schema11.properties.tables.patternProperties["^(?!id$|ID$|Id$|iD$)[a-zA-Z0-9][a-zA-Z0-9_]*$"].properties.type.enum;
+                if (!(data6 === "collection")) {
+                  const err20 = { instancePath: instancePath + "/tables/" + key1.replace(/~/g, "~0").replace(/\//g, "~1") + "/type", schemaPath: "#/properties/tables/patternProperties/%5E(%3F!id%24%7CID%24%7CId%24%7CiD%24)%5Ba-zA-Z0-9%5D%5Ba-zA-Z0-9_%5D*%24/properties/type/enum", keyword: "enum", params: { allowedValues: schema11.properties.tables.patternProperties["^(?!id$|ID$|Id$|iD$)[a-zA-Z0-9][a-zA-Z0-9_]*$"].properties.type.enum }, message: "must be equal to one of the allowed values" };
+                  if (vErrors === null) {
+                    vErrors = [err20];
+                  } else {
+                    vErrors.push(err20);
+                  }
+                  errors++;
+                }
+                var valid4 = _errs18 === errors;
+              }
+              if (data4.origin !== void 0) {
+                let data7 = data4.origin;
+                const _errs20 = errors;
+                const _errs21 = errors;
+                const _errs22 = errors;
+                let valid5 = true;
+                const _errs23 = errors;
+                if (data7 && typeof data7 == "object" && !Array.isArray(data7)) {
+                  if (data7.type !== void 0) {
+                    let data8 = data7.type;
+                    const _errs24 = errors;
+                    if ("reference" !== data8) {
+                      const err21 = {};
+                      if (vErrors === null) {
+                        vErrors = [err21];
+                      } else {
+                        vErrors.push(err21);
+                      }
+                      errors++;
+                    } else {
+                    }
+                    if (errors === _errs24) {
+                    }
+                    var valid6 = _errs24 === errors;
+                  } else {
+                    var valid6 = true;
+                  }
+                  if (valid6) {
+                  }
+                }
+                if (errors === _errs23) {
+                }
+                var _valid0 = _errs23 === errors;
+                errors = _errs22;
+                if (vErrors !== null) {
+                  if (_errs22) {
+                    vErrors.length = _errs22;
+                  } else {
+                    vErrors = null;
+                  }
+                }
+                if (_valid0) {
+                  const _errs25 = errors;
+                  if (data7 && typeof data7 == "object" && !Array.isArray(data7)) {
+                    if (data7.project_id === void 0) {
+                      const err22 = { instancePath: instancePath + "/tables/" + key1.replace(/~/g, "~0").replace(/\//g, "~1") + "/origin", schemaPath: "#/properties/tables/patternProperties/%5E(%3F!id%24%7CID%24%7CId%24%7CiD%24)%5Ba-zA-Z0-9%5D%5Ba-zA-Z0-9_%5D*%24/properties/origin/then/required", keyword: "required", params: { missingProperty: "project_id" }, message: "must have required property 'project_id'" };
+                      if (vErrors === null) {
+                        vErrors = [err22];
+                      } else {
+                        vErrors.push(err22);
+                      }
+                      errors++;
+                    }
+                    if (data7.table === void 0) {
+                      const err23 = { instancePath: instancePath + "/tables/" + key1.replace(/~/g, "~0").replace(/\//g, "~1") + "/origin", schemaPath: "#/properties/tables/patternProperties/%5E(%3F!id%24%7CID%24%7CId%24%7CiD%24)%5Ba-zA-Z0-9%5D%5Ba-zA-Z0-9_%5D*%24/properties/origin/then/required", keyword: "required", params: { missingProperty: "table" }, message: "must have required property 'table'" };
+                      if (vErrors === null) {
+                        vErrors = [err23];
+                      } else {
+                        vErrors.push(err23);
+                      }
+                      errors++;
+                    }
+                  }
+                  var _valid0 = _errs25 === errors;
+                  valid5 = _valid0;
+                }
+                if (!valid5) {
+                  const err24 = { instancePath: instancePath + "/tables/" + key1.replace(/~/g, "~0").replace(/\//g, "~1") + "/origin", schemaPath: "#/properties/tables/patternProperties/%5E(%3F!id%24%7CID%24%7CId%24%7CiD%24)%5Ba-zA-Z0-9%5D%5Ba-zA-Z0-9_%5D*%24/properties/origin/if", keyword: "if", params: { failingKeyword: "then" }, message: 'must match "then" schema' };
+                  if (vErrors === null) {
+                    vErrors = [err24];
+                  } else {
+                    vErrors.push(err24);
+                  }
+                  errors++;
+                }
+                if (data7 && typeof data7 == "object" && !Array.isArray(data7)) {
+                  if (data7.type !== void 0) {
+                    let data9 = data7.type;
+                    const _errs26 = errors;
+                    if (typeof data9 !== "string") {
+                      const err25 = { instancePath: instancePath + "/tables/" + key1.replace(/~/g, "~0").replace(/\//g, "~1") + "/origin/type", schemaPath: "#/properties/tables/patternProperties/%5E(%3F!id%24%7CID%24%7CId%24%7CiD%24)%5Ba-zA-Z0-9%5D%5Ba-zA-Z0-9_%5D*%24/properties/origin/properties/type/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                      if (vErrors === null) {
+                        vErrors = [err25];
+                      } else {
+                        vErrors.push(err25);
+                      }
+                      errors++;
+                    }
+                    const _errs27 = errors;
+                    const vSchema1 = schema11.properties.tables.patternProperties["^(?!id$|ID$|Id$|iD$)[a-zA-Z0-9][a-zA-Z0-9_]*$"].properties.origin.properties.type.enum;
+                    if (!(data9 === "reference")) {
+                      const err26 = { instancePath: instancePath + "/tables/" + key1.replace(/~/g, "~0").replace(/\//g, "~1") + "/origin/type", schemaPath: "#/properties/tables/patternProperties/%5E(%3F!id%24%7CID%24%7CId%24%7CiD%24)%5Ba-zA-Z0-9%5D%5Ba-zA-Z0-9_%5D*%24/properties/origin/properties/type/enum", keyword: "enum", params: { allowedValues: schema11.properties.tables.patternProperties["^(?!id$|ID$|Id$|iD$)[a-zA-Z0-9][a-zA-Z0-9_]*$"].properties.origin.properties.type.enum }, message: "must be equal to one of the allowed values" };
+                      if (vErrors === null) {
+                        vErrors = [err26];
+                      } else {
+                        vErrors.push(err26);
+                      }
+                      errors++;
+                    }
+                    var valid7 = _errs26 === errors;
+                  }
+                  if (data7.project_id !== void 0) {
+                    let data10 = data7.project_id;
+                    const _errs28 = errors;
+                    if (typeof data10 !== "string") {
+                      const err27 = { instancePath: instancePath + "/tables/" + key1.replace(/~/g, "~0").replace(/\//g, "~1") + "/origin/project_id", schemaPath: "#/properties/tables/patternProperties/%5E(%3F!id%24%7CID%24%7CId%24%7CiD%24)%5Ba-zA-Z0-9%5D%5Ba-zA-Z0-9_%5D*%24/properties/origin/properties/project_id/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                      if (vErrors === null) {
+                        vErrors = [err27];
+                      } else {
+                        vErrors.push(err27);
+                      }
+                      errors++;
+                    }
+                    const _errs29 = errors;
+                    var valid7 = _errs28 === errors;
+                  }
+                  if (data7.table !== void 0) {
+                    let data11 = data7.table;
+                    const _errs30 = errors;
+                    if (typeof data11 !== "string") {
+                      const err28 = { instancePath: instancePath + "/tables/" + key1.replace(/~/g, "~0").replace(/\//g, "~1") + "/origin/table", schemaPath: "#/properties/tables/patternProperties/%5E(%3F!id%24%7CID%24%7CId%24%7CiD%24)%5Ba-zA-Z0-9%5D%5Ba-zA-Z0-9_%5D*%24/properties/origin/properties/table/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                      if (vErrors === null) {
+                        vErrors = [err28];
+                      } else {
+                        vErrors.push(err28);
+                      }
+                      errors++;
+                    }
+                    const _errs31 = errors;
+                    var valid7 = _errs30 === errors;
+                  }
+                  if (data7.version !== void 0) {
+                    let data12 = data7.version;
+                    const _errs32 = errors;
+                    if (!(typeof data12 == "number" && (!(data12 % 1) && !isNaN(data12)))) {
+                      const err29 = { instancePath: instancePath + "/tables/" + key1.replace(/~/g, "~0").replace(/\//g, "~1") + "/origin/version", schemaPath: "#/properties/tables/patternProperties/%5E(%3F!id%24%7CID%24%7CId%24%7CiD%24)%5Ba-zA-Z0-9%5D%5Ba-zA-Z0-9_%5D*%24/properties/origin/properties/version/type", keyword: "type", params: { type: "integer" }, message: "must be integer" };
+                      if (vErrors === null) {
+                        vErrors = [err29];
+                      } else {
+                        vErrors.push(err29);
+                      }
+                      errors++;
+                    }
+                    const _errs33 = errors;
+                    var valid7 = _errs32 === errors;
+                  }
+                } else {
+                  const err30 = { instancePath: instancePath + "/tables/" + key1.replace(/~/g, "~0").replace(/\//g, "~1") + "/origin", schemaPath: "#/properties/tables/patternProperties/%5E(%3F!id%24%7CID%24%7CId%24%7CiD%24)%5Ba-zA-Z0-9%5D%5Ba-zA-Z0-9_%5D*%24/properties/origin/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+                  if (vErrors === null) {
+                    vErrors = [err30];
+                  } else {
+                    vErrors.push(err30);
+                  }
+                  errors++;
+                }
+                var valid4 = _errs20 === errors;
+              }
+              if (data4.fields !== void 0) {
+                let data13 = data4.fields;
+                const _errs34 = errors;
+                const _errs35 = errors;
+                if (data13 && typeof data13 == "object" && !Array.isArray(data13)) {
+                  for (const key3 in data13) {
+                    const _errs36 = errors;
+                    const _errs37 = errors;
+                    if (typeof key3 === "string") {
+                      if (func2(key3) > 50) {
+                        const err31 = { instancePath: instancePath + "/tables/" + key1.replace(/~/g, "~0").replace(/\//g, "~1") + "/fields", schemaPath: "#/properties/tables/patternProperties/%5E(%3F!id%24%7CID%24%7CId%24%7CiD%24)%5Ba-zA-Z0-9%5D%5Ba-zA-Z0-9_%5D*%24/properties/fields/propertyNames/maxLength", keyword: "maxLength", params: { limit: 50 }, message: "must NOT have more than 50 characters", propertyName: key3 };
+                        if (vErrors === null) {
+                          vErrors = [err31];
+                        } else {
+                          vErrors.push(err31);
+                        }
+                        errors++;
+                      }
+                      if (func2(key3) < 1) {
+                        const err32 = { instancePath: instancePath + "/tables/" + key1.replace(/~/g, "~0").replace(/\//g, "~1") + "/fields", schemaPath: "#/properties/tables/patternProperties/%5E(%3F!id%24%7CID%24%7CId%24%7CiD%24)%5Ba-zA-Z0-9%5D%5Ba-zA-Z0-9_%5D*%24/properties/fields/propertyNames/minLength", keyword: "minLength", params: { limit: 1 }, message: "must NOT have fewer than 1 characters", propertyName: key3 };
+                        if (vErrors === null) {
+                          vErrors = [err32];
+                        } else {
+                          vErrors.push(err32);
+                        }
+                        errors++;
+                      }
+                      if (!pattern0.test(key3)) {
+                        const err33 = { instancePath: instancePath + "/tables/" + key1.replace(/~/g, "~0").replace(/\//g, "~1") + "/fields", schemaPath: "#/properties/tables/patternProperties/%5E(%3F!id%24%7CID%24%7CId%24%7CiD%24)%5Ba-zA-Z0-9%5D%5Ba-zA-Z0-9_%5D*%24/properties/fields/propertyNames/pattern", keyword: "pattern", params: { pattern: "^(?!id$|ID$|Id$|iD$)[a-zA-Z0-9][a-zA-Z0-9_]*$" }, message: 'must match pattern "^(?!id$|ID$|Id$|iD$)[a-zA-Z0-9][a-zA-Z0-9_]*$"', propertyName: key3 };
+                        if (vErrors === null) {
+                          vErrors = [err33];
+                        } else {
+                          vErrors.push(err33);
+                        }
+                        errors++;
+                      }
+                    } else {
+                      const err34 = { instancePath: instancePath + "/tables/" + key1.replace(/~/g, "~0").replace(/\//g, "~1") + "/fields", schemaPath: "#/properties/tables/patternProperties/%5E(%3F!id%24%7CID%24%7CId%24%7CiD%24)%5Ba-zA-Z0-9%5D%5Ba-zA-Z0-9_%5D*%24/properties/fields/propertyNames/type", keyword: "type", params: { type: "string" }, message: "must be string", propertyName: key3 };
+                      if (vErrors === null) {
+                        vErrors = [err34];
+                      } else {
+                        vErrors.push(err34);
+                      }
+                      errors++;
+                    }
+                    var valid8 = _errs36 === errors;
+                    if (!valid8) {
+                      const err35 = { instancePath: instancePath + "/tables/" + key1.replace(/~/g, "~0").replace(/\//g, "~1") + "/fields", schemaPath: "#/properties/tables/patternProperties/%5E(%3F!id%24%7CID%24%7CId%24%7CiD%24)%5Ba-zA-Z0-9%5D%5Ba-zA-Z0-9_%5D*%24/properties/fields/propertyNames", keyword: "propertyNames", params: { propertyName: key3 }, message: "property name must be valid" };
+                      if (vErrors === null) {
+                        vErrors = [err35];
+                      } else {
+                        vErrors.push(err35);
+                      }
+                      errors++;
+                    }
+                  }
+                  const _errs38 = errors;
+                  for (const key4 in data13) {
+                    if (pattern0.test(key4)) {
+                      let data14 = data13[key4];
+                      const _errs39 = errors;
+                      const _errs40 = errors;
+                      if (data14 && typeof data14 == "object" && !Array.isArray(data14)) {
+                        if (data14.type === void 0) {
+                          const err36 = { instancePath: instancePath + "/tables/" + key1.replace(/~/g, "~0").replace(/\//g, "~1") + "/fields/" + key4.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/properties/tables/patternProperties/%5E(%3F!id%24%7CID%24%7CId%24%7CiD%24)%5Ba-zA-Z0-9%5D%5Ba-zA-Z0-9_%5D*%24/properties/fields/patternProperties/%5E(%3F!id%24%7CID%24%7CId%24%7CiD%24)%5Ba-zA-Z0-9%5D%5Ba-zA-Z0-9_%5D*%24/required", keyword: "required", params: { missingProperty: "type" }, message: "must have required property 'type'" };
+                          if (vErrors === null) {
+                            vErrors = [err36];
+                          } else {
+                            vErrors.push(err36);
+                          }
+                          errors++;
+                        }
+                        if (data14.type !== void 0) {
+                          let data15 = data14.type;
+                          const _errs41 = errors;
+                          if (typeof data15 !== "string") {
+                            const err37 = { instancePath: instancePath + "/tables/" + key1.replace(/~/g, "~0").replace(/\//g, "~1") + "/fields/" + key4.replace(/~/g, "~0").replace(/\//g, "~1") + "/type", schemaPath: "#/properties/tables/patternProperties/%5E(%3F!id%24%7CID%24%7CId%24%7CiD%24)%5Ba-zA-Z0-9%5D%5Ba-zA-Z0-9_%5D*%24/properties/fields/patternProperties/%5E(%3F!id%24%7CID%24%7CId%24%7CiD%24)%5Ba-zA-Z0-9%5D%5Ba-zA-Z0-9_%5D*%24/properties/type/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                            if (vErrors === null) {
+                              vErrors = [err37];
+                            } else {
+                              vErrors.push(err37);
+                            }
+                            errors++;
+                          }
+                          const _errs42 = errors;
+                          const vSchema2 = schema11.properties.tables.patternProperties["^(?!id$|ID$|Id$|iD$)[a-zA-Z0-9][a-zA-Z0-9_]*$"].properties.fields.patternProperties["^(?!id$|ID$|Id$|iD$)[a-zA-Z0-9][a-zA-Z0-9_]*$"].properties.type.enum;
+                          if (!(data15 === "string" || data15 === "boolean" || data15 === "number" || data15 === "json")) {
+                            const err38 = { instancePath: instancePath + "/tables/" + key1.replace(/~/g, "~0").replace(/\//g, "~1") + "/fields/" + key4.replace(/~/g, "~0").replace(/\//g, "~1") + "/type", schemaPath: "#/properties/tables/patternProperties/%5E(%3F!id%24%7CID%24%7CId%24%7CiD%24)%5Ba-zA-Z0-9%5D%5Ba-zA-Z0-9_%5D*%24/properties/fields/patternProperties/%5E(%3F!id%24%7CID%24%7CId%24%7CiD%24)%5Ba-zA-Z0-9%5D%5Ba-zA-Z0-9_%5D*%24/properties/type/enum", keyword: "enum", params: { allowedValues: schema11.properties.tables.patternProperties["^(?!id$|ID$|Id$|iD$)[a-zA-Z0-9][a-zA-Z0-9_]*$"].properties.fields.patternProperties["^(?!id$|ID$|Id$|iD$)[a-zA-Z0-9][a-zA-Z0-9_]*$"].properties.type.enum }, message: "must be equal to one of the allowed values" };
+                            if (vErrors === null) {
+                              vErrors = [err38];
+                            } else {
+                              vErrors.push(err38);
+                            }
+                            errors++;
+                          }
+                          var valid10 = _errs41 === errors;
+                        }
+                        if (data14.indexed !== void 0) {
+                          let data16 = data14.indexed;
+                          const _errs43 = errors;
+                          if (typeof data16 !== "boolean") {
+                            const err39 = { instancePath: instancePath + "/tables/" + key1.replace(/~/g, "~0").replace(/\//g, "~1") + "/fields/" + key4.replace(/~/g, "~0").replace(/\//g, "~1") + "/indexed", schemaPath: "#/properties/tables/patternProperties/%5E(%3F!id%24%7CID%24%7CId%24%7CiD%24)%5Ba-zA-Z0-9%5D%5Ba-zA-Z0-9_%5D*%24/properties/fields/patternProperties/%5E(%3F!id%24%7CID%24%7CId%24%7CiD%24)%5Ba-zA-Z0-9%5D%5Ba-zA-Z0-9_%5D*%24/properties/indexed/type", keyword: "type", params: { type: "boolean" }, message: "must be boolean" };
+                            if (vErrors === null) {
+                              vErrors = [err39];
+                            } else {
+                              vErrors.push(err39);
+                            }
+                            errors++;
+                          }
+                          const _errs44 = errors;
+                          var valid10 = _errs43 === errors;
+                        }
+                        if (data14.required !== void 0) {
+                          let data17 = data14.required;
+                          const _errs45 = errors;
+                          if (typeof data17 !== "boolean") {
+                            const err40 = { instancePath: instancePath + "/tables/" + key1.replace(/~/g, "~0").replace(/\//g, "~1") + "/fields/" + key4.replace(/~/g, "~0").replace(/\//g, "~1") + "/required", schemaPath: "#/properties/tables/patternProperties/%5E(%3F!id%24%7CID%24%7CId%24%7CiD%24)%5Ba-zA-Z0-9%5D%5Ba-zA-Z0-9_%5D*%24/properties/fields/patternProperties/%5E(%3F!id%24%7CID%24%7CId%24%7CiD%24)%5Ba-zA-Z0-9%5D%5Ba-zA-Z0-9_%5D*%24/properties/required/type", keyword: "type", params: { type: "boolean" }, message: "must be boolean" };
+                            if (vErrors === null) {
+                              vErrors = [err40];
+                            } else {
+                              vErrors.push(err40);
+                            }
+                            errors++;
+                          }
+                          const _errs46 = errors;
+                          var valid10 = _errs45 === errors;
+                        }
+                      } else {
+                        const err41 = { instancePath: instancePath + "/tables/" + key1.replace(/~/g, "~0").replace(/\//g, "~1") + "/fields/" + key4.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/properties/tables/patternProperties/%5E(%3F!id%24%7CID%24%7CId%24%7CiD%24)%5Ba-zA-Z0-9%5D%5Ba-zA-Z0-9_%5D*%24/properties/fields/patternProperties/%5E(%3F!id%24%7CID%24%7CId%24%7CiD%24)%5Ba-zA-Z0-9%5D%5Ba-zA-Z0-9_%5D*%24/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+                        if (vErrors === null) {
+                          vErrors = [err41];
+                        } else {
+                          vErrors.push(err41);
+                        }
+                        errors++;
+                      }
+                      var valid9 = _errs39 === errors;
+                    }
+                  }
+                } else {
+                  const err42 = { instancePath: instancePath + "/tables/" + key1.replace(/~/g, "~0").replace(/\//g, "~1") + "/fields", schemaPath: "#/properties/tables/patternProperties/%5E(%3F!id%24%7CID%24%7CId%24%7CiD%24)%5Ba-zA-Z0-9%5D%5Ba-zA-Z0-9_%5D*%24/properties/fields/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+                  if (vErrors === null) {
+                    vErrors = [err42];
+                  } else {
+                    vErrors.push(err42);
+                  }
+                  errors++;
+                }
+                var valid4 = _errs34 === errors;
+              }
+            } else {
+              const err43 = { instancePath: instancePath + "/tables/" + key1.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/properties/tables/patternProperties/%5E(%3F!id%24%7CID%24%7CId%24%7CiD%24)%5Ba-zA-Z0-9%5D%5Ba-zA-Z0-9_%5D*%24/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+              if (vErrors === null) {
+                vErrors = [err43];
+              } else {
+                vErrors.push(err43);
+              }
+              errors++;
+            }
+            var valid2 = _errs12 === errors;
+          }
+        }
+      } else {
+        const err44 = { instancePath: instancePath + "/tables", schemaPath: "#/properties/tables/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+        if (vErrors === null) {
+          vErrors = [err44];
+        } else {
+          vErrors.push(err44);
+        }
+        errors++;
+      }
+      var valid0 = _errs7 === errors;
+    }
+  } else {
+    const err45 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+    if (vErrors === null) {
+      vErrors = [err45];
+    } else {
+      vErrors.push(err45);
+    }
+    errors++;
+  }
+  validate10.errors = vErrors;
+  return errors === 0;
+}
+
+// index.ts
 var basicJsonSchema = {
   "$schema": "http://json-schema.org/draft-07/schema#",
   "type": "object",
@@ -139,8 +730,7 @@ var basicJsonSchema = {
   },
   "required": ["project_id", "version", "tables"]
 };
-var ajv = new import_ajv.default({ allErrors: true });
-var validator = ajv.compile(basicJsonSchema);
+var validator = validate;
 function generateEmptySchema(project_id = "", version = 0) {
   return {
     project_id,