--- /dev/null
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveSchema = exports.getCompilingSchema = exports.resolveRef = exports.compileSchema = exports.SchemaEnv = void 0;
+const codegen_1 = require("./codegen");
+const validation_error_1 = require("../runtime/validation_error");
+const names_1 = require("./names");
+const resolve_1 = require("./resolve");
+const util_1 = require("./util");
+const validate_1 = require("./validate");
+const URI = require("uri-js");
+class SchemaEnv {
+ constructor(env) {
+ var _a;
+ this.refs = {};
+ this.dynamicAnchors = {};
+ let schema;
+ if (typeof env.schema == "object")
+ schema = env.schema;
+ this.schema = env.schema;
+ this.root = env.root || this;
+ this.baseId = (_a = env.baseId) !== null && _a !== void 0 ? _a : resolve_1.normalizeId(schema === null || schema === void 0 ? void 0 : schema.$id);
+ this.schemaPath = env.schemaPath;
+ this.localRefs = env.localRefs;
+ this.meta = env.meta;
+ this.$async = schema === null || schema === void 0 ? void 0 : schema.$async;
+ this.refs = {};
+ }
+}
+exports.SchemaEnv = SchemaEnv;
+// let codeSize = 0
+// let nodeCount = 0
+// Compiles schema in SchemaEnv
+function compileSchema(sch) {
+ // TODO refactor - remove compilations
+ const _sch = getCompilingSchema.call(this, sch);
+ if (_sch)
+ return _sch;
+ const rootId = resolve_1.getFullPath(sch.root.baseId); // TODO if getFullPath removed 1 tests fails
+ const { es5, lines } = this.opts.code;
+ const { ownProperties } = this.opts;
+ const gen = new codegen_1.CodeGen(this.scope, { es5, lines, ownProperties });
+ let _ValidationError;
+ if (sch.$async) {
+ _ValidationError = gen.scopeValue("Error", {
+ ref: validation_error_1.default,
+ code: codegen_1._ `require("ajv/dist/runtime/validation_error").default`,
+ });
+ }
+ const validateName = gen.scopeName("validate");
+ sch.validateName = validateName;
+ const schemaCxt = {
+ gen,
+ allErrors: this.opts.allErrors,
+ data: names_1.default.data,
+ parentData: names_1.default.parentData,
+ parentDataProperty: names_1.default.parentDataProperty,
+ dataNames: [names_1.default.data],
+ dataPathArr: [codegen_1.nil],
+ dataLevel: 0,
+ dataTypes: [],
+ definedProperties: new Set(),
+ topSchemaRef: gen.scopeValue("schema", this.opts.code.source === true
+ ? { ref: sch.schema, code: codegen_1.stringify(sch.schema) }
+ : { ref: sch.schema }),
+ validateName,
+ ValidationError: _ValidationError,
+ schema: sch.schema,
+ schemaEnv: sch,
+ rootId,
+ baseId: sch.baseId || rootId,
+ schemaPath: codegen_1.nil,
+ errSchemaPath: sch.schemaPath || (this.opts.jtd ? "" : "#"),
+ errorPath: codegen_1._ `""`,
+ opts: this.opts,
+ self: this,
+ };
+ let sourceCode;
+ try {
+ this._compilations.add(sch);
+ validate_1.validateFunctionCode(schemaCxt);
+ gen.optimize(this.opts.code.optimize);
+ // gen.optimize(1)
+ const validateCode = gen.toString();
+ sourceCode = `${gen.scopeRefs(names_1.default.scope)}return ${validateCode}`;
+ // console.log((codeSize += sourceCode.length), (nodeCount += gen.nodeCount))
+ if (this.opts.code.process)
+ sourceCode = this.opts.code.process(sourceCode, sch);
+ // console.log("\n\n\n *** \n", sourceCode)
+ const makeValidate = new Function(`${names_1.default.self}`, `${names_1.default.scope}`, sourceCode);
+ const validate = makeValidate(this, this.scope.get());
+ this.scope.value(validateName, { ref: validate });
+ validate.errors = null;
+ validate.schema = sch.schema;
+ validate.schemaEnv = sch;
+ if (sch.$async)
+ validate.$async = true;
+ if (this.opts.code.source === true) {
+ validate.source = { validateName, validateCode, scopeValues: gen._values };
+ }
+ if (this.opts.unevaluated) {
+ const { props, items } = schemaCxt;
+ validate.evaluated = {
+ props: props instanceof codegen_1.Name ? undefined : props,
+ items: items instanceof codegen_1.Name ? undefined : items,
+ dynamicProps: props instanceof codegen_1.Name,
+ dynamicItems: items instanceof codegen_1.Name,
+ };
+ if (validate.source)
+ validate.source.evaluated = codegen_1.stringify(validate.evaluated);
+ }
+ sch.validate = validate;
+ return sch;
+ }
+ catch (e) {
+ delete sch.validate;
+ delete sch.validateName;
+ if (sourceCode)
+ this.logger.error("Error compiling schema, function code:", sourceCode);
+ // console.log("\n\n\n *** \n", sourceCode, this.opts)
+ throw e;
+ }
+ finally {
+ this._compilations.delete(sch);
+ }
+}
+exports.compileSchema = compileSchema;
+function resolveRef(root, baseId, ref) {
+ var _a;
+ ref = resolve_1.resolveUrl(baseId, ref);
+ const schOrFunc = root.refs[ref];
+ if (schOrFunc)
+ return schOrFunc;
+ let _sch = resolve.call(this, root, ref);
+ if (_sch === undefined) {
+ const schema = (_a = root.localRefs) === null || _a === void 0 ? void 0 : _a[ref]; // TODO maybe localRefs should hold SchemaEnv
+ if (schema)
+ _sch = new SchemaEnv({ schema, root, baseId });
+ }
+ if (_sch === undefined)
+ return;
+ return (root.refs[ref] = inlineOrCompile.call(this, _sch));
+}
+exports.resolveRef = resolveRef;
+function inlineOrCompile(sch) {
+ if (resolve_1.inlineRef(sch.schema, this.opts.inlineRefs))
+ return sch.schema;
+ return sch.validate ? sch : compileSchema.call(this, sch);
+}
+// Index of schema compilation in the currently compiled list
+function getCompilingSchema(schEnv) {
+ for (const sch of this._compilations) {
+ if (sameSchemaEnv(sch, schEnv))
+ return sch;
+ }
+}
+exports.getCompilingSchema = getCompilingSchema;
+function sameSchemaEnv(s1, s2) {
+ return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
+}
+// resolve and compile the references ($ref)
+// TODO returns AnySchemaObject (if the schema can be inlined) or validation function
+function resolve(root, // information about the root schema for the current schema
+ref // reference to resolve
+) {
+ let sch;
+ while (typeof (sch = this.refs[ref]) == "string")
+ ref = sch;
+ return sch || this.schemas[ref] || resolveSchema.call(this, root, ref);
+}
+// Resolve schema, its root and baseId
+function resolveSchema(root, // root object with properties schema, refs TODO below SchemaEnv is assigned to it
+ref // reference to resolve
+) {
+ const p = URI.parse(ref);
+ const refPath = resolve_1._getFullPath(p);
+ let baseId = resolve_1.getFullPath(root.baseId);
+ // TODO `Object.keys(root.schema).length > 0` should not be needed - but removing breaks 2 tests
+ if (Object.keys(root.schema).length > 0 && refPath === baseId) {
+ return getJsonPointer.call(this, p, root);
+ }
+ const id = resolve_1.normalizeId(refPath);
+ const schOrRef = this.refs[id] || this.schemas[id];
+ if (typeof schOrRef == "string") {
+ const sch = resolveSchema.call(this, root, schOrRef);
+ if (typeof (sch === null || sch === void 0 ? void 0 : sch.schema) !== "object")
+ return;
+ return getJsonPointer.call(this, p, sch);
+ }
+ if (typeof (schOrRef === null || schOrRef === void 0 ? void 0 : schOrRef.schema) !== "object")
+ return;
+ if (!schOrRef.validate)
+ compileSchema.call(this, schOrRef);
+ if (id === resolve_1.normalizeId(ref)) {
+ const { schema } = schOrRef;
+ if (schema.$id)
+ baseId = resolve_1.resolveUrl(baseId, schema.$id);
+ return new SchemaEnv({ schema, root, baseId });
+ }
+ return getJsonPointer.call(this, p, schOrRef);
+}
+exports.resolveSchema = resolveSchema;
+const PREVENT_SCOPE_CHANGE = new Set([
+ "properties",
+ "patternProperties",
+ "enum",
+ "dependencies",
+ "definitions",
+]);
+function getJsonPointer(parsedRef, { baseId, schema, root }) {
+ var _a;
+ if (((_a = parsedRef.fragment) === null || _a === void 0 ? void 0 : _a[0]) !== "/")
+ return;
+ for (const part of parsedRef.fragment.slice(1).split("/")) {
+ if (typeof schema == "boolean")
+ return;
+ schema = schema[util_1.unescapeFragment(part)];
+ if (schema === undefined)
+ return;
+ // TODO PREVENT_SCOPE_CHANGE could be defined in keyword def?
+ if (!PREVENT_SCOPE_CHANGE.has(part) && typeof schema == "object" && schema.$id) {
+ baseId = resolve_1.resolveUrl(baseId, schema.$id);
+ }
+ }
+ let env;
+ if (typeof schema != "boolean" && schema.$ref && !util_1.schemaHasRulesButRef(schema, this.RULES)) {
+ const $ref = resolve_1.resolveUrl(baseId, schema.$ref);
+ env = resolveSchema.call(this, root, $ref);
+ }
+ // even though resolution failed we need to return SchemaEnv to throw exception
+ // so that compileAsync loads missing schema.
+ env = env || new SchemaEnv({ schema, root, baseId });
+ if (env.schema !== env.root.schema)
+ return env;
+ return undefined;
+}
+//# sourceMappingURL=index.js.map
\ No newline at end of file
projects / dotfiles / .git / blobdiff