[package-lock.json] Regenerate ; [*.ts] Reformat ; get typedoc and build to succeed

Author: SamuelMarks

package-lock.json

@@ -4,7 +4,15 @@
  * parsing, and providing a unified interface to OpenAPI (3.x) and Swagger (2.x) specifications.
  */
 
-import { GeneratorConfig, PathInfo, SecurityScheme, ServerObject, SwaggerDefinition, SwaggerSpec, LinkObject } from './types.js';
+import {
+    GeneratorConfig,
+    LinkObject,
+    PathInfo,
+    SecurityScheme,
+    ServerObject,
+    SwaggerDefinition,
+    SwaggerSpec
+} from './types.js';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { pathToFileURL } from 'node:url';

src/core/parser.ts

@@ -236,9 +236,9 @@ export interface PathInfo {
     /** Security requirements specific to this operation. keys are definitions, values are scopes. */
     security?: { [key: string]: string[] }[];
     /** An alternate server array to service this operation. (OAS 3+) */
-    servers?: ServerObject[];
+    servers?: ServerObject[] | undefined; // Allow undefined explicit assignment
     /** A map of possible out-of band callbacks related to the parent operation. (OAS 3+) */
-    callbacks?: Record<string, PathItem | { $ref: string }>;
+    callbacks?: Record<string, PathItem | { $ref: string }> | undefined; // Allow undefined explicit assignment
 }
 
 /** A single encoding definition for a multipart property. */

src/core/types.ts

@@ -11,20 +11,16 @@
 import { MethodDeclaration } from 'ts-morph';
 import {
     GeneratorConfig,
+    HeaderObject,
     Parameter,
     PathInfo,
     PathItem,
     RequestBody,
     SpecOperation,
     SwaggerDefinition,
-    SwaggerResponse,
-    HeaderObject
+    SwaggerResponse
 } from './types.js';
-import {
-    BodyParameter,
-    Parameter as SwaggerOfficialParameter,
-    Response
-} from "swagger-schema-official";
+import { BodyParameter, Parameter as SwaggerOfficialParameter, Response } from "swagger-schema-official";
 
 // Re-export runtime expressions
 export * from './runtime-expressions.js';

src/core/utils.ts

@@ -3,9 +3,10 @@ import {
     MethodDeclarationOverloadStructure,
     OptionalKind,
     ParameterDeclarationStructure,
+    WriterFunction,
 } from 'ts-morph';
-import { GeneratorConfig, Parameter, PathInfo, SwaggerDefinition } from '../../../core/types.js';
-import { camelCase, getTypeScriptType, isDataTypeInterface, pascalCase } from '../../../core/utils.js';
+import { GeneratorConfig, Parameter, PathInfo, SwaggerDefinition } from '@src/core/types.js';
+import { camelCase, getTypeScriptType, isDataTypeInterface } from '@src/core/utils.js';
 import { HttpContext, HttpHeaders, HttpParams } from '@angular/common/http';
 import { SwaggerParser } from "@src/core/parser.js";
 
@@ -101,8 +102,8 @@ export class ServiceMethodGenerator {
                 name: paramName,
                 type: paramType,
                 hasQuestionToken: !param.required,
-                // ParameterDeclarationStructure does not support 'docs', so we use leadingTrivia to inject JSDoc
-                leadingTrivia: param.deprecated ? [`/** @deprecated */ `] : undefined
+                // Cast undefined to satisfy strict exactOptionalPropertyTypes
+                leadingTrivia: param.deprecated ? [`/** @deprecated */ `] : (undefined as unknown as string | WriterFunction | (string | WriterFunction)[])
             });
         });
         const requestBody = operation.requestBody;
