@trayio/commons 5.13.0-unstable → 5.14.0

package/dist/schema/JsonSchemaIntrospector.d.ts

@@ -1,53 +1,18 @@
 /**
  * Utility for converting runtime JavaScript objects to JSON Schema
  * Used for dynamic output schema generation in CDK connectors
+ *
+ * This implementation uses the generate-schema library to convert raw JSON
+ * responses into valid JSON Schema representations, matching the behavior
+ * of the legacy connector framework.
  */
 export declare class JsonSchemaIntrospector {
     /**
      * Introspects a JavaScript object and generates a JSON Schema representation
      *
      * @param obj - The object to introspect
-     * @param options - Configuration options for introspection
      * @returns A JSON Schema object describing the structure
-     *
-     * @example
-     * ```typescript
-     * const data = { id: 1, name: "John", active: true };
-     * const schema = JsonSchemaIntrospector.introspectToJsonSchema(data);
-     * // Returns:
-     * // {
-     * //   type: 'object',
-     * //   properties: {
-     * //     id: { type: 'number' },
-     * //     name: { type: 'string' },
-     * //     active: { type: 'boolean' }
-     * //   },
-     * //   required: ['id', 'name', 'active']
-     * // }
-     * ```
      */
-    static introspectToJsonSchema(obj: any, options?: IntrospectionOptions): any;
-    private static introspectRecursive;
+    static introspectToJsonSchema(obj: any): any;
 }
-/**
- * Configuration options for JSON Schema introspection
- */
-export type IntrospectionOptions = {
-    /**
-     * Maximum depth for recursive introspection
-     * @default 10
-     */
-    maxDepth?: number;
-    /**
-     * Whether to include example values in the schema
-     * @default false
-     */
-    includeExamples?: boolean;
-    /**
-     * Whether to mark all present fields as required
-     * If false, only marks non-null/non-undefined fields as required
-     * @default true
-     */
-    strictRequired?: boolean;
-};
 //# sourceMappingURL=JsonSchemaIntrospector.d.ts.map

