Increase test coverage

Author: SamuelMarks

.github/workflows/tests_and_coverage.yml

@@ -42,7 +42,7 @@ jobs:
         uses: codecov/test-results-action@v1
         with:
           token: ${{ secrets.CODECOV_TOKEN }}
-#          flags: report-type="test_results"
+          #          flags: report-type="test_results"
           flags: unittests
           files: ./coverage/junit.xml
           disable_search: true

EXTENDING.md

@@ -1,22 +1,27 @@
 # Guide to Extending the Code Generator
 
-This document provides instructions on how to extend the generator to support new frameworks (like React or Vue) and new HTTP clients (like Axios).
+This document provides instructions on how to extend the generator to support new frameworks (like React or Vue) and new
+HTTP clients (like Axios).
 
 ## Architectural Overview
 
 The generator is built on a clean, three-layer architecture designed for extensibility:
 
-1.  **Core Layer (`src/core`)**: Parses the OpenAPI specification. This layer is completely framework-agnostic.
-2.  **Analysis / IR Layer (`src/analysis`)**: Analyzes the parsed spec and converts it into a framework-agnostic **Intermediate Representation (IR)**. This IR provides a simple, abstract model of services, forms, lists, and validation rules. This is the key to decoupling.
-3.  **Generation Layer (`src/generators`)**: Consumes the IR and generates framework-specific code. All framework-specific logic is isolated here.
+1. **Core Layer (`src/core`)**: Parses the OpenAPI specification. This layer is completely framework-agnostic.
+2. **Analysis / IR Layer (`src/analysis`)**: Analyzes the parsed spec and converts it into a framework-agnostic *
+   *Intermediate Representation (IR)**. This IR provides a simple, abstract model of services, forms, lists, and
+   validation rules. This is the key to decoupling.
+3. **Generation Layer (`src/generators`)**: Consumes the IR and generates framework-specific code. All
+   framework-specific logic is isolated here.
 
 To add support for a new technology, you will primarily be working in the **Generation Layer**.
 
 ---
 
 ## How to Add a New Framework (e.g., React)
 
-Adding a new framework like React involves creating a new set of generators that consume the existing IR from the `src/analysis` layer and emit React-specific code (e.g., TypeScript with JSX).
+Adding a new framework like React involves creating a new set of generators that consume the existing IR from the
+`src/analysis` layer and emit React-specific code (e.g., TypeScript with JSX).
 
 ### 1. Create the Framework Directory
 
@@ -36,7 +41,9 @@ src/generators/
 
 ### 2. Implement the Main Client Generator
 
-Create `src/generators/react/react-client.generator.ts`. This file will be the main orchestrator for your framework's code generation. It must implement the `IClientGenerator` interface. You can use `src/generators/angular/angular-client.generator.ts` as a reference.
+Create `src/generators/react/react-client.generator.ts`. This file will be the main orchestrator for your framework's
+code generation. It must implement the `IClientGenerator` interface. You can use
+`src/generators/angular/angular-client.generator.ts` as a reference.
 
 ```typescript
 // src/generators/react/react-client.generator.ts
@@ -62,7 +69,7 @@ export class ReactClientGenerator extends AbstractClientGenerator {
         //     const adminGenerator = new ReactAdminGenerator(...);
         //     adminGenerator.generate(outputDir);
         // }
-        
+
         console.log(`🎉 React client generation complete!`);
     }
 }
@@ -79,7 +86,8 @@ Add `'react'` to the `framework` option's choices.
 ```typescript
 // src/cli.ts
 // ... inside the 'from_openapi' command definition
-.addOption(new Option('--framework <framework>', 'Target framework').choices(['angular', 'react', 'vue']))
+.
+addOption(new Option('--framework <framework>', 'Target framework').choices(['angular', 'react', 'vue']))
 ```
 
 #### In `src/index.ts`:
@@ -105,11 +113,12 @@ function getGeneratorFactory(framework: string): IClientGenerator {
 
 Your React service generator will generate hooks instead of Angular services.
 
-1.  Create `src/generators/react/service/service-method.generator.ts`.
-2.  Use the `ServiceMethodAnalyzer` from `src/analysis` to get the `ServiceMethodModel` (the IR).
-3.  Use this model to generate a custom hook (e.g., `useGetUserById`) that uses an HTTP client like `fetch` or `axios`.
+1. Create `src/generators/react/service/service-method.generator.ts`.
+2. Use the `ServiceMethodAnalyzer` from `src/analysis` to get the `ServiceMethodModel` (the IR).
+3. Use this model to generate a custom hook (e.g., `useGetUserById`) that uses an HTTP client like `fetch` or `axios`.
 
 **Example Logic:**
+
 ```typescript
 // Inside your React Service Method Generator
 import { ServiceMethodAnalyzer } from '@src/analysis/service-method-analyzer.ts';
