json-schema-migrate-x/lib/index.cjs

Migrate JSON-Schema `draft-04` to `draft-07`, `draft-2019-09` or `draft-2020-12`

'use strict';

var _2019_js = require('ajv/dist/2019.js');
var _2020_js = require('ajv/dist/2020.js');

const DRAFT_7_SCHEMA = "http://json-schema.org/draft-07/schema";
const DRAFT_2019_SCHEMA = "https://json-schema.org/draft/2019-09/schema";
const DRAFT_2020_SCHEMA = "https://json-schema.org/draft/2020-12/schema";

function constantResultSchema(schema) {
  const keys = Object.keys(schema);
  if (keys.length === 0) {
    return true;
  }
  if (keys.length === 1 && keys[0] === "not") {
    const valid = constantResultSchema(schema.not);
    if (typeof valid == "boolean") {
      return !valid;
    }
  }
}
function metaSchema(version) {
  switch (version) {
    case "draft7": {
      return DRAFT_7_SCHEMA;
    }
    case "draft2019": {
      return DRAFT_2019_SCHEMA;
    }
    case "draft2020": {
      return DRAFT_2020_SCHEMA;
    }
  }
}

var __defProp$1 = Object.defineProperty;
var __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;
var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
var __propIsEnum$1 = Object.prototype.propertyIsEnumerable;
var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __spreadValues$1 = (a, b) => {
  for (var prop in b || (b = {}))
    if (__hasOwnProp$1.call(b, prop))
      __defNormalProp$1(a, prop, b[prop]);
  if (__getOwnPropSymbols$1)
    for (var prop of __getOwnPropSymbols$1(b)) {
      if (__propIsEnum$1.call(b, prop))
        __defNormalProp$1(a, prop, b[prop]);
    }
  return a;
};
const ajvCache = {};
function getAjv(version = "draft2019") {
  const isDraft2020 = version === "draft2020";
  const cacheKey = isDraft2020 ? "draft2020" : "default";
  let ajv = ajvCache[cacheKey];
  if (ajv) {
    return ajv;
  }
  ajv = new (isDraft2020 ? _2020_js.Ajv2020 : _2019_js.Ajv2019)({ allErrors: true });
  ajv.addKeyword({
    keyword: "migrateSchema",
    schemaType: "string",
    modifying: true,
    metaSchema: { enum: ["draft7", "draft2019", "draft2020"] },
    // eslint-disable-next-line sonarjs/cognitive-complexity
    validate(version2, schema, _parentSchema, dataCxt) {
      if (typeof schema != "object") {
        return true;
      }
      if (dataCxt) {
        const { parentData, parentDataProperty } = dataCxt;
        const valid = constantResultSchema(schema);
        if (typeof valid == "boolean") {
          parentData[parentDataProperty] = valid;
          return true;
        }
      }
      const dsCopy = __spreadValues$1({}, schema);
      for (const key in dsCopy) {
        delete schema[key];
        switch (key) {
          case "id": {
            const { id } = dsCopy;
            if (typeof id !== "string") {
              throw new TypeError(
                `json-schema-migrate: schema id must be string`
              );
            }
            if ((version2 === "draft2019" || isDraft2020) && id.includes("#")) {
              const [$id, $anchor, ...rest] = id.split("#");
              if (rest.length > 0) {
                throw new Error(`json-schema-migrate: invalid schema id ${id}`);
              }
              if ($id) {
                schema.$id = $id;
              }
              if ($anchor && $anchor !== "/") {
                schema.$anchor = $anchor;
              }
            } else {
              schema.$id = id;
            }
            break;
          }
          case "$schema": {
            schema.$schema = metaSchema(version2);
            break;
          }
          case "constant": {
            schema.const = dsCopy.constant;
            break;
          }
          case "enum": {
            if (Array.isArray(dsCopy.enum) && dsCopy.enum.length === 1 && dsCopy.constant === void 0 && dsCopy.const === void 0) {
              schema.const = dsCopy.enum[0];
            } else {
              schema.enum = dsCopy.enum;
            }
            break;
          }
          case "exclusiveMaximum": {
            migrateExclusive(schema, key, "maximum");
            break;
          }
          case "exclusiveMinimum": {
            migrateExclusive(schema, key, "minimum");
            break;
          }
          case "maximum": {
            if (dsCopy.exclusiveMaximum !== true) {
              schema.maximum = dsCopy.maximum;
            }
            break;
          }
          case "minimum": {
            if (dsCopy.exclusiveMinimum !== true) {
              schema.minimum = dsCopy.minimum;
            }
            break;
          }
          case "dependencies": {
            const deps = dsCopy.dependencies;
            if (version2 === "draft7") {
              schema.dependencies = deps;
            } else {
              for (const prop in deps) {
                const kwd = Array.isArray(deps[prop]) ? "dependentRequired" : "dependentSchemas";
                schema[kwd] || (schema[kwd] = {});
                schema[kwd][prop] = deps[prop];
              }
            }
            break;
          }
          case "items": {
            if (isDraft2020 && Array.isArray(dsCopy.items)) {
              schema.prefixItems = dsCopy.items;
              if (dsCopy.additionalItems !== void 0) {
                schema.items = dsCopy.additionalItems;
              }
            } else {
              schema.items = dsCopy.items;
            }
            break;
          }
          case "additionalItems": {
            if (!isDraft2020) {
              schema.additionalItems = dsCopy.additionalItems;
            }
            break;
          }
          case "$recursiveAnchor": {
            if (isDraft2020) {
              schema.$dynamicAnchor = "meta";
            } else {
              schema.$recursiveAnchor = dsCopy.$recursiveAnchor;
            }
            break;
          }
          default: {
            schema[key] = dsCopy[key];
          }
        }
      }
      return true;
      function migrateExclusive(schema2, key, limit) {
        if (dsCopy[key] === true) {
          schema2[key] = dsCopy[limit];
        } else if (dsCopy[key] !== false && dsCopy[key] !== void 0) {
          ajv.logger.warn(`${key} is not boolean`);
        }
      }
    }
  });
  ajvCache[cacheKey] = ajv;
  return ajv;
}

