@aloma.io/integration-sdk 3.8.54 → 3.8.56

package/test/scenarios/complex/specs/products.json

@@ -0,0 +1,308 @@
+{
+  "openapi": "3.0.0",
+  "info": {
+    "title": "Products API",
+    "version": "1.0.0",
+    "description": "A simple products management API"
+  },
+  "servers": [
+    {
+      "url": "https://api.testshop.com",
+      "description": "Production server"
+    }
+  ],
+  "paths": {
+    "/products": {
+      "get": {
+        "operationId": "getProducts",
+        "summary": "List all products",
+        "parameters": [
+          {
+            "name": "limit",
+            "in": "query",
+            "schema": {
+              "type": "integer",
+              "minimum": 1,
+              "maximum": 100
+            },
+            "description": "Maximum number of products to return"
+          },
+          {
+            "name": "category",
+            "in": "query",
+            "schema": {
+              "type": "string"
+            },
+            "description": "Filter by category"
+          },
+          {
+            "name": "archived",
+            "in": "query",
+            "schema": {
+              "type": "boolean"
+            },
+            "description": "Include archived products"
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "List of products",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProductList"
+                }
+              }
+            }
+          }
+        }
+      },
+      "post": {
+        "operationId": "createProduct",
+        "summary": "Create a new product",
+        "requestBody": {
+          "required": true,
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/CreateProductRequest"
+              }
+            }
+          }
+        },
+        "responses": {
+          "201": {
+            "description": "Product created",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/Product"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/products/{productId}": {
+      "get": {
+        "operationId": "getProduct",
+        "summary": "Get a specific product",
+        "parameters": [
+          {
+            "name": "productId",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string"
+            },
+            "description": "The product ID"
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Product details",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/Product"
+                }
+              }
+            }
+          }
+        }
+      },
+      "put": {
+        "operationId": "updateProduct",
+        "summary": "Update a product",
+        "parameters": [
+          {
+            "name": "productId",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string"
+            },
+            "description": "The product ID"
+          }
+        ],
+        "requestBody": {
+          "required": true,
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/UpdateProductRequest"
+              }
+            }
+          }
+        },
+        "responses": {
+          "200": {
+            "description": "Product updated",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/Product"
+                }
+              }
+            }
+          }
+        }
+      },
+      "delete": {
+        "operationId": "deleteProduct",
+        "summary": "Delete a product",
+        "parameters": [
+          {
+            "name": "productId",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string"
+            },
+            "description": "The product ID"
+          }
+        ],
+        "responses": {
+          "204": {
+            "description": "Product deleted"
+          }
+        }
+      }
+    }
+  },
+  "components": {
+    "schemas": {
+      "Product": {
+        "type": "object",
+        "required": ["id", "name", "price"],
+        "properties": {
+          "id": {
+            "type": "string",
+            "description": "Unique product identifier"
+          },
+          "name": {
+            "type": "string",
+            "description": "Product name"
+          },
+          "description": {
+            "type": "string",
+            "description": "Product description"
+          },
+          "price": {
+            "type": "number",
+            "minimum": 0,
+            "description": "Product price"
+          },
+          "category": {
+            "type": "string",
+            "description": "Product category"
+          },
+          "inStock": {
+            "type": "boolean",
+            "description": "Whether product is in stock"
+          },
+          "tags": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            },
+            "description": "Product tags"
+          },
+          "createdAt": {
+            "type": "string",
+            "format": "date-time",
+            "description": "Creation timestamp"
+          },
+          "updatedAt": {
+            "type": "string",
+            "format": "date-time",
+            "description": "Last update timestamp"
+          }
+        }
+      },
+      "ProductList": {
+        "type": "object",
+        "properties": {
+          "products": {
+            "type": "array",
+            "items": {
+              "$ref": "#/components/schemas/Product"
+            }
+          },
+          "total": {
+            "type": "integer",
+            "description": "Total number of products"
+          },
+          "hasMore": {
+            "type": "boolean",
+            "description": "Whether there are more products available"
+          }
+        }
+      },
+      "CreateProductRequest": {
+        "type": "object",
+        "required": ["name", "price"],
+        "properties": {
+          "name": {
+            "type": "string",
+            "description": "Product name"
+          },
+          "description": {
+            "type": "string",
+            "description": "Product description"
+          },
+          "price": {
+            "type": "number",
+            "minimum": 0,
+            "description": "Product price"
+          },
+          "category": {
+            "type": "string",
+            "description": "Product category"
+          },
+          "tags": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            },
+            "description": "Product tags"
+          }
+        }
+      },
+      "UpdateProductRequest": {
+        "type": "object",
+        "properties": {
+          "name": {
+            "type": "string",
+            "description": "Product name"
+          },
+          "description": {
+            "type": "string",
+            "description": "Product description"
+          },
+          "price": {
+            "type": "number",
+            "minimum": 0,
+            "description": "Product price"
+          },
+          "category": {
+            "type": "string",
+            "description": "Product category"
+          },
+          "inStock": {
+            "type": "boolean",
+            "description": "Whether product is in stock"
+          },
+          "tags": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            },
+            "description": "Product tags"
+          }
+        }
+      }
+    }
+  }
+}

