@trayio/commons 5.13.0 → 5.14.0

package/dist/schema/JsonSchemaIntrospector.d.ts

@@ -0,0 +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
+     * @returns A JSON Schema object describing the structure
+     */
+    static introspectToJsonSchema(obj: any): any;
+}
+//# sourceMappingURL=JsonSchemaIntrospector.d.ts.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +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
+     * @returns A JSON Schema object describing the structure
+     */
+    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;
+        }
+        return generateSchema.json('Schema', obj);
+    }
+}
+exports.JsonSchemaIntrospector = JsonSchemaIntrospector;

package/dist/schema/JsonSchemaIntrospector.unit.test.d.ts

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

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

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

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

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const JsonSchemaIntrospector_1 = require("./JsonSchemaIntrospector");
+describe('JsonSchemaIntrospector', () => {
+    describe('introspectToJsonSchema', () => {
+        it('should handle primitive types', () => {
+            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 = {
+                id: 1,
+                name: 'John',
+                active: true,
+            };
+            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).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 = {
+                user: {
+                    id: 1,
+                    profile: {
+                        name: 'John',
+                        age: 30,
+                    },
+                },
+            };
+            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');
+            expect(schema.properties.user.properties.profile.properties.name).toEqual({
+                type: 'string',
+            });
+        });
+        it('should handle arrays', () => {
+            const obj = {
+                items: [1, 2, 3],
+            };
+            const schema = JsonSchemaIntrospector_1.JsonSchemaIntrospector.introspectToJsonSchema(obj);
+            expect(schema.properties.items).toEqual({
+                type: 'array',
+                items: { type: 'number' },
+            });
+        });
+        it('should handle arrays of objects', () => {
+            const obj = {
+                users: [
+                    { id: 1, name: 'John' },
+                    { id: 2, name: 'Jane' },
+                ],
+            };
+            const schema = JsonSchemaIntrospector_1.JsonSchemaIntrospector.introspectToJsonSchema(obj);
+            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', () => {
+            const obj = { items: [] };
+            const schema = JsonSchemaIntrospector_1.JsonSchemaIntrospector.introspectToJsonSchema(obj);
+            expect(schema.properties.items).toEqual({
+                type: 'array',
+                items: {},
+            });
+        });
+        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',
+                properties: {
+                    custom: { type: 'string' },
+                },
+            };
+            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 = {
+                id: 1,
+                title: 'Post Title',
+                body: 'Post content',
+                userId: 10,
+                metadata: {
+                    created: '2024-01-01',
+                    tags: ['tech', 'tutorial'],
+                    stats: {
+                        views: 100,
+                        likes: 25,
+                    },
+                },
+                comments: [
+                    {
+                        id: 1,
+                        text: 'Great post!',
+                        author: 'Alice',
+                    },
+                ],
+            };
+            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');
+            expect(schema.properties.metadata.properties.tags.type).toBe('array');
+            expect(schema.properties.comments.type).toBe('array');
+            expect(schema.properties.comments.items.type).toBe('object');
+        });
+    });
+});

package/dist/schema/index.d.ts

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

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

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

package/dist/schema/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonSchemaIntrospector = void 0;
+var JsonSchemaIntrospector_1 = require("./JsonSchemaIntrospector");
+Object.defineProperty(exports, "JsonSchemaIntrospector", { enumerable: true, get: function () { return JsonSchemaIntrospector_1.JsonSchemaIntrospector; } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trayio/commons",
-  "version": "5.13.0",
+  "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",