@trayio/commons 5.12.0 → 5.13.0-unstable

package/dist/schema/JsonSchemaIntrospector.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Utility for converting runtime JavaScript objects to JSON Schema
+ * Used for dynamic output schema generation in CDK connectors
+ */
+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;
+}
+/**
+ * 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

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

package/dist/schema/JsonSchemaIntrospector.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonSchemaIntrospector = void 0;
+/**
+ * Utility for converting runtime JavaScript objects to JSON Schema
+ * Used for dynamic output schema generation in CDK connectors
+ */
+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;
+        }
+        // Fallback for unknown types
+        return { type: 'string' };
+    }
+}
+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,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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',
+            });
+        });
+        it('should handle simple objects', () => {
+            const obj = {
+                id: 1,
+                name: 'John',
+                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'],
+            });
+        });
+        it('should handle nested objects', () => {
+            const obj = {
+                user: {
+                    id: 1,
+                    profile: {
+                        name: 'John',
+                        age: 30,
+                    },
+                },
+            };
+            const schema = JsonSchemaIntrospector_1.JsonSchemaIntrospector.introspectToJsonSchema(obj);
+            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).toEqual({
+                type: 'array',
+                items: {
+                    type: 'object',
+                    properties: {
+                        id: { type: 'number' },
+                        name: { type: 'string' },
+                    },
+                    required: ['id', 'name'],
+                },
+            });
+        });
+        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 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({
+                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
+            };
+            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']);
+        });
+        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.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, IntrospectionOptions, } 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,EACN,sBAAsB,EACtB,oBAAoB,GACpB,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.12.0",
+  "version": "5.13.0-unstable",
   "description": "Extensions to the standard/core libraries and basic features",
   "exports": {
     "./*": "./dist/*.js"
@@ -45,5 +45,6 @@
   },
   "files": [
     "/dist"
-  ]
+  ],
+  "stableVersion": "0.0.0"
 }