fetch-client-generator 1.0.1 → 1.1.0

package/api-client.js

@@ -0,0 +1,67 @@
+class ApiClient {
+  constructor(baseUrl = '', options = {}) {
+    this.baseUrl = baseUrl;
+    this.defaultOptions = {
+      headers: {
+        'Content-Type': 'application/json',
+        ...options.headers
+      },
+      ...options
+    };
+  }
+
+  async request(path, options = {}) {
+    const url = this.baseUrl + path;
+    const config = {
+      ...this.defaultOptions,
+      ...options,
+      headers: {
+        ...this.defaultOptions.headers,
+        ...options.headers
+      }
+    };
+
+    const response = await fetch(url, config);
+    
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`);
+    }
+
+    const contentType = response.headers.get('content-type');
+    if (contentType && contentType.includes('application/json')) {
+      return await response.json();
+    } else if (contentType && contentType.includes('text/')) {
+      return await response.text();
+    } else {
+      return response;
+    }
+  }
+
+  async token() {
+    return await this.request('/authentication/token', {
+      method: 'POST'
+    });
+  }
+
+  async logout(data) {
+    return await this.request('/authentication/logout', {
+      method: 'POST',
+      body: JSON.stringify(data)
+    });
+  }
+
+  async getAuthenticationPing() {
+    return await this.request('/authentication/ping', {
+      method: 'GET'
+    });
+  }
+
+  async getApiOrganisations() {
+    return await this.request('/api/organisations', {
+      method: 'GET'
+    });
+  }
+
+}
+
+export default ApiClient;

package/bin/cli.js

@@ -1,9 +1,10 @@
 #!/usr/bin/env node
 
 import { program } from 'commander';
-import { readFileSync } from 'fs';
+import { readFileSync, writeFileSync } from 'fs';
 import { fileURLToPath } from 'url';
 import path from 'path';
+import { generate } from '../index.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -20,10 +21,29 @@ program
   .option('-i, --input <file>', 'input specification file')
   .option('-o, --output <file>', 'output file path')
   .action((options) => {
-    console.log('Generating fetch client...');
-    console.log('Input:', options.input);
-    console.log('Output:', options.output);
-    // Implementation will go here
+    if (!options.input) {
+      console.error('Error: Input file is required');
+      process.exit(1);
+    }
+
+    if (!options.output) {
+      console.error('Error: Output file is required');
+      process.exit(1);
+    }
+
+    try {
+      console.log('Generating fetch client...');
+      console.log('Input:', options.input);
+      console.log('Output:', options.output);
+
+      const clientCode = generate(options.input);
+      writeFileSync(options.output, clientCode, 'utf8');
+      
+      console.log('✓ Fetch client generated successfully!');
+    } catch (error) {
+      console.error('Error generating client:', error.message);
+      process.exit(1);
+    }
   });
 
 program.parse();

package/index.js

@@ -1,4 +1,141 @@
-// fetch-client-generator main entry point
+import { readFileSync } from 'fs';
+
+export function parseOpenAPISpec(specPath) {
+  const spec = JSON.parse(readFileSync(specPath, 'utf8'));
+  
+  const endpoints = [];
+  
+  for (const [path, pathItem] of Object.entries(spec.paths)) {
+    for (const [method, operation] of Object.entries(pathItem)) {
+      const endpoint = {
+        path,
+        method: method.toUpperCase(),
+        operationId: operation.operationId,
+        requestBody: operation.requestBody,
+        responses: operation.responses,
+        tags: operation.tags
+      };
+      endpoints.push(endpoint);
+    }
+  }
+  
+  return {
+    info: spec.info,
+    endpoints,
+    schemas: spec.components?.schemas || {}
+  };
+}
+
+export function generateFetchClient(parsedSpec, options = {}) {
+  const { info, endpoints, schemas } = parsedSpec;
+  const className = options.className || 'ApiClient';
+  
+  let clientCode = `class ${className} {
+  constructor(baseUrl = '', options = {}) {
+    this.baseUrl = baseUrl;
+    this.defaultOptions = {
+      headers: {
+        'Content-Type': 'application/json',
+        ...options.headers
+      },
+      ...options
+    };
+  }
+
+  async request(path, options = {}) {
+    const url = this.baseUrl + path;
+    const config = {
+      ...this.defaultOptions,
+      ...options,
+      headers: {
+        ...this.defaultOptions.headers,
+        ...options.headers
+      }
+    };
+
+    const response = await fetch(url, config);
+    
+    if (!response.ok) {
+      throw new Error(\`HTTP error! status: \${response.status}\`);
+    }
+
+    const contentType = response.headers.get('content-type');
+    if (contentType && contentType.includes('application/json')) {
+      return await response.json();
+    } else if (contentType && contentType.includes('text/')) {
+      return await response.text();
+    } else {
+      return response;
+    }
+  }
+
+`;
+
+  for (const endpoint of endpoints) {
+    let methodName = endpoint.operationId;
+    
+    if (!methodName) {
+      // Generate camelCase method name from path and method
+      const pathParts = endpoint.path.split('/').filter(part => part && !part.startsWith('{'));
+      // Convert each part to PascalCase and join
+      const pascalParts = pathParts.map(part => part.charAt(0).toUpperCase() + part.slice(1));
+      const cleanPath = pascalParts.join('');
+      methodName = `${endpoint.method.toLowerCase()}${cleanPath}`;
+    }
+    
+    // Convert to camelCase if not already
+    methodName = methodName.charAt(0).toLowerCase() + methodName.slice(1);
+    
+    const hasRequestBody = endpoint.requestBody && 
+      endpoint.requestBody.content && 
+      Object.keys(endpoint.requestBody.content).length > 0;
+    
+    const params = hasRequestBody ? 'data' : '';
+    const methodParams = params ? `(${params})` : '()';
+    
+    clientCode += `  async ${methodName}${methodParams} {
+`;
+    
+    if (hasRequestBody) {
+      clientCode += `    return await this.request('${endpoint.path}', {
+      method: '${endpoint.method}',
+      body: JSON.stringify(data)
+    });
+`;
+    } else {
+      clientCode += `    return await this.request('${endpoint.path}', {
+      method: '${endpoint.method}'
+    });
+`;
+    }
+    
+    clientCode += `  }
+
+`;
+  }
+  
+  clientCode += `}
+
+export default ${className};`;
+  
+  return clientCode;
+}
+
+export function generate(inputPath, outputPath, options = {}) {
+  const parsedSpec = parseOpenAPISpec(inputPath);
+  const clientCode = generateFetchClient(parsedSpec, options);
+  
+  if (outputPath) {
+    import('fs').then(({ writeFileSync }) => {
+      writeFileSync(outputPath, clientCode, 'utf8');
+    });
+  }
+  
+  return clientCode;
+}
+
 export default {
-  // Main functionality will be implemented here
+  parseOpenAPISpec,
+  generateFetchClient,
+  generate
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fetch-client-generator",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "A tool for generating fetch-based HTTP client code",
   "main": "index.js",
   "type": "module",

package/test/index.test.js

@@ -1,8 +1,104 @@
 import { expect } from 'chai';
-import fetchClientGenerator from '../index.js';
+import { parseOpenAPISpec, generateFetchClient, generate } from '../index.js';
+import { writeFileSync, unlinkSync } from 'fs';
+import path from 'path';
+
+const sampleOpenAPI = {
+  "openapi": "3.0.1",
+  "info": {
+    "title": "Test API",
+    "version": "1.0.0"
+  },
+  "paths": {
+    "/users": {
+      "get": {
+        "operationId": "getUsers",
+        "responses": {
+          "200": {
+            "description": "OK",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "array",
+                  "items": {
+                    "type": "object"
+                  }
+                }
+              }
+            }
+          }
+        }
+      },
+      "post": {
+        "operationId": "createUser",
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "type": "object",
+                "properties": {
+                  "name": { "type": "string" }
+                }
+              }
+            }
+          }
+        },
+        "responses": {
+          "201": {
+            "description": "Created"
+          }
+        }
+      }
+    }
+  }
+};
 
 describe('fetch-client-generator', () => {
-  it('should export an object', () => {
-    expect(fetchClientGenerator).to.be.an('object');
+  let testSpecPath;
+
+  beforeEach(() => {
+    testSpecPath = path.join(process.cwd(), 'test-spec.json');
+    writeFileSync(testSpecPath, JSON.stringify(sampleOpenAPI, null, 2));
+  });
+
+  afterEach(() => {
+    try {
+      unlinkSync(testSpecPath);
+    } catch (err) {
+      // File might not exist
+    }
+  });
+
+  describe('parseOpenAPISpec', () => {
+    it('should parse OpenAPI specification', () => {
+      const result = parseOpenAPISpec(testSpecPath);
+      
+      expect(result).to.have.property('info');
+      expect(result).to.have.property('endpoints');
+      expect(result).to.have.property('schemas');
+      expect(result.info.title).to.equal('Test API');
+      expect(result.endpoints).to.have.length(2);
+    });
+  });
+
+  describe('generateFetchClient', () => {
+    it('should generate fetch client code', () => {
+      const parsedSpec = parseOpenAPISpec(testSpecPath);
+      const clientCode = generateFetchClient(parsedSpec);
+      
+      expect(clientCode).to.include('class ApiClient');
+      expect(clientCode).to.include('async getUsers()');
+      expect(clientCode).to.include('async createUser(data)');
+      expect(clientCode).to.include('fetch(url, config)');
+    });
+  });
+
+  describe('generate', () => {
+    it('should generate and return client code', () => {
+      const clientCode = generate(testSpecPath);
+      
+      expect(clientCode).to.be.a('string');
+      expect(clientCode).to.include('class ApiClient');
+    });
   });
 });