package/test/scenarios/simple/expected-controller.mts

@@ -0,0 +1,60 @@
+import {AbstractController} from '@aloma.io/integration-sdk';
+
+export default class Controller extends AbstractController {
+  
+  private api: any;
+
+  protected async start(): Promise<void> {
+    const config = this.config;
+    
+    this.api = this.getClient({
+      baseUrl: 'https://api.example.com',
+      customize(request) {
+        request.headers ||= {};
+        // Add authentication headers based on your API requirements
+        // Example: request.headers["Authorization"] = `Bearer ${config.apiToken}`;
+      },
+    });
+  }
+
+  /**
+ * Get all products
+ *
+ *
+ * @returns {Promise<any>} GET /products response
+   */
+  async getProducts() {
+    const url = '/products';
+
+    const fetchOptions: any = {
+      method: 'GET',
+    };
+
+    return this.api.fetch(url, fetchOptions);
+  }
+
+  /**
+ * Create product
+ *
+ * @param {Object} options - Request options
+ * @param {any} options.body (required) - Request body
+ *
+ * @returns {Promise<any>} POST /products response
+   */
+  async createProduct(options: {body?: any}) {
+    options = options || {};
+
+    const url = '/products';
+
+    const { headers, ...bodyData } = options;
+    const requestBody = Object.keys(bodyData).length > 0 ? bodyData : undefined;
+
+    const fetchOptions: any = {
+      method: 'POST',
+      body: requestBody,
+      headers: options.headers,
+    };
+
+    return this.api.fetch(url, fetchOptions);
+  }
+}

package/test/scenarios/simple/simple-api.json

@@ -0,0 +1,39 @@
+{
+  "openapi": "3.0.0",
+  "info": {
+    "title": "Simple API",
+    "version": "1.0.0"
+  },
+  "paths": {
+    "/products": {
+      "get": {
+        "operationId": "getProducts",
+        "summary": "Get all products",
+        "responses": {
+          "200": {
+            "description": "Success"
+          }
+        }
+      },
+      "post": {
+        "operationId": "createProduct",
+        "summary": "Create product",
+        "requestBody": {
+          "required": true,
+          "content": {
+            "application/json": {
+              "schema": {
+                "type": "object"
+              }
+            }
+          }
+        },
+        "responses": {
+          "201": {
+            "description": "Created"
+          }
+        }
+      }
+    }
+  }
+}

package/test/scenarios.test.mts