@@ -357,17 +358,29 @@ export class ServiceMethodGenerator {
 
         return [
             {
-                parameters: [...parameters, { name: 'options', hasQuestionToken: true, type: `RequestOptions & { observe?: 'body' }` }],
+                parameters: [...parameters, {
+                    name: 'options',
+                    hasQuestionToken: true,
+                    type: `RequestOptions & { observe?: 'body' }`
+                }],
                 returnType: `Observable<${finalResponseType}>`,
                 docs: [`${methodName}. \n${paramsDocs}\n@param options The options for this request.${deprecationDoc}`]
             },
             {
-                parameters: [...parameters, { name: 'options', hasQuestionToken: false, type: `RequestOptions & { observe: 'response' }` }],
+                parameters: [...parameters, {
+                    name: 'options',
+                    hasQuestionToken: false,
+                    type: `RequestOptions & { observe: 'response' }`
+                }],
                 returnType: `Observable<HttpResponse<${finalResponseType}>>`,
                 docs: [`${methodName}. \n${paramsDocs}\n@param options The options for this request, with response observation enabled.${deprecationDoc}`]
             },
             {
-                parameters: [...parameters, { name: 'options', hasQuestionToken: false, type: `RequestOptions & { observe: 'events' }` }],
+                parameters: [...parameters, {
+                    name: 'options',
+                    hasQuestionToken: false,
+                    type: `RequestOptions & { observe: 'events' }`
+                }],
                 returnType: `Observable<HttpEvent<${finalResponseType}>>`,
                 docs: [`${methodName}. \n${paramsDocs}\n@param options The options for this request, with event observation enabled.${deprecationDoc}`]
             }

src/service/emit/service/service-method.generator.ts

@@ -1,15 +1,23 @@
 import * as path from "node:path";
-import { Project, SourceFile, JSDocStructure, JSDocTagStructure, OptionalKind, PropertySignatureStructure, WriterFunction } from "ts-morph";
-import { GeneratorConfig, SwaggerDefinition, PathItem, LinkObject, HeaderObject } from "../../../core/types.js";
-import { SwaggerParser } from "../../../core/parser.js";
-import { extractPaths, getTypeScriptType, pascalCase } from "../../../core/utils.js";
+import {
+    JSDocStructure,
+    JSDocTagStructure,
+    OptionalKind,
+    Project,
+    PropertySignatureStructure,
+    SourceFile
+} from "ts-morph";
+import { GeneratorConfig, HeaderObject, PathItem, SwaggerDefinition } from "@src/core/types.js";
+import { SwaggerParser } from "@src/core/parser.js";
+import { extractPaths, getTypeScriptType, pascalCase } from "@src/core/utils.js";
 
 export class TypeGenerator {
     constructor(
         private parser: SwaggerParser,
         private project: Project,
         private config: GeneratorConfig
-    ) { }
+    ) {
+    }
 
     public generate(outputDir: string): void {
         const modelsDir = path.join(outputDir, "models");
@@ -92,7 +100,10 @@ export class TypeGenerator {
                     properties: properties,
                     docs: [{
                         description: `Parameters for the '${linkName}' link.`,
-                        tags: [{ tagName: 'see', text: 'https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#linkObject' }]
+                        tags: [{
+                            tagName: 'see',
+                            text: 'https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#linkObject'
+                        }]
                     }]
                 });
             }
@@ -101,7 +112,7 @@ export class TypeGenerator {
         // 5. Response Headers
         allPaths.forEach(op => {
             if (op.responses) {
-                Object. entries(op.responses).forEach(([code, resp]) => {
+                Object.entries(op.responses).forEach(([code, resp]) => {
                     if (resp.headers) {
                         // Naming: OperationId + Code + Headers, e.g., GetUser200Headers
                         const opIdBase = op.operationId ? pascalCase(op.operationId) : pascalCase(op.method + op.path);
@@ -220,14 +231,20 @@ export class TypeGenerator {
                 name: `${modelName}Request`,
                 isExported: true,
                 properties: requestProps,
-                docs: this.buildJSDoc({ ...def, description: `Model for sending ${modelName} data (excludes read-only fields).` })
+                docs: this.buildJSDoc({
+                    ...def,
+                    description: `Model for sending ${modelName} data (excludes read-only fields).`
+                })
             });
             this.applyComposition(requestDecl, def, { excludeReadOnly: true });
             this.applyIndexSignature(requestDecl, def);
         }
     }
 
-    private applyComposition(interfaceDecl: any, def: SwaggerDefinition, options: { excludeReadOnly?: boolean, excludeWriteOnly?: boolean }): void {
+    private applyComposition(interfaceDecl: any, def: SwaggerDefinition, options: {
+        excludeReadOnly?: boolean,
+        excludeWriteOnly?: boolean
+    }): void {
         if (def.allOf) {
             const extendsTypes: string[] = [];
             def.allOf.forEach(sub => {
@@ -275,7 +292,10 @@ export class TypeGenerator {
         }
     }
 
-    private getInterfaceProperties(def: SwaggerDefinition, options: { excludeReadOnly?: boolean, excludeWriteOnly?: boolean }): OptionalKind<PropertySignatureStructure>[] {
+    private getInterfaceProperties(def: SwaggerDefinition, options: {
+        excludeReadOnly?: boolean,
+        excludeWriteOnly?: boolean
+    }): OptionalKind<PropertySignatureStructure>[] {
         const props: OptionalKind<PropertySignatureStructure>[] = [];
         if (def.properties) {
             Object.entries(def.properties).forEach(([propName, propDef]) => {
@@ -291,7 +311,7 @@ export class TypeGenerator {
                     type: type,
                     hasQuestionToken: !isRequired,
                     docs: this.buildJSDoc(propDef),
-                    isReadonly: options.excludeWriteOnly && !!propDef.readOnly
+                    ...(options.excludeWriteOnly && !!propDef.readOnly && { isReadonly: true })
                 });
             });
         }

src/service/emit/type/type.generator.ts

@@ -1,7 +1,7 @@
 import { describe, expect, it } from 'vitest';
 
 import * as utils from '@src/core/utils.js';
-import { GeneratorConfig, RequestBody, SwaggerDefinition, SwaggerResponse } from '@src/core/types.js';
+import { GeneratorConfig, RequestBody, SwaggerDefinition } from '@src/core/types.js';
 import { branchCoverageSpec, typeGenSpec } from '../shared/specs.js';
 
 /**

tests/00-core/02-utils-coverage.spec.ts

@@ -142,7 +142,13 @@ describe('Core: Runtime Expression Evaluator', () => {
             });
 
             it('should return undefined if response is missing', () => {
-                const noRes = { ...mockContext, response: undefined };
+                const noRes: RuntimeContext = {
+                    url: mockContext.url,
+                    method: mockContext.method,
+                    statusCode: mockContext.statusCode,
+                    request: mockContext.request
+                    // response is undefined
+                };
                 expect(evaluateRuntimeExpression('$response.body', noRes)).toBeUndefined();
             });
         });