@rudderstack/integrations-lib 0.2.17 → 0.2.18

package/build/utils/index.d.ts

@@ -1,5 +1,7 @@
+export * from './json-schema-generator';
 export * from './json';
 export * from './misc';
 export * from './request';
 export * from './sem';
+export * from './tests';
 //# sourceMappingURL=index.d.ts.map

package/build/utils/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC;AACvB,cAAc,QAAQ,CAAC;AACvB,cAAc,WAAW,CAAC;AAC1B,cAAc,OAAO,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,QAAQ,CAAC;AACvB,cAAc,QAAQ,CAAC;AACvB,cAAc,WAAW,CAAC;AAC1B,cAAc,OAAO,CAAC;AACtB,cAAc,SAAS,CAAC"}

package/build/utils/index.js

@@ -14,8 +14,10 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./json-schema-generator"), exports);
 __exportStar(require("./json"), exports);
 __exportStar(require("./misc"), exports);
 __exportStar(require("./request"), exports);
 __exportStar(require("./sem"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdXRpbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLHlDQUF1QjtBQUN2Qix5Q0FBdUI7QUFDdkIsNENBQTBCO0FBQzFCLHdDQUFzQiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vanNvbic7XG5leHBvcnQgKiBmcm9tICcuL21pc2MnO1xuZXhwb3J0ICogZnJvbSAnLi9yZXF1ZXN0JztcbmV4cG9ydCAqIGZyb20gJy4vc2VtJztcbiJdfQ==
+__exportStar(require("./tests"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdXRpbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLDBEQUF3QztBQUN4Qyx5Q0FBdUI7QUFDdkIseUNBQXVCO0FBQ3ZCLDRDQUEwQjtBQUMxQix3Q0FBc0I7QUFDdEIsMENBQXdCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9qc29uLXNjaGVtYS1nZW5lcmF0b3InO1xuZXhwb3J0ICogZnJvbSAnLi9qc29uJztcbmV4cG9ydCAqIGZyb20gJy4vbWlzYyc7XG5leHBvcnQgKiBmcm9tICcuL3JlcXVlc3QnO1xuZXhwb3J0ICogZnJvbSAnLi9zZW0nO1xuZXhwb3J0ICogZnJvbSAnLi90ZXN0cyc7XG4iXX0=

package/build/utils/json-schema-generator.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Type definition for a JSON Schema.
+ */
+export type JSONSchemaType = {
+    type?: string | string[];
+    properties?: {
+        [key: string]: JSONSchemaType;
+    };
+    items?: JSONSchemaType;
+    required?: string[];
+    enum?: any[];
+    anyOf?: JSONSchemaType[];
+};
+/**
+ * Options for generating JSON Schemas.
+ */
+export type JsonSchemaGeneratorOptions = {
+    /** If true, marks every property in an object as required */
+    requireAll?: boolean;
+    /** If true, attempts to detect and include enums for arrays of strings */
+    detectEnums?: boolean;
+};
+/**
+ * Utility for generating and validating JSON Schemas from data.
+ */
+export declare class JsonSchemaGenerator {
+    private static validator;
+    /**
+     * 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: unknown, schema: JSONSchemaType): void;
+    /**
+     * 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: unknown, options?: JsonSchemaGeneratorOptions): JSONSchemaType;
+    /**
+     * Determines the primitive type of a value.
+     *
+     * @param data - The data whose type is to be inferred.
+     * @returns A string representing the type.
+     */
+    private static inferType;
+    /**
+     * Recursively builds a JSON Schema from the provided data.
+     *
+     * @param data - The data to interpret.
+     * @param options - Generation options.
+     * @returns A JSON Schema object.
+     */
+    private static buildSchema;
+    /**
+     * 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.
+     */
+    private static allTypesArePrimitive;
+    /**
+     * 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.
+     */
+    private static buildArraySchema;
+    /**
+     * 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.
+     */
+    private static buildMixedArraySchema;
+    /**
+     * Generates a JSON Schema for an object.
+     *
+     * @param data - The object data.
+     * @param options - Generation options.
+     * @returns The JSON Schema for the object.
+     */
+    private static buildObjectSchema;
+    /**
+     * 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.
+     */
+    private static mergeTwoSchemas;
+    /**
+     * 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.
+     */
+    private static mergeSimilarSchemas;
+}
+//# sourceMappingURL=json-schema-generator.d.ts.map

package/build/utils/json-schema-generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-schema-generator.d.ts","sourceRoot":"","sources":["../../src/utils/json-schema-generator.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IACzB,UAAU,CAAC,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,cAAc,CAAA;KAAE,CAAC;IAC/C,KAAK,CAAC,EAAE,cAAc,CAAC;IACvB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,IAAI,CAAC,EAAE,GAAG,EAAE,CAAC;IACb,KAAK,CAAC,EAAE,cAAc,EAAE,CAAC;CAC1B,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,0BAA0B,GAAG;IACvC,6DAA6D;IAC7D,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,0EAA0E;IAC1E,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB,CAAC;AAEF;;GAEG;AACH,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,MAAM,CAAC,SAAS,CAAmB;IAE3C;;;;;;OAMG;WACW,QAAQ,CAAC,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,cAAc,GAAG,IAAI;IAOnE;;;;;;OAMG;WACW,QAAQ,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,GAAE,0BAA+B,GAAG,cAAc;IAM/F;;;;;OAKG;IACH,OAAO,CAAC,MAAM,CAAC,SAAS;IAOxB;;;;;;OAMG;IACH,OAAO,CAAC,MAAM,CAAC,WAAW;IAc1B;;;;;;OAMG;IACH,OAAO,CAAC,MAAM,CAAC,oBAAoB;IAInC;;;;;;OAMG;IACH,OAAO,CAAC,MAAM,CAAC,gBAAgB;IA4B/B;;;;;;OAMG;IACH,OAAO,CAAC,MAAM,CAAC,qBAAqB;IAYpC;;;;;;OAMG;IACH,OAAO,CAAC,MAAM,CAAC,iBAAiB;IAoBhC;;;;;;;OAOG;IACH,OAAO,CAAC,MAAM,CAAC,eAAe;IAoC9B;;;;;;OAMG;IACH,OAAO,CAAC,MAAM,CAAC,mBAAmB;CAkCnC"}

package/build/utils/json-schema-generator.js

@@ -0,0 +1,218 @@
+"use strict";
+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":";;;AAAA,gCAAgC;AAChC,2CAAuC;AAwBvC;;GAEG;AACH,MAAa,mBAAmB;IAG9B;;;;;;OAMG;IACI,MAAM,CAAC,QAAQ,CAAC,IAAa,EAAE,MAAsB;QAC1D,MAAM,MAAM,GAAG,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QACrD,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE;YACjB,MAAM,IAAI,KAAK,CAAC,sBAAsB,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;SACnE;IACH,CAAC;IAED;;;;;;OAMG;IACI,MAAM,CAAC,QAAQ,CAAC,IAAa,EAAE,UAAsC,EAAE;QAC5E,OAAO,IAAI,CAAC,WAAW,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;IACzC,CAAC;IAED,mEAAmE;IAEnE;;;;;OAKG;IACK,MAAM,CAAC,SAAS,CAAC,IAAa;QACpC,IAAI,IAAI,KAAK,IAAI;YAAE,OAAO,MAAM,CAAC;QACjC,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC;YAAE,OAAO,OAAO,CAAC;QACxC,IAAI,OAAO,IAAI,KAAK,QAAQ;YAAE,OAAO,QAAQ,CAAC;QAC9C,OAAO,OAAO,IAAI,CAAC;IACrB,CAAC;IAED;;;;;;OAMG;IACK,MAAM,CAAC,WAAW,CAAC,IAAa,EAAE,OAAmC;QAC3E,MAAM,IAAI,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;QAClC,QAAQ,IAAI,EAAE;YACZ,KAAK,MAAM;gBACT,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC;YAC1B,KAAK,OAAO;gBACV,OAAO,IAAI,CAAC,gBAAgB,CAAC,IAAiB,EAAE,OAAO,CAAC,CAAC;YAC3D,KAAK,QAAQ;gBACX,OAAO,IAAI,CAAC,iBAAiB,CAAC,IAA+B,EAAE,OAAO,CAAC,CAAC;YAC1E;gBACE,OAAO,EAAE,IAAI,EAAE,CAAC;SACnB;IACH,CAAC;IAED;;;;;;OAMG;IACK,MAAM,CAAC,oBAAoB,CAAC,KAAe;QACjD,OAAO,KAAK,CAAC,KAAK,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC;IAC/E,CAAC;IAED;;;;;;OAMG;IACK,MAAM,CAAC,gBAAgB,CAC7B,IAAe,EACf,OAAmC;QAEnC,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE;YACrB,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC;SAClD;QAED,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QACvC,IAAI,IAAI,CAAC,oBAAoB,CAAC,KAAK,CAAC,EAAE;YACpC,MAAM,WAAW,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC;YAC/C,IAAI,WAAW,CAAC,MAAM,KAAK,CAAC,EAAE;gBAC5B,OAAO;oBACL,IAAI,EAAE,OAAO;oBACb,KAAK,EAAE;wBACL,IAAI,EAAE,WAAW,CAAC,CAAC,CAAC;wBACpB,GAAG,CAAC,WAAW,CAAC,CAAC,CAAC,KAAK,QAAQ,IAAI,OAAO,CAAC,WAAW;4BACpD,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,CAAC,IAAI,GAAG,CAAC,IAAI,CAAC,CAAC,EAAE;4BACrC,CAAC,CAAC,EAAE,CAAC;qBACR;iBACF,CAAC;aACH;YACD,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,WAAW,EAAE,EAAE,CAAC;SACxD;QAED,OAAO,IAAI,CAAC,qBAAqB,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;IACnD,CAAC;IAED;;;;;;OAMG;IACK,MAAM,CAAC,qBAAqB,CAClC,IAAe,EACf,OAAmC;QAEnC,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC;QACpE,MAAM,aAAa,GAAG,IAAI,CAAC,mBAAmB,CAAC,OAAO,CAAC,CAAC;QACxD,OAAO;YACL,IAAI,EAAE,OAAO;YACb,KAAK,EAAE,aAAa,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,aAAa,EAAE;SAChF,CAAC;IACJ,CAAC;IAED;;;;;;OAMG;IACK,MAAM,CAAC,iBAAiB,CAC9B,IAA6B,EAC7B,OAAmC;QAEnC,MAAM,UAAU,GAAsC,EAAE,CAAC;QACzD,MAAM,QAAQ,GAAa,EAAE,CAAC;QAC9B,MAAM,EAAE,UAAU,GAAG,KAAK,EAAE,GAAG,OAAO,CAAC;QAEvC,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,EAAE;YAC5C,UAAU,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,WAAW,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;YACnD,IAAI,UAAU;gBAAE,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACrC,CAAC,CAAC,CAAC;QAEH,OAAO;YACL,IAAI,EAAE,QAAQ;YACd,UAAU;YACV,GAAG,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;SAC7C,CAAC;IACJ,CAAC;IAED;;;;;;;OAOG;IACK,MAAM,CAAC,eAAe,CAC5B,OAAuB,EACvB,OAAuB;QAEvB,IAAI,OAAO,CAAC,IAAI,KAAK,OAAO,CAAC,IAAI;YAAE,OAAO,IAAI,CAAC;QAE/C,MAAM,MAAM,GAAG,OAAO,CAAC,UAAU,IAAI,EAAE,CAAC;QACxC,MAAM,MAAM,GAAG,OAAO,CAAC,UAAU,IAAI,EAAE,CAAC;QACxC,MAAM,OAAO,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,GAAG,CAAC,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,GAAG,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;QAEtF,MAAM,WAAW,GAAG,OAAO,CAAC,IAAI,CAC9B,CAAC,GAAG,EAAE,EAAE,CACN,GAAG,IAAI,MAAM;YACb,GAAG,IAAI,MAAM;YACb,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAC9D,CAAC;QACF,IAAI,WAAW;YAAE,OAAO,IAAI,CAAC;QAE7B,MAAM,gBAAgB,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,GAAG,EAAE,EAAE;YACnD,GAAG,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,GAAG,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC;YACtC,OAAO,GAAG,CAAC;QACb,CAAC,EAAE,EAAuC,CAAC,CAAC;QAE5C,+EAA+E;QAC/E,MAAM,SAAS,GAAG,IAAI,GAAG,CAAC,OAAO,CAAC,QAAQ,IAAI,EAAE,CAAC,CAAC;QAClD,MAAM,cAAc,GAAG,CAAC,OAAO,CAAC,QAAQ,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,SAAS,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC;QAExF,OAAO;YACL,GAAG,OAAO;YACV,GAAG,OAAO;YACV,IAAI,EAAE,OAAO,CAAC,IAAI;YAClB,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,UAAU,EAAE,gBAAgB,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YACrF,GAAG,CAAC,cAAc,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;SACnE,CAAC;IACJ,CAAC;IAED;;;;;;OAMG;IACK,MAAM,CAAC,mBAAmB,CAAC,OAAyB;QAC1D,IAAI,OAAO,CAAC,MAAM,IAAI,CAAC;YAAE,OAAO,CAAC,GAAG,OAAO,CAAC,CAAC;QAE7C,IAAI,aAAa,GAAG,CAAC,GAAG,OAAO,CAAC,CAAC;QAEjC,yBAAyB;QACzB,MAAM,YAAY,GAAG,CACnB,WAA6B,EACmB,EAAE;YAClD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,WAAW,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;gBAC3C,KAAK,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,WAAW,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;oBAC/C,MAAM,MAAM,GAAG,IAAI,CAAC,eAAe,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;oBACpE,IAAI,MAAM,EAAE;wBACV,MAAM,UAAU,GAAG;4BACjB,GAAG,WAAW,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC;4BAC1B,MAAM;4BACN,GAAG,WAAW,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;4BAC9B,GAAG,WAAW,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC;yBAC5B,CAAC;wBACF,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC;qBAC9C;iBACF;aACF;YACD,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC;QACjD,CAAC,CAAC;QAEF,IAAI,MAAM,GAAG,YAAY,CAAC,aAAa,CAAC,CAAC;QACzC,OAAO,MAAM,CAAC,MAAM,EAAE;YACpB,aAAa,GAAG,MAAM,CAAC,OAAO,CAAC;YAC/B,MAAM,GAAG,YAAY,CAAC,aAAa,CAAC,CAAC;SACtC;QAED,OAAO,aAAa,CAAC;IACvB,CAAC;;AAhPH,kDAiPC;AAhPgB,6BAAS,GAAG,IAAI,sBAAS,EAAE,CAAC","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"]}

package/build/utils/json-schema-generator.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=json-schema-generator.test.d.ts.map

package/build/utils/json-schema-generator.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-schema-generator.test.d.ts","sourceRoot":"","sources":["../../src/utils/json-schema-generator.test.ts"],"names":[],"mappings":""}

package/build/utils/json-schema-generator.test.js

@@ -0,0 +1,368 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const json_schema_generator_1 = require("./json-schema-generator");
+const tests_1 = require("./tests");
+describe('JsonSchemaGenerator', () => {
+    describe('generate()', () => {
+        const testCases = [
+            {
+                name: 'primitive - string',
+                input: 'test',
+                expected: { type: 'string' },
+            },
+            {
+                name: 'primitive - number',
+                input: 123,
+                expected: { type: 'number' },
+            },
+            {
+                name: 'primitive - boolean',
+                input: true,
+                expected: { type: 'boolean' },
+            },
+            {
+                name: 'primitive - null',
+                input: null,
+                expected: { type: 'null' },
+            },
+            {
+                name: 'empty array',
+                input: [],
+                expected: { type: 'array', items: { type: 'any' } },
+            },
+            {
+                name: 'simple array of numbers',
+                input: [1, 2, 3],
+                expected: { type: 'array', items: { type: 'number' } },
+            },
+            {
+                name: 'enum detection from array',
+                input: ['red', 'green', 'red', 'blue'],
+                options: { detectEnums: true },
+                expected: {
+                    type: 'array',
+                    items: {
+                        type: 'string',
+                        enum: ['red', 'green', 'blue'],
+                    },
+                },
+            },
+            {
+                name: 'enum detection disabled',
+                input: ['red', 'green', 'red', 'blue'],
+                options: { detectEnums: false },
+                expected: { type: 'array', items: { type: 'string' } },
+            },
+            {
+                name: 'simple object',
+                input: { name: 'John', age: 30 },
+                expected: {
+                    type: 'object',
+                    properties: {
+                        name: { type: 'string' },
+                        age: { type: 'number' },
+                    },
+                },
+            },
+            {
+                name: 'object with required properties',
+                input: { name: 'John', age: 30 },
+                options: { requireAll: true },
+                expected: {
+                    type: 'object',
+                    properties: {
+                        name: { type: 'string' },
+                        age: { type: 'number' },
+                    },
+                    required: ['name', 'age'],
+                },
+            },
+            {
+                name: 'nested object',
+                input: {
+                    name: 'John',
+                    address: {
+                        street: '123 Main St',
+                        city: 'Boston',
+                    },
+                },
+                expected: {
+                    type: 'object',
+                    properties: {
+                        name: { type: 'string' },
+                        address: {
+                            type: 'object',
+                            properties: {
+                                street: { type: 'string' },
+                                city: { type: 'string' },
+                            },
+                        },
+                    },
+                },
+            },
+            {
+                name: 'mixed array of primitives',
+                input: [1, 'test', true],
+                expected: {
+                    type: 'array',
+                    items: { type: ['number', 'string', 'boolean'] },
+                },
+            },
+            {
+                name: 'object with array',
+                input: {
+                    name: 'John',
+                    hobbies: ['reading', 'gaming'],
+                },
+                expected: {
+                    type: 'object',
+                    properties: {
+                        name: { type: 'string' },
+                        hobbies: { type: 'array', items: { type: 'string' } },
+                    },
+                },
+            },
+            {
+                name: 'array of objects',
+                input: [
+                    { id: 1, name: 'John' },
+                    { id: 2, name: 'Jane' },
+                ],
+                expected: {
+                    type: 'array',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            id: { type: 'number' },
+                            name: { type: 'string' },
+                        },
+                    },
+                },
+            },
+            {
+                name: 'mixed array with objects',
+                input: [123, 'test', { name: 'John' }, true],
+                expected: {
+                    type: 'array',
+                    items: {
+                        anyOf: [
+                            { type: 'number' },
+                            { type: 'string' },
+                            {
+                                type: 'object',
+                                properties: { name: { type: 'string' } },
+                            },
+                            { type: 'boolean' },
+                        ],
+                    },
+                },
+            },
+            {
+                name: 'array of arrays',
+                input: [
+                    [1, 2],
+                    [3, 4],
+                ],
+                expected: {
+                    type: 'array',
+                    items: { type: 'array', items: { type: 'number' } },
+                },
+            },
+            {
+                name: 'complex nested object',
+                input: {
+                    id: 1,
+                    user: {
+                        name: 'John',
+                        contacts: {
+                            email: ['john@example.com', 'john.doe@example.com'],
+                            phone: null,
+                        },
+                        preferences: {
+                            notifications: true,
+                            theme: {
+                                dark: false,
+                                colors: ['blue', 'green'],
+                            },
+                        },
+                    },
+                },
+                options: { requireAll: true },
+                expected: {
+                    type: 'object',
+                    required: ['id', 'user'],
+                    properties: {
+                        id: { type: 'number' },
+                        user: {
+                            type: 'object',
+                            required: ['name', 'contacts', 'preferences'],
+                            properties: {
+                                name: { type: 'string' },
+                                contacts: {
+                                    type: 'object',
+                                    required: ['email', 'phone'],
+                                    properties: {
+                                        email: { type: 'array', items: { type: 'string' } },
+                                        phone: { type: 'null' },
+                                    },
+                                },
+                                preferences: {
+                                    type: 'object',
+                                    required: ['notifications', 'theme'],
+                                    properties: {
+                                        notifications: { type: 'boolean' },
+                                        theme: {
+                                            type: 'object',
+                                            required: ['dark', 'colors'],
+                                            properties: {
+                                                dark: { type: 'boolean' },
+                                                colors: { type: 'array', items: { type: 'string' } },
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+            {
+                name: 'string array with no enum detection',
+                input: ['red', 'red', 'blue'],
+                options: { detectEnums: false },
+                expected: { type: 'array', items: { type: 'string' } },
+            },
+            {
+                name: 'array with mixed object types that can be merged',
+                input: [
+                    { id: 1, name: 'John' },
+                    { id: 2, name: 'Jane', age: 30 },
+                ],
+                expected: {
+                    type: 'array',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            id: { type: 'number' },
+                            name: { type: 'string' },
+                            age: { type: 'number' },
+                        },
+                    },
+                },
+            },
+            {
+                name: 'array with mixed object types that cannot be merged',
+                input: [
+                    { id: 1, name: 'John' },
+                    { id: 'ABC', name: 'Jane' }, // id is string instead of number
+                ],
+                expected: {
+                    type: 'array',
+                    items: {
+                        anyOf: [
+                            {
+                                type: 'object',
+                                properties: {
+                                    id: { type: 'number' },
+                                    name: { type: 'string' },
+                                },
+                            },
+                            {
+                                type: 'object',
+                                properties: {
+                                    id: { type: 'string' },
+                                    name: { type: 'string' },
+                                },
+                            },
+                        ],
+                    },
+                },
+            },
+            {
+                name: 'empty array',
+                input: [],
+                expected: {
+                    type: 'array',
+                    items: { type: 'any' },
+                },
+            },
+            {
+                name: 'array with single item',
+                input: ['test'],
+                expected: {
+                    type: 'array',
+                    items: { type: 'string' },
+                },
+            },
+            {
+                name: 'array with single object',
+                input: [{ id: 1, name: 'John' }],
+                expected: {
+                    type: 'array',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            id: { type: 'number' },
+                            name: { type: 'string' },
+                        },
+                    },
+                },
+            },
+            {
+                name: 'array with single nested array',
+                input: [[1, 2, 3]],
+                expected: {
+                    type: 'array',
+                    items: {
+                        type: 'array',
+                        items: { type: 'number' },
+                    },
+                },
+            },
+            {
+                name: 'array with objects having common required properties',
+                input: [
+                    { id: 1, name: 'John', age: 30 },
+                    { id: 2, name: 'Jane', email: 'jane@example.com' },
+                ],
+                options: { requireAll: true },
+                expected: {
+                    type: 'array',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            id: { type: 'number' },
+                            name: { type: 'string' },
+                            age: { type: 'number' },
+                            email: { type: 'string' },
+                        },
+                        required: ['id', 'name'],
+                    },
+                },
+            },
+        ];
+        // Run all test cases
+        (0, tests_1.filter)(testCases).forEach(({ name, input, options, expected }) => {
+            it(name, () => {
+                const result = json_schema_generator_1.JsonSchemaGenerator.generate(input, options);
+                expect(result).toEqual(expected);
+            });
+        });
+    });
+    describe('validate()', () => {
+        const errorTestCases = [
+            {
+                name: 'invalid schema type',
+                input: 123,
+                schema: { type: 'string' },
+                expectedError: 'Validation failed',
+            },
+        ];
+        (0, tests_1.filter)(errorTestCases).forEach(({ name, input, schema, expectedError }) => {
+            it(name, () => {
+                expect(() => json_schema_generator_1.JsonSchemaGenerator.validate(input, schema)).toThrow(expectedError);
+            });
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"json-schema-generator.test.js","sourceRoot":"","sources":["../../src/utils/json-schema-generator.test.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  JsonSchemaGenerator,\n  JSONSchemaType,\n  JsonSchemaGeneratorOptions,\n} from './json-schema-generator';\nimport { BaseTestCase, filter } from './tests';\n\ntype SchemaTestCase = BaseTestCase & {\n  name: string;\n  input: unknown;\n  options?: JsonSchemaGeneratorOptions;\n  expected: JSONSchemaType;\n};\n\ndescribe('JsonSchemaGenerator', () => {\n  describe('generate()', () => {\n    const testCases: SchemaTestCase[] = [\n      {\n        name: 'primitive - string',\n        input: 'test',\n        expected: { type: 'string' },\n      },\n      {\n        name: 'primitive - number',\n        input: 123,\n        expected: { type: 'number' },\n      },\n      {\n        name: 'primitive - boolean',\n        input: true,\n        expected: { type: 'boolean' },\n      },\n      {\n        name: 'primitive - null',\n        input: null,\n        expected: { type: 'null' },\n      },\n      {\n        name: 'empty array',\n        input: [],\n        expected: { type: 'array', items: { type: 'any' } },\n      },\n      {\n        name: 'simple array of numbers',\n        input: [1, 2, 3],\n        expected: { type: 'array', items: { type: 'number' } },\n      },\n      {\n        name: 'enum detection from array',\n        input: ['red', 'green', 'red', 'blue'],\n        options: { detectEnums: true },\n        expected: {\n          type: 'array',\n          items: {\n            type: 'string',\n            enum: ['red', 'green', 'blue'],\n          },\n        },\n      },\n      {\n        name: 'enum detection disabled',\n        input: ['red', 'green', 'red', 'blue'],\n        options: { detectEnums: false },\n        expected: { type: 'array', items: { type: 'string' } },\n      },\n      {\n        name: 'simple object',\n        input: { name: 'John', age: 30 },\n        expected: {\n          type: 'object',\n          properties: {\n            name: { type: 'string' },\n            age: { type: 'number' },\n          },\n        },\n      },\n      {\n        name: 'object with required properties',\n        input: { name: 'John', age: 30 },\n        options: { requireAll: true },\n        expected: {\n          type: 'object',\n          properties: {\n            name: { type: 'string' },\n            age: { type: 'number' },\n          },\n          required: ['name', 'age'],\n        },\n      },\n      {\n        name: 'nested object',\n        input: {\n          name: 'John',\n          address: {\n            street: '123 Main St',\n            city: 'Boston',\n          },\n        },\n        expected: {\n          type: 'object',\n          properties: {\n            name: { type: 'string' },\n            address: {\n              type: 'object',\n              properties: {\n                street: { type: 'string' },\n                city: { type: 'string' },\n              },\n            },\n          },\n        },\n      },\n      {\n        name: 'mixed array of primitives',\n        input: [1, 'test', true],\n        expected: {\n          type: 'array',\n          items: { type: ['number', 'string', 'boolean'] },\n        },\n      },\n      {\n        name: 'object with array',\n        input: {\n          name: 'John',\n          hobbies: ['reading', 'gaming'],\n        },\n        expected: {\n          type: 'object',\n          properties: {\n            name: { type: 'string' },\n            hobbies: { type: 'array', items: { type: 'string' } },\n          },\n        },\n      },\n      {\n        name: 'array of objects',\n        input: [\n          { id: 1, name: 'John' },\n          { id: 2, name: 'Jane' },\n        ],\n        expected: {\n          type: 'array',\n          items: {\n            type: 'object',\n            properties: {\n              id: { type: 'number' },\n              name: { type: 'string' },\n            },\n          },\n        },\n      },\n      {\n        name: 'mixed array with objects',\n        input: [123, 'test', { name: 'John' }, true],\n        expected: {\n          type: 'array',\n          items: {\n            anyOf: [\n              { type: 'number' },\n              { type: 'string' },\n              {\n                type: 'object',\n                properties: { name: { type: 'string' } },\n              },\n              { type: 'boolean' },\n            ],\n          },\n        },\n      },\n      {\n        name: 'array of arrays',\n        input: [\n          [1, 2],\n          [3, 4],\n        ],\n        expected: {\n          type: 'array',\n          items: { type: 'array', items: { type: 'number' } },\n        },\n      },\n      {\n        name: 'complex nested object',\n        input: {\n          id: 1,\n          user: {\n            name: 'John',\n            contacts: {\n              email: ['john@example.com', 'john.doe@example.com'],\n              phone: null,\n            },\n            preferences: {\n              notifications: true,\n              theme: {\n                dark: false,\n                colors: ['blue', 'green'],\n              },\n            },\n          },\n        },\n        options: { requireAll: true },\n        expected: {\n          type: 'object',\n          required: ['id', 'user'],\n          properties: {\n            id: { type: 'number' },\n            user: {\n              type: 'object',\n              required: ['name', 'contacts', 'preferences'],\n              properties: {\n                name: { type: 'string' },\n                contacts: {\n                  type: 'object',\n                  required: ['email', 'phone'],\n                  properties: {\n                    email: { type: 'array', items: { type: 'string' } },\n                    phone: { type: 'null' },\n                  },\n                },\n                preferences: {\n                  type: 'object',\n                  required: ['notifications', 'theme'],\n                  properties: {\n                    notifications: { type: 'boolean' },\n                    theme: {\n                      type: 'object',\n                      required: ['dark', 'colors'],\n                      properties: {\n                        dark: { type: 'boolean' },\n                        colors: { type: 'array', items: { type: 'string' } },\n                      },\n                    },\n                  },\n                },\n              },\n            },\n          },\n        },\n      },\n      {\n        name: 'string array with no enum detection',\n        input: ['red', 'red', 'blue'],\n        options: { detectEnums: false },\n        expected: { type: 'array', items: { type: 'string' } },\n      },\n      {\n        name: 'array with mixed object types that can be merged',\n        input: [\n          { id: 1, name: 'John' },\n          { id: 2, name: 'Jane', age: 30 },\n        ],\n        expected: {\n          type: 'array',\n          items: {\n            type: 'object',\n            properties: {\n              id: { type: 'number' },\n              name: { type: 'string' },\n              age: { type: 'number' },\n            },\n          },\n        },\n      },\n      {\n        name: 'array with mixed object types that cannot be merged',\n        input: [\n          { id: 1, name: 'John' },\n          { id: 'ABC', name: 'Jane' }, // id is string instead of number\n        ],\n        expected: {\n          type: 'array',\n          items: {\n            anyOf: [\n              {\n                type: 'object',\n                properties: {\n                  id: { type: 'number' },\n                  name: { type: 'string' },\n                },\n              },\n              {\n                type: 'object',\n                properties: {\n                  id: { type: 'string' },\n                  name: { type: 'string' },\n                },\n              },\n            ],\n          },\n        },\n      },\n      {\n        name: 'empty array',\n        input: [],\n        expected: {\n          type: 'array',\n          items: { type: 'any' },\n        },\n      },\n      {\n        name: 'array with single item',\n        input: ['test'],\n        expected: {\n          type: 'array',\n          items: { type: 'string' },\n        },\n      },\n      {\n        name: 'array with single object',\n        input: [{ id: 1, name: 'John' }],\n        expected: {\n          type: 'array',\n          items: {\n            type: 'object',\n            properties: {\n              id: { type: 'number' },\n              name: { type: 'string' },\n            },\n          },\n        },\n      },\n      {\n        name: 'array with single nested array',\n        input: [[1, 2, 3]],\n        expected: {\n          type: 'array',\n          items: {\n            type: 'array',\n            items: { type: 'number' },\n          },\n        },\n      },\n      {\n        name: 'array with objects having common required properties',\n        input: [\n          { id: 1, name: 'John', age: 30 },\n          { id: 2, name: 'Jane', email: 'jane@example.com' },\n        ],\n        options: { requireAll: true },\n        expected: {\n          type: 'array',\n          items: {\n            type: 'object',\n            properties: {\n              id: { type: 'number' },\n              name: { type: 'string' },\n              age: { type: 'number' },\n              email: { type: 'string' },\n            },\n            required: ['id', 'name'],\n          },\n        },\n      },\n    ];\n\n    // Run all test cases\n    filter(testCases).forEach(({ name, input, options, expected }) => {\n      it(name, () => {\n        const result = JsonSchemaGenerator.generate(input, options);\n        expect(result).toEqual(expected);\n      });\n    });\n  });\n\n  describe('validate()', () => {\n    type ValidateTestCase = BaseTestCase & {\n      name: string;\n      input: unknown;\n      schema: JSONSchemaType;\n      expectedError: string;\n    };\n\n    const errorTestCases: ValidateTestCase[] = [\n      {\n        name: 'invalid schema type',\n        input: 123,\n        schema: { type: 'string' },\n        expectedError: 'Validation failed',\n      },\n    ];\n\n    filter(errorTestCases).forEach(({ name, input, schema, expectedError }) => {\n      it(name, () => {\n        expect(() => JsonSchemaGenerator.validate(input, schema)).toThrow(expectedError);\n      });\n    });\n  });\n});\n"]}

package/build/utils/misc.d.ts

@@ -33,7 +33,7 @@ export declare const isPrimitive: (arg: unknown) => boolean;
  * for null argss returns "NULL" insted of "object"
  *
  */
-export declare const getType: (arg: unknown) => "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function" | "NULL" | "array";
+export declare const getType: (arg: unknown) => "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function" | "array" | "NULL";
 export declare const isObject: (value: unknown) => boolean;
 export declare const isEmpty: (input: unknown) => boolean;
 /**

package/build/utils/tests.d.ts

@@ -0,0 +1,6 @@
+export type BaseTestCase = {
+    skip?: boolean;
+    only?: boolean;
+};
+export declare const filter: <T extends BaseTestCase>(testCases: T[]) => T[];
+//# sourceMappingURL=tests.d.ts.map

package/build/utils/tests.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tests.d.ts","sourceRoot":"","sources":["../../src/utils/tests.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB,CAAC;AAEF,eAAO,MAAM,MAAM,iDAWlB,CAAC"}

package/build/utils/tests.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filter = void 0;
+const filter = (testCases) => {
+    // Check if any test case has `only` set to true.
+    const hasOnly = testCases.some((testCase) => testCase.only);
+    if (hasOnly) {
+        // Only run test cases that are marked with `only` and are not skipped.
+        return testCases.filter((testCase) => testCase.only && !testCase.skip);
+    }
+    // Otherwise, run all test cases that are not skipped.
+    return testCases.filter((testCase) => !testCase.skip);
+};
+exports.filter = filter;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGVzdHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdXRpbHMvdGVzdHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBS08sTUFBTSxNQUFNLEdBQUcsQ0FBeUIsU0FBYyxFQUFPLEVBQUU7SUFDcEUsaURBQWlEO0lBQ2pELE1BQU0sT0FBTyxHQUFHLFNBQVMsQ0FBQyxJQUFJLENBQUMsQ0FBQyxRQUFRLEVBQUUsRUFBRSxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsQ0FBQztJQUU1RCxJQUFJLE9BQU8sRUFBRTtRQUNYLHVFQUF1RTtRQUN2RSxPQUFPLFNBQVMsQ0FBQyxNQUFNLENBQUMsQ0FBQyxRQUFRLEVBQUUsRUFBRSxDQUFDLFFBQVEsQ0FBQyxJQUFJLElBQUksQ0FBQyxRQUFRLENBQUMsSUFBSSxDQUFDLENBQUM7S0FDeEU7SUFFRCxzREFBc0Q7SUFDdEQsT0FBTyxTQUFTLENBQUMsTUFBTSxDQUFDLENBQUMsUUFBUSxFQUFFLEVBQUUsQ0FBQyxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsQ0FBQztBQUN4RCxDQUFDLENBQUM7QUFYVyxRQUFBLE1BQU0sVUFXakIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgdHlwZSBCYXNlVGVzdENhc2UgPSB7XG4gIHNraXA/OiBib29sZWFuO1xuICBvbmx5PzogYm9vbGVhbjtcbn07XG5cbmV4cG9ydCBjb25zdCBmaWx0ZXIgPSA8VCBleHRlbmRzIEJhc2VUZXN0Q2FzZT4odGVzdENhc2VzOiBUW10pOiBUW10gPT4ge1xuICAvLyBDaGVjayBpZiBhbnkgdGVzdCBjYXNlIGhhcyBgb25seWAgc2V0IHRvIHRydWUuXG4gIGNvbnN0IGhhc09ubHkgPSB0ZXN0Q2FzZXMuc29tZSgodGVzdENhc2UpID0+IHRlc3RDYXNlLm9ubHkpO1xuXG4gIGlmIChoYXNPbmx5KSB7XG4gICAgLy8gT25seSBydW4gdGVzdCBjYXNlcyB0aGF0IGFyZSBtYXJrZWQgd2l0aCBgb25seWAgYW5kIGFyZSBub3Qgc2tpcHBlZC5cbiAgICByZXR1cm4gdGVzdENhc2VzLmZpbHRlcigodGVzdENhc2UpID0+IHRlc3RDYXNlLm9ubHkgJiYgIXRlc3RDYXNlLnNraXApO1xuICB9XG5cbiAgLy8gT3RoZXJ3aXNlLCBydW4gYWxsIHRlc3QgY2FzZXMgdGhhdCBhcmUgbm90IHNraXBwZWQuXG4gIHJldHVybiB0ZXN0Q2FzZXMuZmlsdGVyKCh0ZXN0Q2FzZSkgPT4gIXRlc3RDYXNlLnNraXApO1xufTtcbiJdfQ==

package/build/utils/tests.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=tests.test.d.ts.map

package/build/utils/tests.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tests.test.d.ts","sourceRoot":"","sources":["../../src/utils/tests.test.ts"],"names":[],"mappings":""}

package/build/utils/tests.test.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tests_1 = require("./tests");
+describe('filter', () => {
+    const testCases = [
+        {
+            name: 'should return all test cases when no skip or only flags are present',
+            input: [{ name: 'test1' }, { name: 'test2' }, { name: 'test3' }],
+            expected: [{ name: 'test1' }, { name: 'test2' }, { name: 'test3' }],
+        },
+        {
+            name: 'should filter out skipped test cases',
+            input: [{ name: 'test1', skip: true }, { name: 'test2' }, { name: 'test3', skip: true }],
+            expected: [{ name: 'test2' }],
+        },
+        {
+            name: 'should return only the test cases marked with only',
+            input: [{ name: 'test1' }, { name: 'test2', only: true }, { name: 'test3' }],
+            expected: [{ name: 'test2', only: true }],
+        },
+        {
+            name: 'should return only non-skipped test cases marked with only',
+            input: [
+                { name: 'test1', only: true },
+                { name: 'test2', only: true, skip: true },
+                { name: 'test3', only: true },
+            ],
+            expected: [
+                { name: 'test1', only: true },
+                { name: 'test3', only: true },
+            ],
+        },
+        {
+            name: 'should handle empty array input',
+            input: [],
+            expected: [],
+        },
+        {
+            name: 'should return all test cases marked with only',
+            input: [{ name: 'test1', only: true }, { name: 'test2' }, { name: 'test3', only: true }],
+            expected: [
+                { name: 'test1', only: true },
+                { name: 'test3', only: true },
+            ],
+        },
+        {
+            name: 'should return empty array when all tests are skipped',
+            input: [
+                { name: 'test1', skip: true },
+                { name: 'test2', skip: true },
+                { name: 'test3', skip: true },
+            ],
+            expected: [],
+        },
+        {
+            name: 'should return non-skipped tests when no only flag is present',
+            input: [{ name: 'test1', skip: true }, { name: 'test2' }, { name: 'test3', skip: false }],
+            expected: [{ name: 'test2' }, { name: 'test3', skip: false }],
+        },
+        {
+            name: 'should handle undefined skip and only properties',
+            input: [
+                { name: 'test1', skip: undefined },
+                { name: 'test2', only: undefined },
+                { name: 'test3' },
+            ],
+            expected: [
+                { name: 'test1', skip: undefined },
+                { name: 'test2', only: undefined },
+                { name: 'test3' },
+            ],
+        },
+        {
+            name: 'should maintain original object properties',
+            input: [
+                { name: 'test1', extraProp: 1 },
+                { name: 'test2', extraProp: 2, skip: true },
+                { name: 'test3', extraProp: 3, only: true },
+            ],
+            expected: [{ name: 'test3', extraProp: 3, only: true }],
+        },
+    ];
+    testCases.forEach(({ name, input, expected }) => {
+        it(name, () => {
+            expect((0, tests_1.filter)(input)).toEqual(expected);
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tests.test.js","sourceRoot":"","sources":["../../src/utils/tests.test.ts"],"names":[],"mappings":"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","sourcesContent":["import { BaseTestCase, filter } from './tests';\n\ntype CustomTestCase = BaseTestCase & {\n  [key: string]: any;\n};\n\ninterface TestItem {\n  name: string;\n  expected: CustomTestCase[];\n  input: CustomTestCase[];\n}\n\ndescribe('filter', () => {\n  const testCases: TestItem[] = [\n    {\n      name: 'should return all test cases when no skip or only flags are present',\n      input: [{ name: 'test1' }, { name: 'test2' }, { name: 'test3' }],\n      expected: [{ name: 'test1' }, { name: 'test2' }, { name: 'test3' }],\n    },\n    {\n      name: 'should filter out skipped test cases',\n      input: [{ name: 'test1', skip: true }, { name: 'test2' }, { name: 'test3', skip: true }],\n      expected: [{ name: 'test2' }],\n    },\n    {\n      name: 'should return only the test cases marked with only',\n      input: [{ name: 'test1' }, { name: 'test2', only: true }, { name: 'test3' }],\n      expected: [{ name: 'test2', only: true }],\n    },\n    {\n      name: 'should return only non-skipped test cases marked with only',\n      input: [\n        { name: 'test1', only: true },\n        { name: 'test2', only: true, skip: true },\n        { name: 'test3', only: true },\n      ],\n      expected: [\n        { name: 'test1', only: true },\n        { name: 'test3', only: true },\n      ],\n    },\n    {\n      name: 'should handle empty array input',\n      input: [],\n      expected: [],\n    },\n    {\n      name: 'should return all test cases marked with only',\n      input: [{ name: 'test1', only: true }, { name: 'test2' }, { name: 'test3', only: true }],\n      expected: [\n        { name: 'test1', only: true },\n        { name: 'test3', only: true },\n      ],\n    },\n    {\n      name: 'should return empty array when all tests are skipped',\n      input: [\n        { name: 'test1', skip: true },\n        { name: 'test2', skip: true },\n        { name: 'test3', skip: true },\n      ],\n      expected: [],\n    },\n    {\n      name: 'should return non-skipped tests when no only flag is present',\n      input: [{ name: 'test1', skip: true }, { name: 'test2' }, { name: 'test3', skip: false }],\n      expected: [{ name: 'test2' }, { name: 'test3', skip: false }],\n    },\n    {\n      name: 'should handle undefined skip and only properties',\n      input: [\n        { name: 'test1', skip: undefined },\n        { name: 'test2', only: undefined },\n        { name: 'test3' },\n      ],\n      expected: [\n        { name: 'test1', skip: undefined },\n        { name: 'test2', only: undefined },\n        { name: 'test3' },\n      ],\n    },\n    {\n      name: 'should maintain original object properties',\n      input: [\n        { name: 'test1', extraProp: 1 },\n        { name: 'test2', extraProp: 2, skip: true },\n        { name: 'test3', extraProp: 3, only: true },\n      ],\n      expected: [{ name: 'test3', extraProp: 3, only: true }],\n    },\n  ];\n\n  testCases.forEach(({ name, input, expected }) => {\n    it(name, () => {\n      expect(filter(input)).toEqual(expected);\n    });\n  });\n});\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rudderstack/integrations-lib",
-  "version": "0.2.17",
+  "version": "0.2.18",
   "description": "",
   "main": "build/index.js",
   "module": "build/index.js",
@@ -53,7 +53,8 @@
     "sha256": "^0.2.0",
     "tslib": "^2.4.0",
     "uuid": "^11.0.5",
-    "winston": "^3.11.0"
+    "winston": "^3.11.0",
+    "jsonschema": "^1.5.0"
   },
   "devDependencies": {
     "@commitlint/config-conventional": "^18.5.0",