@@ -0,0 +1,286 @@
+import { describe, it } from 'mocha';
+import { expect } from 'chai';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { OpenAPIToConnector } from '../build/openapi-to-connector.mjs';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+describe('Scenario Tests - Full Code Generation', () => {
+  
+  describe('Simple Scenario (single controller)', () => {
+    it('should generate exact expected output for simple-api.json', () => {
+      // Read input spec
+      const specPath = path.join(__dirname, 'scenarios/simple/simple-api.json');
+      const specContent = fs.readFileSync(specPath, 'utf-8');
+      const spec = OpenAPIToConnector.parseSpec(specContent);
+      
+      // Read expected output
+      const expectedPath = path.join(__dirname, 'scenarios/simple/expected-controller.mts');
+      const expectedOutput = fs.readFileSync(expectedPath, 'utf-8');
+      
+      // Generate actual output
+      const generator = new OpenAPIToConnector(spec, 'simple-test');
+      const actualOutput = generator.generateController();
+      
+      // Compare outputs (normalize line endings)
+      const normalizeOutput = (output: string) => output
+        .replace(/\r\n/g, '\n')
+        .trim();
+      
+      expect(normalizeOutput(actualOutput)).to.equal(normalizeOutput(expectedOutput));
+    });
+
+    it('should correctly handle methods without options', () => {
+      // Read input spec
+      const specPath = path.join(__dirname, 'scenarios/simple/simple-api.json');
+      const specContent = fs.readFileSync(specPath, 'utf-8');
+      const spec = OpenAPIToConnector.parseSpec(specContent);
+      
+      // Generate actual output
+      const generator = new OpenAPIToConnector(spec, 'simple-test');
+      const actualOutput = generator.generateController();
+      
+      // Verify methods without options don't have unnecessary code
+      expect(actualOutput).to.include('async getProducts() {'); // No options parameter
+      expect(actualOutput).to.not.include('options = options || {}'); // No options initialization for getProducts
+      expect(actualOutput).to.include('async createProduct(options:'); // Has options parameter
+      expect(actualOutput).to.include('options = options || {};'); // Has options initialization for createProduct
+    });
+  });
+
+  describe('Complex Scenario (multi-resource)', () => {
+    it('should generate exact expected main controller output', () => {
+      // Read input specs
+      const productsSpecPath = path.join(__dirname, 'scenarios/complex/specs/products.json');
+      const ordersSpecPath = path.join(__dirname, 'scenarios/complex/specs/orders.json');
+      const productsSpecContent = fs.readFileSync(productsSpecPath, 'utf-8');
+      const ordersSpecContent = fs.readFileSync(ordersSpecPath, 'utf-8');
+      
+      const productsSpec = OpenAPIToConnector.parseSpec(productsSpecContent);
+      const ordersSpec = OpenAPIToConnector.parseSpec(ordersSpecContent);
+      
+      // Read expected output
+      const expectedPath = path.join(__dirname, 'scenarios/complex/expected/controller.mts');
+      const expectedOutput = fs.readFileSync(expectedPath, 'utf-8');
+      
+      // Generate actual output
+      const resources = [
+        { className: 'ProductsResource', fileName: 'products' },
+        { className: 'OrdersResource', fileName: 'orders' }
+      ];
+      const resourceSpecs = [
+        { fileName: 'products', spec: productsSpec },
+        { fileName: 'orders', spec: ordersSpec }
+      ];
+      
+      const mainGenerator = new OpenAPIToConnector(productsSpec, 'test-shop-temp');
+      const actualOutput = mainGenerator.generateMainController(resources, resourceSpecs);
+      
+      // Compare outputs (normalize line endings)
+      const normalizeOutput = (output: string) => output
+        .replace(/\r\n/g, '\n')
+        .trim();
+      
+      expect(normalizeOutput(actualOutput)).to.equal(normalizeOutput(expectedOutput));
+    });
+
+    it('should generate exact expected products resource output', () => {
+      // Read input spec
+      const specPath = path.join(__dirname, 'scenarios/complex/specs/products.json');
+      const specContent = fs.readFileSync(specPath, 'utf-8');
+      const spec = OpenAPIToConnector.parseSpec(specContent);
+      
+      // Read expected output
+      const expectedPath = path.join(__dirname, 'scenarios/complex/expected/products-resource.mts');
+      const expectedOutput = fs.readFileSync(expectedPath, 'utf-8');
+      
+      // Generate actual output
+      const generator = new OpenAPIToConnector(spec, 'test-shop');
+      const actualOutput = generator.generateResourceClass('ProductsResource');
+      
+      // Compare outputs (normalize line endings)
+      const normalizeOutput = (output: string) => output
+        .replace(/\r\n/g, '\n')
+        .trim();
+      
+      expect(normalizeOutput(actualOutput)).to.equal(normalizeOutput(expectedOutput));
+    });
+
+    it('should generate exact expected orders resource output', () => {
+      // Read input spec
+      const specPath = path.join(__dirname, 'scenarios/complex/specs/orders.json');
+      const specContent = fs.readFileSync(specPath, 'utf-8');
+      const spec = OpenAPIToConnector.parseSpec(specContent);
+      
+      // Read expected output
+      const expectedPath = path.join(__dirname, 'scenarios/complex/expected/orders-resource.mts');
+      const expectedOutput = fs.readFileSync(expectedPath, 'utf-8');
+      
+      // Generate actual output
+      const generator = new OpenAPIToConnector(spec, 'test-shop');
+      const actualOutput = generator.generateResourceClass('OrdersResource');
+      
+      // Compare outputs (normalize line endings)
+      const normalizeOutput = (output: string) => output
+        .replace(/\r\n/g, '\n')
+        .trim();
+      
+      expect(normalizeOutput(actualOutput)).to.equal(normalizeOutput(expectedOutput));
+    });
+
+    it('should correctly handle TypeScript interface generation', () => {
+      // Read products spec
+      const specPath = path.join(__dirname, 'scenarios/complex/specs/products.json');
+      const specContent = fs.readFileSync(specPath, 'utf-8');
+      const spec = OpenAPIToConnector.parseSpec(specContent);
+      
+      // Generate output
+      const generator = new OpenAPIToConnector(spec, 'test-shop');
+      const actualOutput = generator.generateResourceClass('ProductsResource');
+      
+      // Verify TypeScript interfaces are generated correctly
+      expect(actualOutput).to.include('export interface Product {');
+      expect(actualOutput).to.include('export interface ProductList {');
+      expect(actualOutput).to.include('export interface CreateProductRequest {');
+      expect(actualOutput).to.include('export interface UpdateProductRequest {');
+      
+      // Verify proper TypeScript types in method signatures
+      expect(actualOutput).to.include('Promise<ProductList>');
+      expect(actualOutput).to.include('Promise<Product>');
+    });
+
+    it('should correctly handle path parameters and options separation', () => {
+      // Read orders spec (has path parameters)
+      const specPath = path.join(__dirname, 'scenarios/complex/specs/orders.json');
+      const specContent = fs.readFileSync(specPath, 'utf-8');
+      const spec = OpenAPIToConnector.parseSpec(specContent);
+      
+      // Generate output
+      const generator = new OpenAPIToConnector(spec, 'test-shop');
+      const actualOutput = generator.generateResourceClass('OrdersResource');
+      
+      // Verify path parameters are handled correctly
+      expect(actualOutput).to.include('export function getOrder(this: any, orderId: string)');
+      expect(actualOutput).to.include('export function updateOrderStatus(this: any, orderId: string, options');
+      expect(actualOutput).to.include('export function cancelOrder(this: any, orderId: string)');
+      
+      // Verify methods without options don't have unnecessary code
+      expect(actualOutput).to.match(/export function getOrder\(this: any, orderId: string\) \{/);
+      expect(actualOutput).to.match(/export function cancelOrder\(this: any, orderId: string\) \{/);
+    });
+
+    it('should correctly expose resource methods in main controller', () => {
+      // Read both specs
+      const productsSpecPath = path.join(__dirname, 'scenarios/complex/specs/products.json');
+      const ordersSpecPath = path.join(__dirname, 'scenarios/complex/specs/orders.json');
+      const productsSpecContent = fs.readFileSync(productsSpecPath, 'utf-8');
+      const ordersSpecContent = fs.readFileSync(ordersSpecPath, 'utf-8');
+      
+      const productsSpec = OpenAPIToConnector.parseSpec(productsSpecContent);
+      const ordersSpec = OpenAPIToConnector.parseSpec(ordersSpecContent);
+      
+      // Generate main controller
+      const resources = [
+        { className: 'ProductsResource', fileName: 'products' },
+        { className: 'OrdersResource', fileName: 'orders' }
+      ];
+      const resourceSpecs = [
+        { fileName: 'products', spec: productsSpec },
+        { fileName: 'orders', spec: ordersSpec }
+      ];
+      
+      const mainGenerator = new OpenAPIToConnector(productsSpec, 'test-shop');
+      const actualOutput = mainGenerator.generateMainController(resources, resourceSpecs);
+      
+      // Verify exposed methods exist
+      expect(actualOutput).to.include('async productsGetProducts(');
+      expect(actualOutput).to.include('async productsCreateProduct(');
+      expect(actualOutput).to.include('async productsGetProduct(');
+      expect(actualOutput).to.include('async productsUpdateProduct(');
+      expect(actualOutput).to.include('async productsDeleteProduct(');
+      
+      expect(actualOutput).to.include('async ordersGetOrders(');
+      expect(actualOutput).to.include('async ordersCreateOrder(');
+      expect(actualOutput).to.include('async ordersGetOrder(');
+      expect(actualOutput).to.include('async ordersUpdateOrderStatus(');
+      expect(actualOutput).to.include('async ordersCancelOrder(');
+      
+      // Verify resource binding
+      expect(actualOutput).to.include('this.bindResourceFunctions(\'products\', productsFunctions);');
+      expect(actualOutput).to.include('this.bindResourceFunctions(\'orders\', ordersFunctions);');
+    });
+  });
+
+  describe('Regression Tests', () => {
+    it('should handle OpenAPI schemas with different naming patterns', () => {
+      const testSpec = {
+        openapi: '3.0.0',
+        info: { title: 'Test API', version: '1.0.0' },
+        paths: {
+          '/test': {
+            get: {
+              operationId: 'testOperation',
+              responses: {
+                '200': {
+                  description: 'Success',
+                  content: {
+                    'application/json': {
+                      schema: {
+                        '$ref': '#/components/schemas/Complex.Name.With.Dots'
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        },
+        components: {
+          schemas: {
+            'Complex.Name.With.Dots': {
+              type: 'object',
+              properties: {
+                id: { type: 'string' },
+                name: { type: 'string' }
+              }
+            }
+          }
+        }
+      };
+
+      const generator = new OpenAPIToConnector(testSpec, 'test');
+      const output = generator.generateController();
+      
+      // Should generate valid TypeScript interface names
+      expect(output).to.include('export interface Complex_Name_With_Dots {');
+      expect(output).to.not.include('export interface Complex.Name.With.Dots {'); // Invalid TS
+      expect(output).to.include('Promise<Complex_Name_With_Dots>');
+    });
+
+    it('should not add options parameter to methods that don\'t need it', () => {
+      const simpleSpec = {
+        openapi: '3.0.0',
+        info: { title: 'Simple API', version: '1.0.0' },
+        paths: {
+          '/simple': {
+            get: {
+              operationId: 'getSimple',
+              responses: { '200': { description: 'Success' } }
+            }
+          }
+        }
+      };
+
+      const generator = new OpenAPIToConnector(simpleSpec, 'test');
+      const output = generator.generateController();
+      
+      // Should not have options parameter or initialization
+      expect(output).to.include('async getSimple() {');
+      expect(output).to.not.include('options = options || {}');
+      expect(output).to.not.include('headers: options');
+    });
+  });
+});