var __defProp = Object.defineProperty;
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __propIsEnum = Object.prototype.propertyIsEnumerable;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __spreadValues = (a, b) => {
  for (var prop in b || (b = {}))
    if (__hasOwnProp.call(b, prop))
      __defNormalProp(a, prop, b[prop]);
  if (__getOwnPropSymbols)
    for (var prop of __getOwnPropSymbols(b)) {
      if (__propIsEnum.call(b, prop))
        __defNormalProp(a, prop, b[prop]);
    }
  return a;
};
function getMigrateSchema(version) {
  const isDraft2020 = version === "draft2020";
  const schema = isDraft2020 ? DRAFT_2020_SCHEMA : DRAFT_2019_SCHEMA;
  return __spreadValues({
    $id: `migrateSchema-${version}`,
    $schema: schema,
    allOf: [{ migrateSchema: version }, { $ref: schema }]
  }, isDraft2020 ? { $dynamicAnchor: "meta" } : { $recursiveAnchor: true });
}
function getMigrate(version) {
  let migrate;
  return (schema) => {
    migrate || (migrate = getAjv(version).compile(getMigrateSchema(version)));
    migrate(schema);
    schema.$schema || (schema.$schema = metaSchema(version));
  };
}

const draft7 = getMigrate("draft7");
const draft2019 = getMigrate("draft2019");
const draft2020 = getMigrate("draft2020");

exports.constantResultSchema = constantResultSchema;
exports.draft2019 = draft2019;
exports.draft2020 = draft2020;
exports.draft7 = draft7;
exports.getAjv = getAjv;
exports.getMigrate = getMigrate;
exports.getMigrateSchema = getMigrateSchema;
exports.metaSchema = metaSchema;