package/dist/schema/JsonSchemaIntrospector.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"JsonSchemaIntrospector.d.ts","sourceRoot":"","sources":["../../src/schema/JsonSchemaIntrospector.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,qBAAa,sBAAsB;IAClC;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,MAAM,CAAC,sBAAsB,CAAC,GAAG,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,oBAAoB,GAAG,GAAG;IAU5E,OAAO,CAAC,MAAM,CAAC,mBAAmB;CA8FlC;AAED;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAAG;IAClC;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB;;;OAGG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;IAE1B;;;;OAIG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;CACzB,CAAC"}
+{"version":3,"file":"JsonSchemaIntrospector.d.ts","sourceRoot":"","sources":["../../src/schema/JsonSchemaIntrospector.ts"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,qBAAa,sBAAsB;IAClC;;;;;OAKG;IACH,MAAM,CAAC,sBAAsB,CAAC,GAAG,EAAE,GAAG,GAAG,GAAG;CAS5C"}

package/dist/schema/JsonSchemaIntrospector.js

@@ -1,118 +1,52 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.JsonSchemaIntrospector = void 0;
+const generateSchema = __importStar(require("generate-schema"));
 /**
  * Utility for converting runtime JavaScript objects to JSON Schema
  * Used for dynamic output schema generation in CDK connectors
+ *
+ * This implementation uses the generate-schema library to convert raw JSON
+ * responses into valid JSON Schema representations, matching the behavior
+ * of the legacy connector framework.
  */
 class JsonSchemaIntrospector {
     /**
      * Introspects a JavaScript object and generates a JSON Schema representation
      *
      * @param obj - The object to introspect
-     * @param options - Configuration options for introspection
      * @returns A JSON Schema object describing the structure
-     *
-     * @example
-     * ```typescript
-     * const data = { id: 1, name: "John", active: true };
-     * const schema = JsonSchemaIntrospector.introspectToJsonSchema(data);
-     * // Returns:
-     * // {
-     * //   type: 'object',
-     * //   properties: {
-     * //     id: { type: 'number' },
-     * //     name: { type: 'string' },
-     * //     active: { type: 'boolean' }
-     * //   },
-     * //   required: ['id', 'name', 'active']
-     * // }
-     * ```
      */
-    static introspectToJsonSchema(obj, options) {
-        const opts = {
-            maxDepth: options?.maxDepth ?? 10,
-            includeExamples: options?.includeExamples ?? false,
-            strictRequired: options?.strictRequired ?? true,
-        };
-        return this.introspectRecursive(obj, 0, opts);
-    }
-    static introspectRecursive(obj, depth, options) {
-        // Prevent infinite recursion
-        if (depth >= options.maxDepth) {
-            return { type: 'object', additionalProperties: true };
-        }
-        // Handle null
-        if (obj === null) {
-            return { type: 'null' };
-        }
-        // Handle arrays
-        if (Array.isArray(obj)) {
-            if (obj.length === 0) {
-                return { type: 'array', items: {} };
-            }
-            // Generate schema from first item
-            const itemSchema = this.introspectRecursive(obj[0], depth + 1, options);
-            const schema = {
-                type: 'array',
-                items: itemSchema,
-            };
-            if (options.includeExamples) {
-                schema.examples = [obj];
-            }
-            return schema;
-        }
-        const type = typeof obj;
-        // Handle primitives
-        if (type === 'string') {
-            const schema = { type: 'string' };
-            if (options.includeExamples) {
-                schema.examples = [obj];
-            }
-            return schema;
-        }
-        if (type === 'number') {
-            const schema = { type: 'number' };
-            if (options.includeExamples) {
-                schema.examples = [obj];
-            }
-            return schema;
-        }
-        if (type === 'boolean') {
-            const schema = { type: 'boolean' };
-            if (options.includeExamples) {
-                schema.examples = [obj];
-            }
-            return schema;
-        }
-        // Handle objects
-        if (type === 'object') {
-            const properties = {};
-            const required = [];
-            for (const [key, value] of Object.entries(obj)) {
-                properties[key] = this.introspectRecursive(value, depth + 1, options);
-                // Add to required array based on options
-                if (options.strictRequired) {
-                    required.push(key);
-                }
-                else if (value !== null && value !== undefined) {
-                    required.push(key);
-                }
-            }
-            const schema = {
-                type: 'object',
-                properties,
-            };
-            if (required.length > 0) {
-                schema.required = required;
-            }
-            if (options.includeExamples) {
-                schema.examples = [obj];
-            }
-            return schema;
+    static introspectToJsonSchema(obj) {
+        // If object already has $schema, assume it's a JSON schema and return as-is
+        // This matches the old connector framework behavior
+        if (obj && typeof obj === 'object' && obj.$schema) {
+            return obj;
         }
-        // Fallback for unknown types
-        return { type: 'string' };
+        return generateSchema.json('Schema', obj);
     }
 }
 exports.JsonSchemaIntrospector = JsonSchemaIntrospector;

package/dist/schema/JsonSchemaIntrospector.unit.test.js

@@ -4,18 +4,18 @@ const JsonSchemaIntrospector_1 = require("./JsonSchemaIntrospector");
 describe('JsonSchemaIntrospector', () => {
     describe('introspectToJsonSchema', () => {
         it('should handle primitive types', () => {
-            expect(JsonSchemaIntrospector_1.JsonSchemaIntrospector.introspectToJsonSchema('test')).toEqual({
-                type: 'string',
-            });
-            expect(JsonSchemaIntrospector_1.JsonSchemaIntrospector.introspectToJsonSchema(42)).toEqual({
-                type: 'number',
-            });
-            expect(JsonSchemaIntrospector_1.JsonSchemaIntrospector.introspectToJsonSchema(true)).toEqual({
-                type: 'boolean',
-            });
-            expect(JsonSchemaIntrospector_1.JsonSchemaIntrospector.introspectToJsonSchema(null)).toEqual({
-                type: 'null',
-            });
+            const stringSchema = JsonSchemaIntrospector_1.JsonSchemaIntrospector.introspectToJsonSchema('test');
+            expect(stringSchema.$schema).toBe('http://json-schema.org/draft-04/schema#');
+            expect(stringSchema.type).toBeDefined();
+            const numberSchema = JsonSchemaIntrospector_1.JsonSchemaIntrospector.introspectToJsonSchema(42);
+            expect(numberSchema.$schema).toBe('http://json-schema.org/draft-04/schema#');
+            expect(numberSchema.type).toBe('number');
+            const boolSchema = JsonSchemaIntrospector_1.JsonSchemaIntrospector.introspectToJsonSchema(true);
+            expect(boolSchema.$schema).toBe('http://json-schema.org/draft-04/schema#');
+            expect(boolSchema.type).toBe('boolean');
+            const nullSchema = JsonSchemaIntrospector_1.JsonSchemaIntrospector.introspectToJsonSchema(null);
+            expect(nullSchema.$schema).toBe('http://json-schema.org/draft-04/schema#');
+            expect(nullSchema.type).toBe('null');
         });
         it('should handle simple objects', () => {
             const obj = {
@@ -24,15 +24,14 @@ describe('JsonSchemaIntrospector', () => {
                 active: true,
             };
             const schema = JsonSchemaIntrospector_1.JsonSchemaIntrospector.introspectToJsonSchema(obj);
-            expect(schema).toEqual({
-                type: 'object',
-                properties: {
-                    id: { type: 'number' },
-                    name: { type: 'string' },
-                    active: { type: 'boolean' },
-                },
-                required: ['id', 'name', 'active'],
+            expect(schema.$schema).toBe('http://json-schema.org/draft-04/schema#');
+            expect(schema.type).toBe('object');
+            expect(schema.properties).toEqual({
+                id: { type: 'number' },
+                name: { type: 'string' },
+                active: { type: 'boolean' },
             });
+            // Note: generate-schema doesn't add 'required' array, which is fine for path referencing
         });
         it('should handle nested objects', () => {
             const obj = {
@@ -45,6 +44,7 @@ describe('JsonSchemaIntrospector', () => {
                 },
             };
             const schema = JsonSchemaIntrospector_1.JsonSchemaIntrospector.introspectToJsonSchema(obj);
+            expect(schema.$schema).toBe('http://json-schema.org/draft-04/schema#');
             expect(schema.type).toBe('object');
             expect(schema.properties.user.type).toBe('object');
             expect(schema.properties.user.properties.profile.type).toBe('object');
@@ -70,16 +70,11 @@ describe('JsonSchemaIntrospector', () => {
                 ],
             };
             const schema = JsonSchemaIntrospector_1.JsonSchemaIntrospector.introspectToJsonSchema(obj);
-            expect(schema.properties.users).toEqual({
-                type: 'array',
-                items: {
-                    type: 'object',
-                    properties: {
-                        id: { type: 'number' },
-                        name: { type: 'string' },
-                    },
-                    required: ['id', 'name'],
-                },
+            expect(schema.properties.users.type).toBe('array');
+            expect(schema.properties.users.items.type).toBe('object');
+            expect(schema.properties.users.items.properties).toEqual({
+                id: { type: 'number' },
+                name: { type: 'string' },
             });
         });
         it('should handle empty arrays', () => {
@@ -90,50 +85,19 @@ describe('JsonSchemaIntrospector', () => {
                 items: {},
             });
         });
-        it('should respect maxDepth option', () => {
-            const deepObj = {
-                level1: {
-                    level2: {
-                        level3: {
-                            level4: {
-                                level5: {
-                                    tooDeep: 'value',
-                                },
-                            },
-                        },
-                    },
-                },
-            };
-            const schema = JsonSchemaIntrospector_1.JsonSchemaIntrospector.introspectToJsonSchema(deepObj, {
-                maxDepth: 2,
-            });
-            // Should cut off at depth 2 (level1 -> level2 -> stop)
-            expect(schema.properties.level1.properties.level2).toEqual({
+        it('should return as-is if object already has $schema', () => {
+            // This matches the old connector framework behavior
+            const existingSchema = {
+                $schema: 'http://json-schema.org/draft-07/schema#',
                 type: 'object',
-                additionalProperties: true,
-            });
-        });
-        it('should include examples when requested', () => {
-            const obj = { name: 'John' };
-            const schema = JsonSchemaIntrospector_1.JsonSchemaIntrospector.introspectToJsonSchema(obj, {
-                includeExamples: true,
-            });
-            expect(schema.examples).toEqual([{ name: 'John' }]);
-            expect(schema.properties.name.examples).toEqual(['John']);
-        });
-        it('should handle strictRequired option', () => {
-            const obj = {
-                present: 'value',
-                // In real use, there might be optional fields
+                properties: {
+                    custom: { type: 'string' },
+                },
             };
-            const strictSchema = JsonSchemaIntrospector_1.JsonSchemaIntrospector.introspectToJsonSchema(obj, {
-                strictRequired: true,
-            });
-            expect(strictSchema.required).toEqual(['present']);
-            const relaxedSchema = JsonSchemaIntrospector_1.JsonSchemaIntrospector.introspectToJsonSchema(obj, {
-                strictRequired: false,
-            });
-            expect(relaxedSchema.required).toEqual(['present']);
+            const schema = JsonSchemaIntrospector_1.JsonSchemaIntrospector.introspectToJsonSchema(existingSchema);
+            // Should return the input unchanged
+            expect(schema).toBe(existingSchema);
+            expect(schema.$schema).toBe('http://json-schema.org/draft-07/schema#');
         });
         it('should handle complex real-world example', () => {
             const obj = {
@@ -158,6 +122,7 @@ describe('JsonSchemaIntrospector', () => {
                 ],
             };
             const schema = JsonSchemaIntrospector_1.JsonSchemaIntrospector.introspectToJsonSchema(obj);
+            expect(schema.$schema).toBe('http://json-schema.org/draft-04/schema#');
             expect(schema.type).toBe('object');
             expect(schema.properties.id.type).toBe('number');
             expect(schema.properties.metadata.type).toBe('object');

package/dist/schema/index.d.ts

@@ -1,2 +1,2 @@
-export { JsonSchemaIntrospector, IntrospectionOptions, } from './JsonSchemaIntrospector';
+export { JsonSchemaIntrospector } from './JsonSchemaIntrospector';
 //# sourceMappingURL=index.d.ts.map

package/dist/schema/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/schema/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,sBAAsB,EACtB,oBAAoB,GACpB,MAAM,0BAA0B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/schema/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trayio/commons",
-  "version": "5.13.0-unstable",
+  "version": "5.14.0",
   "description": "Extensions to the standard/core libraries and basic features",
   "exports": {
     "./*": "./dist/*.js"
@@ -25,6 +25,7 @@
     "formidable": "3.5.1",
     "fp-ts": "2.12.3",
     "fs-extra": "11.1.0",
+    "generate-schema": "^2.6.0",
     "io-ts": "2.2.20",
     "io-ts-reporters": "2.0.1",
     "io-ts-types": "0.5.19",
@@ -45,6 +46,5 @@
   },
   "files": [
     "/dist"
-  ],
-  "stableVersion": "0.0.0"
+  ]
 }