@rudderstack/integrations-lib
Version:
218 lines • 27.6 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.JsonSchemaGenerator = void 0;
/* eslint-disable no-plusplus */
const jsonschema_1 = require("jsonschema");
/**
* Utility for generating and validating JSON Schemas from data.
*/
class JsonSchemaGenerator {
/**
* Validates the provided data against the given JSON Schema.
*
* @param data - The data to validate.
* @param schema - The JSON Schema to use for validation.
* @throws Error if the validation fails.
*/
static validate(data, schema) {
const result = this.validator.validate(data, schema);
if (!result.valid) {
throw new Error(`Validation failed: ${result.errors.join(', ')}`);
}
}
/**
* Generates a JSON Schema for the given data.
*
* @param data - The data for which to generate a JSON Schema.
* @param options - Generation options.
* @returns The generated JSON Schema.
*/
static generate(data, options = {}) {
return this.buildSchema(data, options);
}
// ─── PRIVATE HELPERS ────────────────────────────────────────────
/**
* Determines the primitive type of a value.
*
* @param data - The data whose type is to be inferred.
* @returns A string representing the type.
*/
static inferType(data) {
if (data === null)
return 'null';
if (Array.isArray(data))
return 'array';
if (typeof data === 'object')
return 'object';
return typeof data;
}
/**
* Recursively builds a JSON Schema from the provided data.
*
* @param data - The data to interpret.
* @param options - Generation options.
* @returns A JSON Schema object.
*/
static buildSchema(data, options) {
const type = this.inferType(data);
switch (type) {
case 'null':
return { type: 'null' };
case 'array':
return this.buildArraySchema(data, options);
case 'object':
return this.buildObjectSchema(data, options);
default:
return { type };
}
}
/**
* Checks if all types in an array are one of the primitive types:
* string, number, or boolean.
*
* @param types - An array of type strings.
* @returns True if every type is primitive.
*/
static allTypesArePrimitive(types) {
return types.every((type) => ['string', 'number', 'boolean'].includes(type));
}
/**
* Generates a JSON Schema for an array.
*
* @param data - The array data.
* @param options - Generation options.
* @returns The JSON Schema corresponding to the array data.
*/
static buildArraySchema(data, options) {
if (data.length === 0) {
return { type: 'array', items: { type: 'any' } };
}
const types = data.map(this.inferType);
if (this.allTypesArePrimitive(types)) {
const uniqueTypes = Array.from(new Set(types));
if (uniqueTypes.length === 1) {
return {
type: 'array',
items: {
type: uniqueTypes[0],
...(uniqueTypes[0] === 'string' && options.detectEnums
? { enum: Array.from(new Set(data)) }
: {}),
},
};
}
return { type: 'array', items: { type: uniqueTypes } };
}
return this.buildMixedArraySchema(data, options);
}
/**
* Generates a JSON Schema for an array containing mixed types.
*
* @param data - The array data.
* @param options - Generation options.
* @returns The JSON Schema with an "anyOf" clause.
*/
static buildMixedArraySchema(data, options) {
const schemas = data.map((item) => this.buildSchema(item, options));
const uniqueSchemas = this.mergeSimilarSchemas(schemas);
return {
type: 'array',
items: uniqueSchemas.length === 1 ? uniqueSchemas[0] : { anyOf: uniqueSchemas },
};
}
/**
* Generates a JSON Schema for an object.
*
* @param data - The object data.
* @param options - Generation options.
* @returns The JSON Schema for the object.
*/
static buildObjectSchema(data, options) {
const properties = {};
const required = [];
const { requireAll = false } = options;
Object.entries(data).forEach(([key, value]) => {
properties[key] = this.buildSchema(value, options);
if (requireAll)
required.push(key);
});
return {
type: 'object',
properties,
...(required.length > 0 ? { required } : {}),
};
}
/**
* Attempts to merge two JSON Schemas. Merging is only successful if both schemas have the same type
* and there are no conflicts within defined properties.
*
* @param schemaA - The first JSON Schema.
* @param schemaB - The second JSON Schema.
* @returns The merged schema if successful; otherwise, null.
*/
static mergeTwoSchemas(schemaA, schemaB) {
if (schemaA.type !== schemaB.type)
return null;
const propsA = schemaA.properties || {};
const propsB = schemaB.properties || {};
const allKeys = Array.from(new Set([...Object.keys(propsA), ...Object.keys(propsB)]));
const hasConflict = allKeys.some((key) => key in propsA &&
key in propsB &&
JSON.stringify(propsA[key]) !== JSON.stringify(propsB[key]));
if (hasConflict)
return null;
const mergedProperties = allKeys.reduce((acc, key) => {
acc[key] = propsA[key] || propsB[key];
return acc;
}, {});
// A property is required in the merged schema only if it was required in both.
const requiredA = new Set(schemaA.required || []);
const requiredMerged = (schemaB.required || []).filter((field) => requiredA.has(field));
return {
...schemaA,
...schemaB,
type: schemaA.type,
...(Object.keys(mergedProperties).length > 0 ? { properties: mergedProperties } : {}),
...(requiredMerged.length > 0 ? { required: requiredMerged } : {}),
};
}
/**
* Merges an array of JSON Schemas. Schemas with the same type and non-conflicting
* definitions are merged together.
*
* @param schemas - The list of schemas to merge.
* @returns A deduplicated list of merged schemas.
*/
static mergeSimilarSchemas(schemas) {
if (schemas.length <= 1)
return [...schemas];
let mergedSchemas = [...schemas];
// Attempt one merge pass
const attemptMerge = (schemasList) => {
for (let i = 0; i < schemasList.length; i++) {
for (let j = i + 1; j < schemasList.length; j++) {
const merged = this.mergeTwoSchemas(schemasList[i], schemasList[j]);
if (merged) {
const newSchemas = [
...schemasList.slice(0, i),
merged,
...schemasList.slice(i + 1, j),
...schemasList.slice(j + 1),
];
return { schemas: newSchemas, merged: true };
}
}
}
return { schemas: schemasList, merged: false };
};
let result = attemptMerge(mergedSchemas);
while (result.merged) {
mergedSchemas = result.schemas;
result = attemptMerge(mergedSchemas);
}
return mergedSchemas;
}
}
exports.JsonSchemaGenerator = JsonSchemaGenerator;
JsonSchemaGenerator.validator = new jsonschema_1.Validator();
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"json-schema-generator.js","sourceRoot":"","sources":["../../src/utils/json-schema-generator.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable no-plusplus */\nimport { Validator } from 'jsonschema';\n\n/**\n * Type definition for a JSON Schema.\n */\nexport type JSONSchemaType = {\n  type?: string | string[];\n  properties?: { [key: string]: JSONSchemaType };\n  items?: JSONSchemaType;\n  required?: string[];\n  enum?: any[];\n  anyOf?: JSONSchemaType[];\n};\n\n/**\n * Options for generating JSON Schemas.\n */\nexport type JsonSchemaGeneratorOptions = {\n  /** If true, marks every property in an object as required */\n  requireAll?: boolean;\n  /** If true, attempts to detect and include enums for arrays of strings */\n  detectEnums?: boolean;\n};\n\n/**\n * Utility for generating and validating JSON Schemas from data.\n */\nexport class JsonSchemaGenerator {\n  private static validator = new Validator();\n\n  /**\n   * Validates the provided data against the given JSON Schema.\n   *\n   * @param data - The data to validate.\n   * @param schema - The JSON Schema to use for validation.\n   * @throws Error if the validation fails.\n   */\n  public static validate(data: unknown, schema: JSONSchemaType): void {\n    const result = this.validator.validate(data, schema);\n    if (!result.valid) {\n      throw new Error(`Validation failed: ${result.errors.join(', ')}`);\n    }\n  }\n\n  /**\n   * Generates a JSON Schema for the given data.\n   *\n   * @param data - The data for which to generate a JSON Schema.\n   * @param options - Generation options.\n   * @returns The generated JSON Schema.\n   */\n  public static generate(data: unknown, options: JsonSchemaGeneratorOptions = {}): JSONSchemaType {\n    return this.buildSchema(data, options);\n  }\n\n  // ─── PRIVATE HELPERS ────────────────────────────────────────────\n\n  /**\n   * Determines the primitive type of a value.\n   *\n   * @param data - The data whose type is to be inferred.\n   * @returns A string representing the type.\n   */\n  private static inferType(data: unknown): string {\n    if (data === null) return 'null';\n    if (Array.isArray(data)) return 'array';\n    if (typeof data === 'object') return 'object';\n    return typeof data;\n  }\n\n  /**\n   * Recursively builds a JSON Schema from the provided data.\n   *\n   * @param data - The data to interpret.\n   * @param options - Generation options.\n   * @returns A JSON Schema object.\n   */\n  private static buildSchema(data: unknown, options: JsonSchemaGeneratorOptions): JSONSchemaType {\n    const type = this.inferType(data);\n    switch (type) {\n      case 'null':\n        return { type: 'null' };\n      case 'array':\n        return this.buildArraySchema(data as unknown[], options);\n      case 'object':\n        return this.buildObjectSchema(data as Record<string, unknown>, options);\n      default:\n        return { type };\n    }\n  }\n\n  /**\n   * Checks if all types in an array are one of the primitive types:\n   * string, number, or boolean.\n   *\n   * @param types - An array of type strings.\n   * @returns True if every type is primitive.\n   */\n  private static allTypesArePrimitive(types: string[]): boolean {\n    return types.every((type) => ['string', 'number', 'boolean'].includes(type));\n  }\n\n  /**\n   * Generates a JSON Schema for an array.\n   *\n   * @param data - The array data.\n   * @param options - Generation options.\n   * @returns The JSON Schema corresponding to the array data.\n   */\n  private static buildArraySchema(\n    data: unknown[],\n    options: JsonSchemaGeneratorOptions,\n  ): JSONSchemaType {\n    if (data.length === 0) {\n      return { type: 'array', items: { type: 'any' } };\n    }\n\n    const types = data.map(this.inferType);\n    if (this.allTypesArePrimitive(types)) {\n      const uniqueTypes = Array.from(new Set(types));\n      if (uniqueTypes.length === 1) {\n        return {\n          type: 'array',\n          items: {\n            type: uniqueTypes[0],\n            ...(uniqueTypes[0] === 'string' && options.detectEnums\n              ? { enum: Array.from(new Set(data)) }\n              : {}),\n          },\n        };\n      }\n      return { type: 'array', items: { type: uniqueTypes } };\n    }\n\n    return this.buildMixedArraySchema(data, options);\n  }\n\n  /**\n   * Generates a JSON Schema for an array containing mixed types.\n   *\n   * @param data - The array data.\n   * @param options - Generation options.\n   * @returns The JSON Schema with an \"anyOf\" clause.\n   */\n  private static buildMixedArraySchema(\n    data: unknown[],\n    options: JsonSchemaGeneratorOptions,\n  ): JSONSchemaType {\n    const schemas = data.map((item) => this.buildSchema(item, options));\n    const uniqueSchemas = this.mergeSimilarSchemas(schemas);\n    return {\n      type: 'array',\n      items: uniqueSchemas.length === 1 ? uniqueSchemas[0] : { anyOf: uniqueSchemas },\n    };\n  }\n\n  /**\n   * Generates a JSON Schema for an object.\n   *\n   * @param data - The object data.\n   * @param options - Generation options.\n   * @returns The JSON Schema for the object.\n   */\n  private static buildObjectSchema(\n    data: Record<string, unknown>,\n    options: JsonSchemaGeneratorOptions,\n  ): JSONSchemaType {\n    const properties: { [key: string]: JSONSchemaType } = {};\n    const required: string[] = [];\n    const { requireAll = false } = options;\n\n    Object.entries(data).forEach(([key, value]) => {\n      properties[key] = this.buildSchema(value, options);\n      if (requireAll) required.push(key);\n    });\n\n    return {\n      type: 'object',\n      properties,\n      ...(required.length > 0 ? { required } : {}),\n    };\n  }\n\n  /**\n   * Attempts to merge two JSON Schemas. Merging is only successful if both schemas have the same type\n   * and there are no conflicts within defined properties.\n   *\n   * @param schemaA - The first JSON Schema.\n   * @param schemaB - The second JSON Schema.\n   * @returns The merged schema if successful; otherwise, null.\n   */\n  private static mergeTwoSchemas(\n    schemaA: JSONSchemaType,\n    schemaB: JSONSchemaType,\n  ): JSONSchemaType | null {\n    if (schemaA.type !== schemaB.type) return null;\n\n    const propsA = schemaA.properties || {};\n    const propsB = schemaB.properties || {};\n    const allKeys = Array.from(new Set([...Object.keys(propsA), ...Object.keys(propsB)]));\n\n    const hasConflict = allKeys.some(\n      (key) =>\n        key in propsA &&\n        key in propsB &&\n        JSON.stringify(propsA[key]) !== JSON.stringify(propsB[key]),\n    );\n    if (hasConflict) return null;\n\n    const mergedProperties = allKeys.reduce((acc, key) => {\n      acc[key] = propsA[key] || propsB[key];\n      return acc;\n    }, {} as { [key: string]: JSONSchemaType });\n\n    // A property is required in the merged schema only if it was required in both.\n    const requiredA = new Set(schemaA.required || []);\n    const requiredMerged = (schemaB.required || []).filter((field) => requiredA.has(field));\n\n    return {\n      ...schemaA,\n      ...schemaB,\n      type: schemaA.type,\n      ...(Object.keys(mergedProperties).length > 0 ? { properties: mergedProperties } : {}),\n      ...(requiredMerged.length > 0 ? { required: requiredMerged } : {}),\n    };\n  }\n\n  /**\n   * Merges an array of JSON Schemas. Schemas with the same type and non-conflicting\n   * definitions are merged together.\n   *\n   * @param schemas - The list of schemas to merge.\n   * @returns A deduplicated list of merged schemas.\n   */\n  private static mergeSimilarSchemas(schemas: JSONSchemaType[]): JSONSchemaType[] {\n    if (schemas.length <= 1) return [...schemas];\n\n    let mergedSchemas = [...schemas];\n\n    // Attempt one merge pass\n    const attemptMerge = (\n      schemasList: JSONSchemaType[],\n    ): { schemas: JSONSchemaType[]; merged: boolean } => {\n      for (let i = 0; i < schemasList.length; i++) {\n        for (let j = i + 1; j < schemasList.length; j++) {\n          const merged = this.mergeTwoSchemas(schemasList[i], schemasList[j]);\n          if (merged) {\n            const newSchemas = [\n              ...schemasList.slice(0, i),\n              merged,\n              ...schemasList.slice(i + 1, j),\n              ...schemasList.slice(j + 1),\n            ];\n            return { schemas: newSchemas, merged: true };\n          }\n        }\n      }\n      return { schemas: schemasList, merged: false };\n    };\n\n    let result = attemptMerge(mergedSchemas);\n    while (result.merged) {\n      mergedSchemas = result.schemas;\n      result = attemptMerge(mergedSchemas);\n    }\n\n    return mergedSchemas;\n  }\n}\n"]}