@@ -129,15 +138,18 @@ export const use${pascalCase(model.methodName)} = () => {
 
 If you want to generate an admin UI:
 
-1.  Use `FormModelBuilder` and `ListModelBuilder` from `src/analysis` to get the `FormAnalysisResult` and `ListViewModel`.
-2.  Create React-specific generators that consume this IR to produce JSX.
-3.  You will need to create a **React-specific renderer for validation**. For example, create a `ValidationRenderer` that converts the `ValidationRule[]` IR into a `Yup` schema for use with Formik.
+1. Use `FormModelBuilder` and `ListModelBuilder` from `src/analysis` to get the `FormAnalysisResult` and
+   `ListViewModel`.
+2. Create React-specific generators that consume this IR to produce JSX.
+3. You will need to create a **React-specific renderer for validation**. For example, create a `ValidationRenderer` that
+   converts the `ValidationRule[]` IR into a `Yup` schema for use with Formik.
 
 ---
 
 ## How to Add a New HTTP Client (e.g., Axios)
 
-This change is much simpler as it's localized within a specific framework's generator. Here’s how to do it for the existing Angular generator.
+This change is much simpler as it's localized within a specific framework's generator. Here’s how to do it for the
+existing Angular generator.
 
 ### 1. Locate the HTTP Call Logic
 
@@ -175,8 +187,9 @@ Replace the `this.http.*` calls with your desired client's syntax.
 
 **To switch to Axios, you would:**
 
-1.  Change the imports at the top of `src/generators/angular/service/service.generator.ts` to import `axios` and `from` from `rxjs` (to wrap the Promise in an Observable).
-2.  Modify the `emitMethodBody` logic to build an `axios` config object and make the call.
+1. Change the imports at the top of `src/generators/angular/service/service.generator.ts` to import `axios` and `from`
+   from `rxjs` (to wrap the Promise in an Observable).
+2. Modify the `emitMethodBody` logic to build an `axios` config object and make the call.
 
 **Example Change (Conceptual):**
 
@@ -193,4 +206,5 @@ lines.push(`const config = { headers, params };`);
 lines.push(`return from(axios.get(url, config));`);
 ```
 
-You would need to adapt the `requestOptions` object to the format expected by Axios. You could also add a configuration option in `config.ts` to let the user choose which HTTP client to generate code for.
+You would need to adapt the `requestOptions` object to the format expected by Axios. You could also add a configuration
+option in `config.ts` to let the user choose which HTTP client to generate code for.

README.md

@@ -168,6 +168,7 @@ npm install
 npm run build
 npm install -g .
 ```
+
 (I'll put it up on npmjs soon)
 
 ## Usage

src/generators/angular/utils/index.generator.ts

@@ -69,17 +69,24 @@ export class ServiceIndexGenerator {
 
     public generateIndex(outputRoot: string): void {
         const servicesDir = path.join(outputRoot, "services");
+
+        // Use path.resolve for robust comparison of directory paths (normalizes separators and makes absolute)
+        // This handles cases where ts-morph internal paths and input path formats differ (e.g. windows vs posix)
+        const absServicesDir = path.resolve(servicesDir);
+
+        const serviceFiles = this.project.getSourceFiles().filter(sf => {
+            const absFileDir = path.resolve(path.dirname(sf.getFilePath()));
+            return absFileDir === absServicesDir && sf.getFilePath().endsWith('.service.ts');
+        });
+
+        if (serviceFiles.length === 0) return;
+
+        // Create index file
         const indexPath = path.join(servicesDir, "index.ts");
         const sourceFile = this.project.createSourceFile(indexPath, "", { overwrite: true });
 
         sourceFile.insertText(0, SERVICE_INDEX_GENERATOR_HEADER_COMMENT);
 
-        const servicesDirectory = this.project.getDirectory(servicesDir);
-        if (!servicesDirectory) return;
-
-        const serviceFiles = servicesDirectory.getSourceFiles()
-            .filter(sf => sf.getFilePath().endsWith('.service.ts'));
-
         for (const serviceFile of serviceFiles) {
             const serviceClass = serviceFile.getClasses()[0];
             const className = serviceClass?.getName();

tests/00-core/parser/reference-resolver.spec.ts

@@ -0,0 +1,133 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { ReferenceResolver } from '@src/core/parser/reference-resolver.js';
+import { SwaggerSpec } from "@src/core/types/index.js";
+
+describe('Core: ReferenceResolver', () => {
+    let cache: Map<string, SwaggerSpec>;
+    let resolver: ReferenceResolver;
+    const rootUri = 'file:///root.json';
+
+    beforeEach(() => {
+        cache = new Map();
+        cache.set(rootUri, { openapi: '3.0.0', paths: {} } as any);
+        resolver = new ReferenceResolver(cache, rootUri);
+    });
+
+    describe('indexSchemaIds', () => {
+        it('should index standard $id and anchors', () => {
+            const spec = {
+                schemas: {
+                    User: { $id: 'http://example.com/user', $anchor: 'local', $dynamicAnchor: 'dyn' }
+                }
+            };
+            ReferenceResolver.indexSchemaIds(spec, rootUri, cache);
+            expect(cache.has('http://example.com/user')).toBe(true);
+            expect(cache.has('http://example.com/user#local')).toBe(true);
+            expect(cache.has('http://example.com/user#dyn')).toBe(true);
+        });
+
+        it('should safely ignore invalid IDs', () => {
+            const spec = { schemas: { Bad: { $id: 'invalid-uri' } } };
+            expect(() => ReferenceResolver.indexSchemaIds(spec, rootUri, cache)).not.toThrow();
+        });
+    });
+
+    describe('resolveReference', () => {
+        it('should handle JSON pointer traversal', () => {
+            cache.set(rootUri, { nested: { val: 123 } } as any);
+            const res = resolver.resolveReference('#/nested/val');
+            expect(res).toBe(123);
+        });
+
+        it('should return undefined and warn when traversal fails on missing property', () => {
+            const spy = vi.spyOn(console, 'warn').mockImplementation(() => {
+            });
+            cache.set(rootUri, { nested: {} } as any);
+            const res = resolver.resolveReference('#/nested/missing');
+            expect(res).toBeUndefined();
+            expect(spy).toHaveBeenCalledWith(expect.stringContaining('Failed to resolve reference part "missing"'));
+        });
+
+        // ** NEW COVERAGE **
+        // Hits line 144 logic: `result` is valid object but doesn't have property
+        it('should warn if property access fails during traversal', () => {
+            const spy = vi.spyOn(console, 'warn').mockImplementation(() => {
+            });
+            cache.set(rootUri, { a: { b: 1 } } as any);
+            // 'c' doesn't exist on { b: 1 }
+            const res = resolver.resolveReference('#/a/c');
+            expect(res).toBeUndefined();
+            expect(spy).toHaveBeenCalledWith(expect.stringContaining('Failed to resolve reference part "c"'));
+        });
+
+        it('should return undefined and warn when traversal fails on null intermediate', () => {
+            const spy = vi.spyOn(console, 'warn').mockImplementation(() => {
+            });
+            cache.set(rootUri, { nested: null } as any);
+            const res = resolver.resolveReference('#/nested/child');
+            expect(res).toBeUndefined();
+            expect(spy).toHaveBeenCalledWith(expect.stringContaining('Failed to resolve reference part "child"'));
+        });
+
+        it('should resolve references to external files in cache', () => {
+            cache.set('http://external.com/doc.json', { id: 'extern' } as any);
+            const res = resolver.resolveReference('http://external.com/doc.json#/id');
+            expect(res).toBe('extern');
+        });
+
+        it('should return undefined if external file missing from cache', () => {
+            const spy = vi.spyOn(console, 'warn').mockImplementation(() => {
+            });
+            const res = resolver.resolveReference('http://missing.com/doc.json');
+            expect(res).toBeUndefined();
+            expect(spy).toHaveBeenCalledWith(expect.stringContaining('Unresolved external file reference'));
+        });
+
+        it('should warn on invalid reference type input', () => {
+            const spy = vi.spyOn(console, 'warn').mockImplementation(() => {
+            });
+            const res = resolver.resolveReference(123 as any);
+            expect(res).toBeUndefined();
+            expect(spy).toHaveBeenCalledWith(expect.stringContaining('Encountered an unsupported or invalid reference'));
+        });
+    });
+
+    describe('findRefs', () => {
+        it('should find all $ref and $dynamicRef strings', () => {
+            const obj = {
+                a: { $ref: '#/a' },
+                b: [{ $dynamicRef: '#/b' }],
+                c: 'not-a-ref'
+            };
+            const refs = ReferenceResolver.findRefs(obj);
+            expect(refs).toContain('#/a');
+            expect(refs).toContain('#/b');
+            expect(refs.length).toBe(2);
+        });
+    });
+
+    describe('resolve', () => {
+        it('should augment resolved object with summary/description from ref wrapper', () => {
+            cache.set(rootUri, { defs: { Target: { type: 'string', description: 'Original' } } } as any);
+            const refObj = {
+                $ref: '#/defs/Target',
+                description: 'Overridden',
+                summary: 'Summary'
+            };
+            const res: any = resolver.resolve(refObj);
+            expect(res.type).toBe('string');
+            expect(res.description).toBe('Overridden');
+            expect(res.summary).toBe('Summary');
+        });
+
+        it('should return null/undefined if input is null/undefined', () => {
+            expect(resolver.resolve(null)).toBeUndefined();
+            expect(resolver.resolve(undefined)).toBeUndefined();
+        });
+
+        it('should return input object if it is not a reference', () => {
+            const obj = { type: 'number' };
+            expect(resolver.resolve(obj)).toBe(obj);
+        });
+    });
+});