@trayio/cdk-cli 5.13.0 → 5.14.0

package/README.md

@@ -19,7 +19,7 @@ $ npm install -g @trayio/cdk-cli
 $ tray-cdk COMMAND
 running command...
 $ tray-cdk (--version|-v)
-@trayio/cdk-cli/5.13.0 linux-x64 node-v18.20.8
+@trayio/cdk-cli/5.14.0 linux-x64 node-v18.20.8
 $ tray-cdk --help [COMMAND]
 USAGE
   $ tray-cdk COMMAND
@@ -32,6 +32,7 @@ USAGE
 <!-- commands -->
 * [`tray-cdk .`](#tray-cdk-)
 * [`tray-cdk autocomplete [SHELL]`](#tray-cdk-autocomplete-shell)
+* [`tray-cdk connector add-dynamic-output-schema OPERATIONNAME`](#tray-cdk-connector-add-dynamic-output-schema-operationname)
 * [`tray-cdk connector add-operation [OPERATIONNAME] [OPERATIONTYPE]`](#tray-cdk-connector-add-operation-operationname-operationtype)
 * [`tray-cdk connector build`](#tray-cdk-connector-build)
 * [`tray-cdk connector import [OPENAPISPEC] [CONNECTORNAME]`](#tray-cdk-connector-import-openapispec-connectorname)
@@ -96,6 +97,26 @@ EXAMPLES
 
 _See code: [@oclif/plugin-autocomplete](https://github.com/oclif/plugin-autocomplete/blob/v3.0.5/src/commands/autocomplete/index.ts)_
 
+## `tray-cdk connector add-dynamic-output-schema OPERATIONNAME`
+
+Add a dynamic output schema operation for an existing operation
+
+```
+USAGE
+  $ tray-cdk connector add-dynamic-output-schema OPERATIONNAME
+
+ARGUMENTS
+  OPERATIONNAME  Name of the parent operation to add dynamic output schema for
+
+DESCRIPTION
+  Add a dynamic output schema operation for an existing operation
+
+EXAMPLES
+  $ tray-cdk connector add-dynamic-output-schema get_posts
+
+  $ tray-cdk connector add-dynamic-output-schema fetch_user_data
+```
+
 ## `tray-cdk connector add-operation [OPERATIONNAME] [OPERATIONTYPE]`
 
 Add an operation to connector project

package/dist/commands/connector/add-dynamic-output-schema.d.ts

@@ -0,0 +1,16 @@
+import { Command } from '@oclif/core';
+export default class AddDynamicOutputSchema extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {
+        operationName: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    private generator;
+    run(): Promise<void>;
+    private validateParentOperation;
+    private detectAuthConfig;
+    private copyInputFromParent;
+    private updateParentOperationJson;
+    private findSrcDirectory;
+}
+//# sourceMappingURL=add-dynamic-output-schema.d.ts.map

package/dist/commands/connector/add-dynamic-output-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"add-dynamic-output-schema.d.ts","sourceRoot":"","sources":["../../../src/commands/connector/add-dynamic-output-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAQ,MAAM,aAAa,CAAC;AAW5C,MAAM,CAAC,OAAO,OAAO,sBAAuB,SAAQ,OAAO;IAC1D,MAAM,CAAC,WAAW,SACiD;IAEnE,MAAM,CAAC,QAAQ,WAGb;IAEF,MAAM,CAAC,IAAI;;MAOT;IAEF,OAAO,CAAC,SAAS,CAAyB;IAEpC,GAAG;IAsGT,OAAO,CAAC,uBAAuB;YAuBjB,gBAAgB;YAehB,mBAAmB;YA8BnB,yBAAyB;IAcvC,OAAO,CAAC,gBAAgB;CAOxB"}

package/dist/commands/connector/add-dynamic-output-schema.js

@@ -0,0 +1,163 @@
+"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 });
+const core_1 = require("@oclif/core");
+const fse = __importStar(require("fs-extra"));
+const path = __importStar(require("path"));
+const StringExtensions_1 = require("@trayio/commons/string/StringExtensions");
+const colorizeString_1 = require("@trayio/cdk-cli-commons/utils/colorizeString");
+const NodeFsGenerator_1 = require("@trayio/generator/generator/NodeFsGenerator");
+const auth_detector_1 = require("../../lib/dynamic-output/auth-detector");
+class AddDynamicOutputSchema extends core_1.Command {
+    static description = 'Add a dynamic output schema operation for an existing operation';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> get_posts',
+        '<%= config.bin %> <%= command.id %> fetch_user_data',
+    ];
+    static args = {
+        operationName: core_1.Args.string({
+            name: 'operationName',
+            required: true,
+            description: 'Name of the parent operation to add dynamic output schema for',
+        }),
+    };
+    generator = new NodeFsGenerator_1.NodeFsGenerator();
+    async run() {
+        const { args } = await this.parse(AddDynamicOutputSchema);
+        const { operationName } = args;
+        const currentDirectory = process.cwd();
+        const srcDir = this.findSrcDirectory(currentDirectory);
+        // Validate parent operation exists
+        this.validateParentOperation(srcDir, operationName);
+        const parentOperationPath = path.join(srcDir, operationName);
+        const parentOperationJsonPath = path.join(parentOperationPath, 'operation.json');
+        this.log(`Checking for operation '${operationName}'... ✓`);
+        // Check if dynamic output schema operation already exists
+        const outputSchemaOpName = `${operationName}_output_schema`;
+        const outputSchemaOpPath = path.join(srcDir, outputSchemaOpName);
+        if (fse.existsSync(outputSchemaOpPath)) {
+            this.error((0, colorizeString_1.error)(`Dynamic output schema operation '${outputSchemaOpName}' already exists!`));
+        }
+        // Read parent operation.json
+        const parentOperationJson = await fse.readJson(parentOperationJsonPath);
+        // Detect auth configuration
+        const authInfo = await this.detectAuthConfig(srcDir);
+        this.log(`Creating dynamic output schema operation '${outputSchemaOpName}'...`);
+        // Build template values for generator
+        const templateValues = {
+            operationNameSnakeCase: operationName,
+            operationNameTitleCase: StringExtensions_1.StringExtensions.titleCase(operationName),
+            operationNamePascalCase: StringExtensions_1.StringExtensions.pascalCase(operationName),
+            operationNameCamelCase: StringExtensions_1.StringExtensions.camelCase(operationName),
+            outputSchemaOpNameSnakeCase: outputSchemaOpName,
+            outputSchemaOpNamePascalCase: StringExtensions_1.StringExtensions.pascalCase(outputSchemaOpName),
+            outputSchemaOpNameCamelCase: StringExtensions_1.StringExtensions.camelCase(outputSchemaOpName),
+            parentOpNameSnakeCase: operationName,
+            parentOpNamePascalCase: StringExtensions_1.StringExtensions.pascalCase(operationName),
+            parentOpNameCamelCase: StringExtensions_1.StringExtensions.camelCase(operationName),
+            authType: authInfo.authType,
+            authFileName: authInfo.authFileName,
+        };
+        // Generate files from template
+        const rootDir = __dirname;
+        const templateDir = path.join(rootDir, '..', '..', 'templates');
+        const templatePath = path.join(templateDir, 'dynamic-output-schema-template.zip');
+        await this.generator.generate(templatePath, srcDir, templateValues)();
+        this.log('  ✓ Generated operation files from template');
+        // Ensure the output schema operation directory exists
+        await fse.ensureDir(outputSchemaOpPath);
+        // Manually copy input.ts from parent operation (can't be templated)
+        await this.copyInputFromParent(parentOperationPath, outputSchemaOpPath, StringExtensions_1.StringExtensions.pascalCase(operationName), StringExtensions_1.StringExtensions.pascalCase(outputSchemaOpName));
+        // Update parent operation.json with dynamic_output: true
+        await this.updateParentOperationJson(parentOperationJsonPath, parentOperationJson);
+        // Success message with next steps
+        this.log('');
+        this.log((0, colorizeString_1.success)(`Success! Created dynamic output schema operation: ${outputSchemaOpName}`));
+        this.log('');
+        this.log('Next steps:');
+        this.log(`  1. Edit src/${outputSchemaOpName}/handler.ts`);
+        this.log('  2. Customize the data fetching logic for your use case');
+        this.log('  3. Run "tray-cdk connector build" to build the connector');
+        this.log('');
+        this.log('Note: Dynamic output is only safe for read-only GET operations!');
+    }
+    validateParentOperation(srcDir, operationName) {
+        const parentOperationPath = path.join(srcDir, operationName);
+        if (!fse.existsSync(parentOperationPath)) {
+            this.error((0, colorizeString_1.error)(`Operation '${operationName}' not found in src/ directory.\nMake sure you're in the connector root or src/ directory.`));
+        }
+        const parentOperationJsonPath = path.join(parentOperationPath, 'operation.json');
+        if (!fse.existsSync(parentOperationJsonPath)) {
+            this.error((0, colorizeString_1.error)(`Operation '${operationName}' exists but missing operation.json file.`));
+        }
+    }
+    async detectAuthConfig(srcDir) {
+        const connectorJsonPath = path.join(path.dirname(srcDir), 'connector.json');
+        try {
+            const connectorJson = await fse.readJson(connectorJsonPath);
+            return await auth_detector_1.AuthDetector.detectAuthInfo(srcDir, connectorJson.name);
+        }
+        catch (e) {
+            // If we can't read connector.json, use defaults
+            this.warn('Could not read connector.json, using default auth type. Auth import may need manual adjustment.');
+            return await auth_detector_1.AuthDetector.detectAuthInfo(srcDir);
+        }
+    }
+    async copyInputFromParent(parentOperationPath, outputSchemaOpPath, parentOpNamePascalCase, outputSchemaOpNamePascalCase) {
+        const parentInputPath = path.join(parentOperationPath, 'input.ts');
+        let inputTsContent;
+        if (fse.existsSync(parentInputPath)) {
+            // Read parent input.ts and copy it with renamed types
+            const parentInputContent = await fse.readFile(parentInputPath, 'utf-8');
+            // Replace the parent type name with the new type name
+            inputTsContent = parentInputContent.replace(new RegExp(`\\b${parentOpNamePascalCase}Input\\b`, 'g'), `${outputSchemaOpNamePascalCase}Input`);
+        }
+        else {
+            // Fallback: create a simple input type
+            inputTsContent = `export type ${outputSchemaOpNamePascalCase}Input = Record<string, any>;
+`;
+        }
+        await fse.writeFile(path.join(outputSchemaOpPath, 'input.ts'), inputTsContent);
+        this.log('  ✓ Generated input.ts from parent operation');
+    }
+    async updateParentOperationJson(parentOperationJsonPath, parentOperationJson) {
+        const updatedParentJson = {
+            ...parentOperationJson,
+            dynamic_output: true,
+        };
+        await fse.writeJson(parentOperationJsonPath, updatedParentJson, {
+            spaces: 2,
+        });
+        this.log('  ✓ Updated parent operation.json with dynamic_output: true');
+    }
+    findSrcDirectory(currentDirectory) {
+        const { base } = path.parse(currentDirectory);
+        if (base === 'src') {
+            return currentDirectory;
+        }
+        return path.join(currentDirectory, 'src');
+    }
+}
+exports.default = AddDynamicOutputSchema;

package/dist/commands/connector/add-dynamic-output-schema.unit.test.d.ts

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

package/dist/commands/connector/add-dynamic-output-schema.unit.test.d.ts.map

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

package/dist/commands/connector/add-dynamic-output-schema.unit.test.js

@@ -0,0 +1,335 @@
+"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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const stdout_stderr_1 = require("stdout-stderr");
+const fse = __importStar(require("fs-extra"));
+const path = __importStar(require("path"));
+const add_dynamic_output_schema_1 = __importDefault(require("./add-dynamic-output-schema"));
+jest.mock('fs-extra');
+describe('AddDynamicOutputSchema', () => {
+    const mockFse = fse;
+    const operationName = 'get_posts';
+    const outputSchemaOpName = 'get_posts_output_schema';
+    const srcDir = path.join(process.cwd(), 'src');
+    const parentOperationPath = path.join(srcDir, operationName);
+    const outputSchemaOpPath = path.join(srcDir, outputSchemaOpName);
+    beforeEach(() => {
+        jest.clearAllMocks();
+        // Default mocks for successful case
+        mockFse.existsSync.mockImplementation((filePath) => {
+            const pathStr = filePath.toString();
+            if (pathStr.includes(operationName) &&
+                pathStr.includes('operation.json')) {
+                return true; // Parent operation.json exists
+            }
+            if (pathStr.includes(operationName) &&
+                !pathStr.includes('output_schema')) {
+                return true; // Parent operation exists
+            }
+            if (pathStr.includes('output_schema')) {
+                return false; // Output schema operation doesn't exist yet
+            }
+            if (pathStr.includes('connector.json')) {
+                return true;
+            }
+            if (pathStr.includes('MyConnectorAuth.ts')) {
+                return true;
+            }
+            return false;
+        });
+        mockFse.readJson.mockImplementation(async (filePath) => {
+            const pathStr = filePath.toString();
+            if (pathStr.includes('connector.json')) {
+                return { name: 'my_connector' };
+            }
+            if (pathStr.includes('operation.json')) {
+                return {
+                    name: operationName,
+                    title: 'Get Posts',
+                    description: 'Get all posts',
+                };
+            }
+            return {};
+        });
+        mockFse.readFile.mockImplementation(async (filePath) => {
+            const pathStr = filePath.toString();
+            if (pathStr.includes('input.ts')) {
+                return `export type GetPostsInput = {
+	limit?: number;
+	offset?: number;
+};
+`;
+            }
+            if (pathStr.includes('Auth.ts')) {
+                return 'export type MyConnectorAuth = { apiKey: string };';
+            }
+            return '';
+        });
+        mockFse.readdir.mockImplementation(async (dirPath) => {
+            const pathStr = dirPath.toString();
+            if (pathStr.includes('src')) {
+                // Mock src directory contents with auth file
+                return [
+                    operationName,
+                    'MyConnectorAuth.ts',
+                    'connector.ts',
+                    'index.ts',
+                ];
+            }
+            return [];
+        });
+        mockFse.ensureDir.mockResolvedValue(undefined);
+        mockFse.writeJson.mockResolvedValue(undefined);
+        mockFse.writeFile.mockResolvedValue(undefined);
+    });
+    afterAll(() => {
+        jest.restoreAllMocks();
+    });
+    describe('successful operation creation', () => {
+        it('should create dynamic output schema operation for existing operation', async () => {
+            const command = new add_dynamic_output_schema_1.default([operationName], {});
+            const mockGenerate = jest
+                .fn()
+                .mockImplementation(() => jest.fn().mockResolvedValue(true));
+            command['generator'] = {
+                generate: mockGenerate,
+            };
+            stdout_stderr_1.stdout.start();
+            await command.run();
+            stdout_stderr_1.stdout.stop();
+            // Verify success message
+            expect(stdout_stderr_1.stdout.output).toContain(`Success! Created dynamic output schema operation: ${outputSchemaOpName}`);
+            // Verify generator was called with correct template and values
+            expect(mockGenerate).toHaveBeenCalledWith(expect.stringContaining('dynamic-output-schema-template.zip'), expect.stringContaining('/src'), expect.objectContaining({
+                operationNameSnakeCase: operationName,
+                outputSchemaOpNameSnakeCase: outputSchemaOpName,
+                parentOpNameSnakeCase: operationName,
+                authType: 'MyConnectorAuth',
+                authFileName: 'MyConnectorAuth',
+            }));
+            // Verify parent operation.json was updated with dynamic_output: true
+            expect(mockFse.writeJson).toHaveBeenCalledWith(path.join(parentOperationPath, 'operation.json'), expect.objectContaining({
+                dynamic_output: true,
+            }), { spaces: 2 });
+        });
+        it('should generate correct input.ts by copying and renaming from parent', async () => {
+            const command = new add_dynamic_output_schema_1.default([operationName], {});
+            const mockGenerate = jest
+                .fn()
+                .mockImplementation(() => jest.fn().mockResolvedValue(true));
+            command['generator'] = {
+                generate: mockGenerate,
+            };
+            stdout_stderr_1.stdout.start();
+            await command.run();
+            stdout_stderr_1.stdout.stop();
+            // Verify input.ts was written with renamed types
+            expect(mockFse.writeFile).toHaveBeenCalledWith(path.join(outputSchemaOpPath, 'input.ts'), expect.stringContaining('GetPostsOutputSchemaInput'));
+            // Verify it doesn't import from parent operation
+            const inputCall = mockFse.writeFile.mock.calls.find((call) => call[0].toString().includes('input.ts'));
+            expect(inputCall?.[1]).not.toContain(`from '../${operationName}/input'`);
+            expect(inputCall?.[1]).toContain('GetPostsOutputSchemaInput');
+        });
+        it('should handle input.ts fallback when parent input.ts does not exist', async () => {
+            mockFse.existsSync.mockImplementation((filePath) => {
+                const pathStr = filePath.toString();
+                if (pathStr.includes('input.ts')) {
+                    return false; // Parent input.ts doesn't exist
+                }
+                if (pathStr.includes(operationName) &&
+                    pathStr.includes('operation.json')) {
+                    return true;
+                }
+                if (pathStr.includes(operationName) &&
+                    !pathStr.includes('output_schema')) {
+                    return true;
+                }
+                if (pathStr.includes('connector.json')) {
+                    return true;
+                }
+                return false;
+            });
+            mockFse.readdir.mockResolvedValue([
+                operationName,
+                'MyConnectorAuth.ts',
+                'connector.ts',
+            ]);
+            const command = new add_dynamic_output_schema_1.default([operationName], {});
+            const mockGenerate = jest
+                .fn()
+                .mockImplementation(() => jest.fn().mockResolvedValue(true));
+            command['generator'] = {
+                generate: mockGenerate,
+            };
+            stdout_stderr_1.stdout.start();
+            await command.run();
+            stdout_stderr_1.stdout.stop();
+            // Verify fallback input.ts was created
+            const inputCall = mockFse.writeFile.mock.calls.find((call) => call[0].toString().includes('input.ts'));
+            expect(inputCall?.[1]).toContain('Record<string, any>');
+        });
+    });
+    describe('error handling', () => {
+        it('should error when parent operation does not exist', async () => {
+            mockFse.existsSync.mockReturnValue(false);
+            mockFse.readdir.mockResolvedValue([]);
+            const command = new add_dynamic_output_schema_1.default([operationName], {});
+            let errorThrown = false;
+            try {
+                await command.run();
+            }
+            catch (error) {
+                errorThrown = true;
+                expect(error.message).toContain(`Operation '${operationName}' not found`);
+            }
+            expect(errorThrown).toBe(true);
+        });
+        it('should error when parent operation.json is missing', async () => {
+            mockFse.existsSync.mockImplementation((filePath) => {
+                const pathStr = filePath.toString();
+                if (pathStr.includes('operation.json')) {
+                    return false; // operation.json doesn't exist
+                }
+                if (pathStr.includes(operationName)) {
+                    return true; // but operation folder exists
+                }
+                return false;
+            });
+            mockFse.readdir.mockResolvedValue([]);
+            const command = new add_dynamic_output_schema_1.default([operationName], {});
+            let errorThrown = false;
+            try {
+                await command.run();
+            }
+            catch (error) {
+                errorThrown = true;
+                expect(error.message).toContain('missing operation.json');
+            }
+            expect(errorThrown).toBe(true);
+        });
+        it('should error when dynamic output schema operation already exists', async () => {
+            mockFse.existsSync.mockImplementation((filePath) => 
+            // Everything exists including the output schema operation
+            true);
+            mockFse.readdir.mockResolvedValue([]);
+            const command = new add_dynamic_output_schema_1.default([operationName], {});
+            let errorThrown = false;
+            try {
+                await command.run();
+            }
+            catch (error) {
+                errorThrown = true;
+                expect(error.message).toContain('already exists');
+            }
+            expect(errorThrown).toBe(true);
+        });
+        it('should warn when connector.json cannot be read', async () => {
+            mockFse.readJson.mockImplementation(async (filePath) => {
+                const pathStr = filePath.toString();
+                if (pathStr.includes('connector.json')) {
+                    throw new Error('Cannot read connector.json');
+                }
+                if (pathStr.includes('operation.json')) {
+                    return {
+                        name: operationName,
+                        title: 'Get Posts',
+                    };
+                }
+                return {};
+            });
+            const command = new add_dynamic_output_schema_1.default([operationName], {});
+            stdout_stderr_1.stdout.start();
+            stdout_stderr_1.stderr.start();
+            await command.run();
+            stdout_stderr_1.stderr.stop();
+            stdout_stderr_1.stdout.stop();
+            // Should warn but still succeed
+            expect(stdout_stderr_1.stderr.output).toContain('Could not read connector.json');
+            expect(stdout_stderr_1.stdout.output).toContain('Success!');
+        });
+    });
+    describe('file detection', () => {
+        it('should detect standard {ConnectorName}Auth.ts pattern', async () => {
+            const command = new add_dynamic_output_schema_1.default([operationName], {});
+            const mockGenerate = jest
+                .fn()
+                .mockImplementation(() => jest.fn().mockResolvedValue(true));
+            command['generator'] = {
+                generate: mockGenerate,
+            };
+            stdout_stderr_1.stdout.start();
+            await command.run();
+            stdout_stderr_1.stdout.stop();
+            // Verify auth type was detected and passed to generator
+            expect(mockGenerate).toHaveBeenCalledWith(expect.anything(), expect.anything(), expect.objectContaining({
+                authType: 'MyConnectorAuth',
+                authFileName: 'MyConnectorAuth',
+            }));
+        });
+        it('should handle when in src/ directory', async () => {
+            // Mock process.cwd to return src directory
+            const originalCwd = process.cwd;
+            process.cwd = jest.fn().mockReturnValue(srcDir);
+            const command = new add_dynamic_output_schema_1.default([operationName], {});
+            const mockGenerate = jest
+                .fn()
+                .mockImplementation(() => jest.fn().mockResolvedValue(true));
+            command['generator'] = {
+                generate: mockGenerate,
+            };
+            stdout_stderr_1.stdout.start();
+            await command.run();
+            stdout_stderr_1.stdout.stop();
+            // Verify generator was called with src directory
+            expect(mockGenerate).toHaveBeenCalledWith(expect.anything(), srcDir, expect.anything());
+            // Restore
+            process.cwd = originalCwd;
+        });
+    });
+    describe('output messages', () => {
+        it('should display correct success message and next steps', async () => {
+            const command = new add_dynamic_output_schema_1.default([operationName], {});
+            const mockGenerate = jest
+                .fn()
+                .mockImplementation(() => jest.fn().mockResolvedValue(true));
+            command['generator'] = {
+                generate: mockGenerate,
+            };
+            stdout_stderr_1.stdout.start();
+            await command.run();
+            stdout_stderr_1.stdout.stop();
+            expect(stdout_stderr_1.stdout.output).toContain('Checking for operation');
+            expect(stdout_stderr_1.stdout.output).toContain('Creating dynamic output schema operation');
+            expect(stdout_stderr_1.stdout.output).toContain('✓ Generated operation files from template');
+            expect(stdout_stderr_1.stdout.output).toContain('✓ Generated input.ts from parent operation');
+            expect(stdout_stderr_1.stdout.output).toContain('✓ Updated parent operation.json');
+            expect(stdout_stderr_1.stdout.output).toContain('Next steps:');
+            expect(stdout_stderr_1.stdout.output).toContain(`Edit src/${outputSchemaOpName}/handler.ts`);
+        });
+    });
+});

package/dist/lib/dynamic-output/auth-detector.d.ts

@@ -0,0 +1,21 @@
+export interface AuthInfo {
+    authFileName: string;
+    authType: string;
+}
+/**
+ * Detects the authentication file and type for a connector
+ */
+export declare class AuthDetector {
+    /**
+     * Detects the auth file and extracts the auth type name
+     * @param srcDir - Path to the connector's src directory
+     * @param connectorName - Name of the connector from connector.json
+     * @returns AuthInfo with file name and type name
+     */
+    static detectAuthInfo(srcDir: string, connectorName?: string): Promise<AuthInfo>;
+    /**
+     * Find a file in a list using case-insensitive matching
+     */
+    private static findFileCaseInsensitive;
+}
+//# sourceMappingURL=auth-detector.d.ts.map

package/dist/lib/dynamic-output/auth-detector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth-detector.d.ts","sourceRoot":"","sources":["../../../src/lib/dynamic-output/auth-detector.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,QAAQ;IACxB,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,qBAAa,YAAY;IACxB;;;;;OAKG;WACU,cAAc,CAC1B,MAAM,EAAE,MAAM,EACd,aAAa,CAAC,EAAE,MAAM,GACpB,OAAO,CAAC,QAAQ,CAAC;IAkDpB;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,uBAAuB;CAQtC"}

package/dist/lib/dynamic-output/auth-detector.js

@@ -0,0 +1,85 @@
+"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.AuthDetector = void 0;
+const fse = __importStar(require("fs-extra"));
+const path = __importStar(require("path"));
+const StringExtensions_1 = require("@trayio/commons/string/StringExtensions");
+/**
+ * Detects the authentication file and type for a connector
+ */
+class AuthDetector {
+    /**
+     * Detects the auth file and extracts the auth type name
+     * @param srcDir - Path to the connector's src directory
+     * @param connectorName - Name of the connector from connector.json
+     * @returns AuthInfo with file name and type name
+     */
+    static async detectAuthInfo(srcDir, connectorName) {
+        let authFileName = 'Authentication';
+        let authType = 'NoAuth';
+        // Get all files in src directory for case-insensitive matching
+        const srcFiles = await fse.readdir(srcDir);
+        if (connectorName) {
+            const connectorNamePascalCase = StringExtensions_1.StringExtensions.pascalCase(connectorName);
+            // Check for {ConnectorName}Auth.ts pattern (standard pattern)
+            const standardAuthFile = `${connectorNamePascalCase}Auth.ts`;
+            const foundFile = this.findFileCaseInsensitive(srcFiles, standardAuthFile);
+            if (foundFile) {
+                authFileName = foundFile.replace('.ts', '');
+                authType = `${connectorNamePascalCase}Auth`;
+                return { authFileName, authType };
+            }
+        }
+        // Fall back to other common patterns
+        const authFiles = ['Authentication.ts', 'Auth.ts'];
+        const foundFile = authFiles
+            .map((pattern) => this.findFileCaseInsensitive(srcFiles, pattern))
+            .find((file) => file !== undefined);
+        if (foundFile) {
+            authFileName = foundFile.replace('.ts', '');
+            const authPath = path.join(srcDir, foundFile);
+            // Try to read and extract auth type name
+            try {
+                const authContent = await fse.readFile(authPath, 'utf-8');
+                const typeMatch = authContent.match(/export\s+type\s+(\w+)/);
+                if (typeMatch) {
+                    [, authType] = typeMatch;
+                }
+            }
+            catch (e) {
+                // If we can't read the file, use the default
+            }
+        }
+        return { authFileName, authType };
+    }
+    /**
+     * Find a file in a list using case-insensitive matching
+     */
+    static findFileCaseInsensitive(files, targetFile) {
+        return files.find((file) => file.toLowerCase() === targetFile.toLowerCase());
+    }
+}
+exports.AuthDetector = AuthDetector;

package/dist/lib/dynamic-output/index.d.ts

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

package/dist/lib/dynamic-output/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lib/dynamic-output/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/lib/dynamic-output/index.js

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

package/oclif.manifest.json

@@ -17,6 +17,37 @@
         "index.js"
       ]
     },
+    "connector:add-dynamic-output-schema": {
+      "aliases": [],
+      "args": {
+        "operationName": {
+          "description": "Name of the parent operation to add dynamic output schema for",
+          "name": "operationName",
+          "required": true
+        }
+      },
+      "description": "Add a dynamic output schema operation for an existing operation",
+      "examples": [
+        "<%= config.bin %> <%= command.id %> get_posts",
+        "<%= config.bin %> <%= command.id %> fetch_user_data"
+      ],
+      "flags": {},
+      "hasDynamicHelp": false,
+      "hiddenAliases": [],
+      "id": "connector:add-dynamic-output-schema",
+      "pluginAlias": "@trayio/cdk-cli",
+      "pluginName": "@trayio/cdk-cli",
+      "pluginType": "core",
+      "strict": true,
+      "enableJsonFlag": false,
+      "isESM": false,
+      "relativePath": [
+        "dist",
+        "commands",
+        "connector",
+        "add-dynamic-output-schema.js"
+      ]
+    },
     "connector:add-operation": {
       "aliases": [],
       "args": {
@@ -684,5 +715,5 @@
       ]
     }
   },
-  "version": "5.13.0"
+  "version": "5.14.0"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trayio/cdk-cli",
-  "version": "5.13.0",
+  "version": "5.14.0",
   "description": "A CLI for connector development",
   "exports": {
     "./*": "./dist/*.js"
@@ -22,13 +22,13 @@
     "@oclif/plugin-version": "2.0.11",
     "@oclif/plugin-warn-if-update-available": "^3.1.4",
     "@oclif/test": "3.1.12",
-    "@trayio/axios": "5.13.0",
-    "@trayio/cdk-build": "5.13.0",
-    "@trayio/cdk-cli-commons": "5.13.0",
-    "@trayio/commons": "5.13.0",
-    "@trayio/generator": "5.13.0",
-    "@trayio/tray-client": "5.13.0",
-    "@trayio/tray-openapi": "5.13.0",
+    "@trayio/axios": "5.14.0",
+    "@trayio/cdk-build": "5.14.0",
+    "@trayio/cdk-cli-commons": "5.14.0",
+    "@trayio/commons": "5.14.0",
+    "@trayio/generator": "5.14.0",
+    "@trayio/tray-client": "5.14.0",
+    "@trayio/tray-openapi": "5.14.0",
     "chalk": "4.1.2",
     "dotenv": "^16.0.0",
     "inquirer": "8.2.6"