@trayio/cdk-cli 5.13.0-unstable → 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-unstable 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

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

@@ -5,7 +5,12 @@ export default class AddDynamicOutputSchema extends Command {
     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

@@ -1 +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;AAS5C,MAAM,CAAC,OAAO,OAAO,sBAAuB,SAAQ,OAAO;IAC1D,MAAM,CAAC,WAAW,SACiD;IAEnE,MAAM,CAAC,QAAQ,WAGb;IAEF,MAAM,CAAC,IAAI;;MAOT;IAEI,GAAG;IA+PT,OAAO,CAAC,gBAAgB;CAOxB"}
+{"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

@@ -28,6 +28,8 @@ 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 = [
@@ -41,20 +43,16 @@ class AddDynamicOutputSchema extends core_1.Command {
             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);
-        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.`));
-        }
         this.log(`Checking for operation '${operationName}'... ✓`);
         // Check if dynamic output schema operation already exists
         const outputSchemaOpName = `${operationName}_output_schema`;
@@ -64,173 +62,95 @@ class AddDynamicOutputSchema extends core_1.Command {
         }
         // Read parent operation.json
         const parentOperationJson = await fse.readJson(parentOperationJsonPath);
-        // Get connector name to construct auth file name (matches add-operation pattern)
+        // 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');
-        let connectorNamePascalCase = 'MyConnector';
-        let authFileName = 'Authentication';
-        let authType = 'NoAuth';
         try {
             const connectorJson = await fse.readJson(connectorJsonPath);
-            connectorNamePascalCase = StringExtensions_1.StringExtensions.pascalCase(connectorJson.name);
-            // Check for {ConnectorName}Auth.ts pattern (standard pattern)
-            const standardAuthFile = `${connectorNamePascalCase}Auth.ts`;
-            const standardAuthPath = path.join(srcDir, standardAuthFile);
-            if (fse.existsSync(standardAuthPath)) {
-                authFileName = standardAuthFile.replace('.ts', '');
-                authType = `${connectorNamePascalCase}Auth`;
-            }
-            else {
-                // Fall back to other common patterns
-                const authFiles = ['Authentication.ts', 'Auth.ts'];
-                const foundAuthFile = authFiles.find((file) => {
-                    const authPath = path.join(srcDir, file);
-                    return fse.existsSync(authPath);
-                });
-                if (foundAuthFile) {
-                    authFileName = foundAuthFile.replace('.ts', '');
-                    // Try to read and extract auth type name
-                    const authContent = await fse.readFile(path.join(srcDir, foundAuthFile), 'utf-8');
-                    const typeMatch = authContent.match(/export\s+type\s+(\w+)/);
-                    if (typeMatch) {
-                        [, authType] = typeMatch;
-                    }
-                }
-            }
+            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);
         }
-        this.log(`Creating dynamic output schema operation '${outputSchemaOpName}'...`);
-        // Create operation folder
-        await fse.ensureDir(outputSchemaOpPath);
-        this.log('  ✓ Created operation folder');
-        // Generate names
-        const parentOpNamePascalCase = StringExtensions_1.StringExtensions.pascalCase(operationName);
-        const outputSchemaOpNamePascalCase = StringExtensions_1.StringExtensions.pascalCase(outputSchemaOpName);
-        const parentOpNameCamelCase = operationName
-            .split('_')
-            .map((word, i) => i === 0 ? word : word.charAt(0).toUpperCase() + word.slice(1))
-            .join('');
-        const outputSchemaOpNameCamelCase = outputSchemaOpName
-            .split('_')
-            .map((word, i) => i === 0 ? word : word.charAt(0).toUpperCase() + word.slice(1))
-            .join('');
-        // 1. Generate operation.json
-        const operationJson = {
-            name: outputSchemaOpName,
-            title: `${StringExtensions_1.StringExtensions.titleCase(operationName)} Output Schema`,
-            description: `Dynamic output schema generator for ${operationName} (private operation)`,
-            isPrivate: true,
-        };
-        await fse.writeJson(path.join(outputSchemaOpPath, 'operation.json'), operationJson, { spaces: 2 });
-        this.log('  ✓ Generated operation.json');
-        // 2. Generate input.ts (re-export from parent)
-        const inputTsContent = `export type { ${parentOpNamePascalCase}Input as ${outputSchemaOpNamePascalCase}Input } from '../${operationName}/input';
+    }
+    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');
-        // 3. Generate output.ts
-        const outputTsContent = `import { DynamicOutput } from '@trayio/cdk-dsl/connector/operation/OperationHandler';
-
-export type ${outputSchemaOpNamePascalCase}Output = DynamicOutput;
-`;
-        await fse.writeFile(path.join(outputSchemaOpPath, 'output.ts'), outputTsContent);
-        this.log('  ✓ Generated output.ts');
-        // 4. Generate handler.ts from template
-        const handlerTsContent = `import { OperationHandlerSetup } from '@trayio/cdk-dsl/connector/operation/OperationHandlerSetup';
-import {
-	OperationHandlerResult,
-	DynamicOutput,
-} from '@trayio/cdk-dsl/connector/operation/OperationHandler';
-import { JsonSchemaIntrospector } from '@trayio/commons/schema/JsonSchemaIntrospector';
-import { ${parentOpNamePascalCase}Input } from '../${operationName}/input';
-import { ${authType} } from '../${authFileName}';
-import { ${parentOpNameCamelCase}Handler } from '../${operationName}/handler';
-
-/**
- * Dynamic output schema handler for ${operationName}
- * 
- * This handler generates a JSON Schema by introspecting actual API responses.
- * Customize the data-fetching logic below for your specific use case.
- */
-export const ${outputSchemaOpNameCamelCase}Handler =
-	OperationHandlerSetup.configureDynamicOutputHandler<
-		${authType},
-		${parentOpNamePascalCase}Input
-	>((handler) =>
-		handler.usingComposite(async (ctx, input, invoke) => {
-			try {
-				// TODO: Customize this logic for your use case
-				
-				// Option 1: Invoke the main operation (ONLY for read-only GET operations!)
-				const result = await invoke(${parentOpNameCamelCase}Handler)(input);
-				
-				// Option 2: Call a metadata/schema endpoint instead
-				// const result = await invoke(getSchemaMetadataHandler)(input);
-				
-				// Option 3: Compute schema without API calls
-				// const schema = computeSchemaBasedOnInput(input);
-				// return OperationHandlerResult.success<DynamicOutput>({ output_schema: schema });
-				
-				if (result.isFailure) {
-					// Return generic fallback schema on error
-					return OperationHandlerResult.success<DynamicOutput>({
-						output_schema: {
-							type: 'object',
-							additionalProperties: true,
-							description: 'Generic schema - operation failed',
-						},
-					});
-				}
-
-				// Use the standard JsonSchemaIntrospector utility to convert response to JSON Schema
-				const schema = JsonSchemaIntrospector.introspectToJsonSchema(
-					result.value,
-					{
-						maxDepth: 10,
-						includeExamples: false,
-						strictRequired: true,
-					}
-				);
-
-				return OperationHandlerResult.success<DynamicOutput>({
-					output_schema: schema,
-				});
-			} catch (error) {
-				// Fallback on any error
-				return OperationHandlerResult.success<DynamicOutput>({
-					output_schema: {
-						type: 'object',
-						additionalProperties: true,
-						description: 'Fallback schema due to error',
-					},
-				});
-			}
-		})
-	);
-`;
-        await fse.writeFile(path.join(outputSchemaOpPath, 'handler.ts'), handlerTsContent);
-        this.log('  ✓ Generated handler.ts (with JsonSchemaIntrospector template)');
-        // 5. Update parent operation.json with isDynamicOutput: true
+        this.log('  ✓ Generated input.ts from parent operation');
+    }
+    async updateParentOperationJson(parentOperationJsonPath, parentOperationJson) {
         const updatedParentJson = {
             ...parentOperationJson,
-            isDynamicOutput: true,
+            dynamic_output: true,
         };
         await fse.writeJson(parentOperationJsonPath, updatedParentJson, {
             spaces: 2,
         });
-        this.log(`  ✓ Updated parent operation.json with isDynamicOutput: true`);
-        // 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!');
+        this.log('  ✓ Updated parent operation.json with dynamic_output: true');
     }
     findSrcDirectory(currentDirectory) {
         const { base } = path.parse(currentDirectory);

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

@@ -715,5 +715,5 @@
       ]
     }
   },
-  "version": "5.13.0-unstable"
+  "version": "5.14.0"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trayio/cdk-cli",
-  "version": "5.13.0-unstable",
+  "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-unstable",
-    "@trayio/cdk-build": "5.13.0-unstable",
-    "@trayio/cdk-cli-commons": "5.13.0-unstable",
-    "@trayio/commons": "5.13.0-unstable",
-    "@trayio/generator": "5.13.0-unstable",
-    "@trayio/tray-client": "5.13.0-unstable",
-    "@trayio/tray-openapi": "5.13.0-unstable",
+    "@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"
@@ -92,6 +92,5 @@
   "devDependencies": {
     "@types/inquirer": "8.2.6",
     "oclif": "*"
-  },
-  "stableVersion": "0.0.0"
+  }
 }