ts-class-to-openapi 1.0.6 → 1.1.1

package/dist/index.js

@@ -16,10 +16,10 @@ const jsPrimitives = {
     Object: { type: 'Object', value: 'object' },
     Array: { type: 'Array', value: 'array' },
     Date: { type: 'Date', value: 'string', format: 'date-time' },
-    Buffer: { type: 'Buffer', value: 'string'},
-    Uint8Array: { type: 'Uint8Array', value: 'string'},
+    Buffer: { type: 'Buffer'},
+    Uint8Array: { type: 'Uint8Array'},
     UploadFile: { type: 'UploadFile', value: 'string', format: 'binary' },
-    File: { type: 'File', value: 'string'},
+    File: { type: 'File'},
 };
 const validatorDecorators = {
     Length: { name: 'Length'},
@@ -68,9 +68,42 @@ class SchemaTransformer {
         this.program = ts.createProgram(fileNames, tsOptions);
         this.checker = this.program.getTypeChecker();
     }
-    getPropertiesByClassDeclaration(classNode) {
+    getPropertiesByClassDeclaration(classNode, visitedDeclarations = new Set()) {
+        if (visitedDeclarations.has(classNode)) {
+            return [];
+        }
+        visitedDeclarations.add(classNode);
+        // if no heritage clauses, get properties directly from class
+        if (!classNode.heritageClauses) {
+            return this.getPropertiesByClassMembers(classNode.members, classNode);
+        } // use heritage clauses to get properties from base classes
+        else {
+            const heritageClause = classNode.heritageClauses[0];
+            if (heritageClause &&
+                heritageClause.token === ts.SyntaxKind.ExtendsKeyword) {
+                const type = heritageClause.types[0];
+                let properties = [];
+                let baseProperties = [];
+                if (!type)
+                    return [];
+                const symbol = this.checker.getSymbolAtLocation(type.expression);
+                if (!symbol)
+                    return [];
+                const declaration = symbol.declarations?.[0];
+                if (declaration && ts.isClassDeclaration(declaration)) {
+                    baseProperties = this.getPropertiesByClassDeclaration(declaration, visitedDeclarations);
+                }
+                properties = this.getPropertiesByClassMembers(classNode.members, classNode);
+                return baseProperties.concat(properties);
+            }
+            else {
+                return this.getPropertiesByClassMembers(classNode.members, classNode);
+            }
+        }
+    }
+    getPropertiesByClassMembers(members, parentClassNode) {
         const properties = [];
-        for (const member of classNode.members) {
+        for (const member of members) {
             if (ts.isPropertyDeclaration(member) &&
                 member.name &&
                 ts.isIdentifier(member.name)) {
@@ -80,6 +113,8 @@ class SchemaTransformer {
                 const isOptional = !!member.questionToken;
                 const isGeneric = this.isPropertyTypeGeneric(member);
                 const isPrimitive = this.isPrimitiveType(type);
+                const isClassType = this.isClassType(member);
+                const isArray = this.isArrayProperty(member);
                 const property = {
                     name: propertyName,
                     type,
@@ -88,9 +123,25 @@ class SchemaTransformer {
                     isGeneric,
                     originalProperty: member,
                     isPrimitive,
-                    isClassType: this.isClassType(member),
-                    isArray: this.isArrayProperty(member),
+                    isClassType,
+                    isArray,
+                    isRef: false,
                 };
+                // Check for self-referencing properties to mark as $ref
+                if (property.isClassType) {
+                    const declaration = this.getDeclarationProperty(property);
+                    if (parentClassNode) {
+                        if (declaration &&
+                            declaration.name &&
+                            this.checker.getSymbolAtLocation(declaration.name) ===
+                                this.checker.getSymbolAtLocation(parentClassNode.name)) {
+                            property.isRef = true;
+                        }
+                    }
+                    else {
+                        debugger;
+                    }
+                }
                 properties.push(property);
             }
         }
@@ -458,7 +509,7 @@ class SchemaTransformer {
         }
         return ts.isArrayTypeNode(propertyDeclaration.type);
     }
-    getSchemaFromProperties({ properties, visitedClass, transformedSchema, }) {
+    getSchemaFromProperties({ properties, visitedClass, transformedSchema, classDeclaration, }) {
         let schema = {};
         const required = [];
         for (const property of properties) {
@@ -466,6 +517,7 @@ class SchemaTransformer {
                 property,
                 visitedClass,
                 transformedSchema,
+                classDeclaration,
             });
             // this.applyDecorators(property, schema as SchemaType)
             if (!property.isOptional) {
@@ -478,17 +530,35 @@ class SchemaTransformer {
             required: required.length ? required : undefined,
         };
     }
-    getSchemaFromProperty({ property, visitedClass, transformedSchema, }) {
+    getSchemaFromProperty({ property, visitedClass, transformedSchema, classDeclaration, }) {
         let schema = {};
         if (property.isPrimitive) {
             schema = this.getSchemaFromPrimitive(property);
         }
         else if (property.isClassType) {
-            schema = this.getSchemaFromClass({
-                property,
-                visitedClass,
-                transformedSchema,
-            });
+            const declaration = this.getDeclarationProperty(property);
+            if (property.isRef && classDeclaration.name) {
+                // Self-referencing property, handle as a reference to avoid infinite recursion
+                if (property.isArray) {
+                    schema.type = 'array';
+                    schema.items = {
+                        $ref: `#/components/schemas/${classDeclaration.name.text}`,
+                    };
+                }
+                else {
+                    schema = {
+                        $ref: `#/components/schemas/${classDeclaration.name.text}`,
+                    };
+                }
+            }
+            else {
+                schema = this.getSchemaFromClass({
+                    isArray: property.isArray,
+                    visitedClass,
+                    transformedSchema,
+                    declaration,
+                });
+            }
         }
         else {
             schema = { type: 'object', properties: {}, additionalProperties: true };
@@ -496,21 +566,26 @@ class SchemaTransformer {
         this.applyDecorators(property, schema);
         return schema;
     }
-    getSchemaFromClass({ property, transformedSchema = new Map(), visitedClass = new Set(), }) {
+    getSchemaFromClass({ transformedSchema = new Map(), visitedClass = new Set(), declaration, isArray, }) {
         let schema = { type: 'object' };
-        const declaration = this.getDeclarationProperty(property);
         if (!declaration ||
             !ts.isClassDeclaration(declaration) ||
             !declaration.name) {
             return { type: 'object' };
         }
         if (visitedClass.has(declaration)) {
-            if (transformedSchema.has(declaration.name.text)) {
-                return transformedSchema.get(declaration.name.text);
+            if (isArray) {
+                schema.type = 'array';
+                schema.items = {
+                    $ref: `#/components/schemas/${declaration.name.text}`,
+                };
             }
-            return {
-                $ref: `#/components/schemas/${declaration.name.text}`,
-            };
+            else {
+                schema = {
+                    $ref: `#/components/schemas/${declaration.name.text}`,
+                };
+            }
+            return schema;
         }
         visitedClass.add(declaration);
         const properties = this.getPropertiesByClassDeclaration(declaration);
@@ -518,8 +593,9 @@ class SchemaTransformer {
             properties,
             visitedClass,
             transformedSchema: transformedSchema,
+            classDeclaration: declaration,
         });
-        if (property.isArray) {
+        if (isArray) {
             schema.type = 'array';
             schema.items = {
                 type: transformerProps.type,
@@ -533,14 +609,12 @@ class SchemaTransformer {
             schema.required = transformerProps.required;
         }
         transformedSchema.set(declaration.name.text, schema);
-        if (schema.properties && Object.keys(schema.properties).length === 0) {
-            schema = { type: 'object', properties: {}, additionalProperties: true };
-        }
         return schema;
     }
     getSchemaFromPrimitive(property) {
         const propertySchema = { type: 'object' };
         const propertyType = property.type.toLowerCase().replace('[]', '').trim();
+        let isFile = false;
         switch (propertyType) {
             case constants.jsPrimitives.String.value:
                 propertySchema.type = constants.jsPrimitives.String.value;
@@ -557,12 +631,13 @@ class SchemaTransformer {
                 propertySchema.type = constants.jsPrimitives.Date.value;
                 propertySchema.format = constants.jsPrimitives.Date.format;
                 break;
-            case constants.jsPrimitives.Buffer.value:
-            case constants.jsPrimitives.Uint8Array.value:
-            case constants.jsPrimitives.File.value:
-            case constants.jsPrimitives.UploadFile.value:
+            case constants.jsPrimitives.Buffer.type.toLocaleLowerCase():
+            case constants.jsPrimitives.Uint8Array.type.toLocaleLowerCase():
+            case constants.jsPrimitives.File.type.toLocaleLowerCase():
+            case constants.jsPrimitives.UploadFile.type.toLocaleLowerCase():
                 propertySchema.type = constants.jsPrimitives.UploadFile.value;
                 propertySchema.format = constants.jsPrimitives.UploadFile.format;
+                isFile = true;
                 break;
             case constants.jsPrimitives.Array.value:
                 propertySchema.type = constants.jsPrimitives.Array.value;
@@ -581,7 +656,9 @@ class SchemaTransformer {
         }
         if (property.isArray) {
             propertySchema.type = `array`;
-            propertySchema.items = { type: propertyType };
+            propertySchema.items = {
+                type: isFile ? constants.jsPrimitives.UploadFile.value : propertyType,
+            };
         }
         return propertySchema;
     }
@@ -697,7 +774,10 @@ class SchemaTransformer {
             return { name: cls.name, schema: {} };
         }
         const properties = this.getPropertiesByClassDeclaration(result.node);
-        schema = this.getSchemaFromProperties({ properties });
+        schema = this.getSchemaFromProperties({
+            properties,
+            classDeclaration: result.node,
+        });
         return { name: cls.name, schema };
     }
 }