Fix code formatting with Prettier

omar-dulaimi · omar-dulaimi · commit b6c184ee3f4a · 2025-07-21T18:47:06.000+03:00
diff --git a/src/generate-class.ts b/src/generate-class.ts
@@ -56,8 +56,13 @@ function generateSingleClass(
   generateClassValidatorImport(sourceFile, validatorImports as Array<string>);
 
   // Add Swagger imports if enabled
-  if (config.swagger && shouldImportSwagger(model.fields as PrismaDMMF.Field[])) {
-    const swaggerImports = getSwaggerImportsByType(model.fields as PrismaDMMF.Field[]);
+  if (
+    config.swagger &&
+    shouldImportSwagger(model.fields as PrismaDMMF.Field[])
+  ) {
+    const swaggerImports = getSwaggerImportsByType(
+      model.fields as PrismaDMMF.Field[],
+    );
     generateSwaggerImport(sourceFile, swaggerImports);
   }
   const relationImports = new Set();
@@ -105,15 +110,15 @@ function generateSeparateRelationClasses(
   // Separate base fields from relation fields
   const baseFields = model.fields.filter((field) => !field.relationName);
   const relationFields = model.fields.filter((field) => field.relationName);
-  
+
   // Generate base class (without relations)
   generateBaseClass(project, config, model, baseFields);
-  
+
   // Generate relation class (only relations)
   if (relationFields.length > 0) {
     generateRelationClass(project, config, model, relationFields);
   }
-  
+
   // Generate combined class that extends base and includes relations
   generateCombinedClass(project, config, model, baseFields, relationFields);
 }
@@ -146,7 +151,9 @@ function generateBaseClass(
 
   // Add Swagger imports if enabled
   if (config.swagger && shouldImportSwagger(fields as PrismaDMMF.Field[])) {
-    const swaggerImports = getSwaggerImportsByType(fields as PrismaDMMF.Field[]);
+    const swaggerImports = getSwaggerImportsByType(
+      fields as PrismaDMMF.Field[],
+    );
     generateSwaggerImport(sourceFile, swaggerImports);
   }
 
@@ -160,18 +167,16 @@ function generateBaseClass(
     name: `${model.name}Base`,
     isExported: true,
     properties: [
-      ...fields.map<OptionalKind<PropertyDeclarationStructure>>(
-        (field) => {
-          return {
-            name: field.name,
-            type: getTSDataTypeFromFieldType(field),
-            hasExclamationToken: field.isRequired,
-            hasQuestionToken: !field.isRequired,
-            trailingTrivia: '\r\n',
-            decorators: getDecoratorsByFieldType(field, config.swagger),
-          };
-        },
-      ),
+      ...fields.map<OptionalKind<PropertyDeclarationStructure>>((field) => {
+        return {
+          name: field.name,
+          type: getTSDataTypeFromFieldType(field),
+          hasExclamationToken: field.isRequired,
+          hasQuestionToken: !field.isRequired,
+          trailingTrivia: '\r\n',
+          decorators: getDecoratorsByFieldType(field, config.swagger),
+        };
+      }),
     ],
   });
 }
@@ -199,8 +204,13 @@ function generateRelationClass(
   generateClassValidatorImport(sourceFile, validatorImports as Array<string>);
 
   // Add Swagger imports if enabled
-  if (config.swagger && shouldImportSwagger(relationFields as PrismaDMMF.Field[])) {
-    const swaggerImports = getSwaggerImportsByType(relationFields as PrismaDMMF.Field[]);
+  if (
+    config.swagger &&
+    shouldImportSwagger(relationFields as PrismaDMMF.Field[])
+  ) {
+    const swaggerImports = getSwaggerImportsByType(
+      relationFields as PrismaDMMF.Field[],
+    );
     generateSwaggerImport(sourceFile, swaggerImports);
   }
 
diff --git a/src/helpers.ts b/src/helpers.ts
@@ -68,26 +68,29 @@ export const getTSDataTypeFromFieldType = (field: PrismaDMMF.Field) => {
   if (field.isList) {
     type = `${type}[]`;
   }
-  
+
   // Add null union for optional fields to match Prisma client behavior
   if (!field.isRequired) {
     type = `${type} | null`;
   }
-  
+
   return type;
 };
 
-export const getDecoratorsByFieldType = (field: PrismaDMMF.Field, includeSwagger: boolean = false) => {
+export const getDecoratorsByFieldType = (
+  field: PrismaDMMF.Field,
+  includeSwagger: boolean = false,
+) => {
   const decorators: OptionalKind<DecoratorStructure>[] = [];
-  
+
   // Add Swagger decorators first if enabled
   if (includeSwagger) {
     const swaggerDecorator = getSwaggerDecoratorByFieldType(field);
     if (swaggerDecorator) {
       decorators.push(swaggerDecorator);
     }
   }
-  
+
   // Add class-validator decorators
   switch (field.type) {
     case 'Int':
@@ -143,7 +146,7 @@ export const getDecoratorsByFieldType = (field: PrismaDMMF.Field, includeSwagger
 
 export const getSwaggerDecoratorByFieldType = (field: PrismaDMMF.Field) => {
   const args: string[] = [];
-  
+
   // Base properties
   if (field.hasDefaultValue && field.default !== null) {
     if (typeof field.default === 'object' && 'name' in field.default) {
@@ -153,7 +156,7 @@ export const getSwaggerDecoratorByFieldType = (field: PrismaDMMF.Field) => {
       args.push(`example: ${JSON.stringify(field.default)}`);
     }
   }
-  
+
   // Type-specific properties
   switch (field.type) {
     case 'Int':
@@ -181,22 +184,22 @@ export const getSwaggerDecoratorByFieldType = (field: PrismaDMMF.Field) => {
       args.push('type: "string"', 'format: "byte"');
       break;
   }
-  
+
   // Array handling
   if (field.isList) {
     args.push('isArray: true');
   }
-  
+
   // Required/optional
   if (!field.isRequired) {
     args.push('required: false');
   }
-  
+
   // Enum handling
   if (field.kind === 'enum') {
     args.push(`enum: Object.values(${field.type})`);
   }
-  
+
   return {
     name: 'ApiProperty',
     arguments: args.length > 0 ? [`{ ${args.join(', ')} }`] : [],
diff --git a/src/prisma-generator.ts b/src/prisma-generator.ts
@@ -17,11 +17,12 @@ export interface GeneratorConfig {
 
 export async function generate(options: GeneratorOptions) {
   const outputDir = parseEnvValue(options.generator.output as EnvValue);
-  
+
   const config: GeneratorConfig = {
     outputDir,
     swagger: options.generator.config?.swagger === 'true',
-    separateRelationFields: options.generator.config?.separateRelationFields === 'true',
+    separateRelationFields:
+      options.generator.config?.separateRelationFields === 'true',
   };
   await fs.mkdir(outputDir, { recursive: true });
   await removeDir(outputDir, true);
diff --git a/tests/relation-splitting.test.ts b/tests/relation-splitting.test.ts
@@ -10,7 +10,7 @@ describe('Relation Splitting Generation', () => {
   beforeAll(async () => {
     // Build the generator first
     await execAsync('npm run build');
-    
+
     // Generate models for full-features schema
     const schemaPath = path.resolve(__dirname, 'schemas/full-features.prisma');
     await execAsync(`npx prisma generate --schema="${schemaPath}"`);
@@ -19,50 +19,66 @@ describe('Relation Splitting Generation', () => {
   it('should generate separate base and relation classes', () => {
     const outputPath = path.resolve(__dirname, 'generated/full-features');
     const modelsDir = path.join(outputPath, 'models');
-    
+
     // Check that all expected files are generated
-    expect(() => readFileSync(path.join(modelsDir, 'UserBase.model.ts'))).not.toThrow();
-    expect(() => readFileSync(path.join(modelsDir, 'UserRelations.model.ts'))).not.toThrow();
-    expect(() => readFileSync(path.join(modelsDir, 'User.model.ts'))).not.toThrow();
-    
-    expect(() => readFileSync(path.join(modelsDir, 'PostBase.model.ts'))).not.toThrow();
-    expect(() => readFileSync(path.join(modelsDir, 'PostRelations.model.ts'))).not.toThrow();
-    expect(() => readFileSync(path.join(modelsDir, 'Post.model.ts'))).not.toThrow();
+    expect(() =>
+      readFileSync(path.join(modelsDir, 'UserBase.model.ts')),
+    ).not.toThrow();
+    expect(() =>
+      readFileSync(path.join(modelsDir, 'UserRelations.model.ts')),
+    ).not.toThrow();
+    expect(() =>
+      readFileSync(path.join(modelsDir, 'User.model.ts')),
+    ).not.toThrow();
+
+    expect(() =>
+      readFileSync(path.join(modelsDir, 'PostBase.model.ts')),
+    ).not.toThrow();
+    expect(() =>
+      readFileSync(path.join(modelsDir, 'PostRelations.model.ts')),
+    ).not.toThrow();
+    expect(() =>
+      readFileSync(path.join(modelsDir, 'Post.model.ts')),
+    ).not.toThrow();
   });
 
   it('should generate UserBase with only non-relation fields', () => {
     const outputPath = path.resolve(__dirname, 'generated/full-features');
     const userBasePath = path.join(outputPath, 'models', 'UserBase.model.ts');
     const userBase = readFileSync(userBasePath, 'utf-8');
-    
+
     // Should contain scalar fields
     expect(userBase).toContain('id!: number');
     expect(userBase).toContain('email!: string');
     expect(userBase).toContain('name?: string | null');
-    
+
     // Should NOT contain relation fields
     expect(userBase).not.toContain('posts');
-    
+
     // Should have both class-validator and Swagger decorators
     expect(userBase).toContain('@IsInt()');
     expect(userBase).toContain('@ApiProperty({');
   });
 
   it('should generate UserRelations with only relation fields', () => {
     const outputPath = path.resolve(__dirname, 'generated/full-features');
-    const userRelationsPath = path.join(outputPath, 'models', 'UserRelations.model.ts');
+    const userRelationsPath = path.join(
+      outputPath,
+      'models',
+      'UserRelations.model.ts',
+    );
     const userRelations = readFileSync(userRelationsPath, 'utf-8');
-    
+
     // Should contain relation fields
     expect(userRelations).toContain('posts!: Post[]');
-    
+
     // Should NOT contain scalar fields
     expect(userRelations).not.toContain('id!: number');
     expect(userRelations).not.toContain('email!: string');
-    
+
     // Should import related models
     expect(userRelations).toContain('import { Post } from "./"');
-    
+
     // Should have decorators for relations
     expect(userRelations).toContain('@ApiProperty({ isArray: true })');
   });
@@ -71,16 +87,16 @@ describe('Relation Splitting Generation', () => {
     const outputPath = path.resolve(__dirname, 'generated/full-features');
     const userPath = path.join(outputPath, 'models', 'User.model.ts');
     const user = readFileSync(userPath, 'utf-8');
-    
+
     // Should extend base class
     expect(user).toContain('extends UserBase');
-    
+
     // Should import base class
     expect(user).toContain('import { UserBase } from "./UserBase.model"');
-    
+
     // Should import relation types
     expect(user).toContain('import { Post } from "./"');
-    
+
     // Should include relation properties
     expect(user).toContain('posts!: Post[]');
   });
@@ -89,13 +105,13 @@ describe('Relation Splitting Generation', () => {
     const outputPath = path.resolve(__dirname, 'generated/full-features');
     const postBasePath = path.join(outputPath, 'models', 'PostBase.model.ts');
     const postBase = readFileSync(postBasePath, 'utf-8');
-    
+
     // Should contain all scalar fields including foreign key
     expect(postBase).toContain('id!: number');
     expect(postBase).toContain('title!: string');
     expect(postBase).toContain('authorId?: number | null');
     expect(postBase).toContain('rating!: number');
-    
+
     // Should NOT contain relation fields (but should contain foreign key)
     expect(postBase).not.toContain('author?: User');
     expect(postBase).not.toContain('import { User } from "./"');
@@ -106,8 +122,8 @@ describe('Relation Splitting Generation', () => {
     const outputPath = path.resolve(__dirname, 'generated/full-features');
     const userPath = path.join(outputPath, 'models', 'User.model.ts');
     const user = readFileSync(userPath, 'utf-8');
-    
+
     // Should be valid TypeScript
     expect(user).toContain('export class User extends UserBase');
   });
-});
+});
diff --git a/tests/swagger-generation.test.ts b/tests/swagger-generation.test.ts
@@ -10,7 +10,7 @@ describe('Swagger Generation', () => {
   beforeAll(async () => {
     // Build the generator first
     await execAsync('npm run build');
-    
+
     // Generate models for swagger schema
     const schemaPath = path.resolve(__dirname, 'schemas/swagger.prisma');
     await execAsync(`npx prisma generate --schema="${schemaPath}"`);
@@ -20,10 +20,12 @@ describe('Swagger Generation', () => {
     const outputPath = path.resolve(__dirname, 'generated/swagger');
     const userModelPath = path.join(outputPath, 'models', 'User.model.ts');
     const userModel = readFileSync(userModelPath, 'utf-8');
-    
+
     // Check for Swagger imports
-    expect(userModel).toContain('import { ApiProperty } from "@nestjs/swagger"');
-    
+    expect(userModel).toContain(
+      'import { ApiProperty } from "@nestjs/swagger"',
+    );
+
     // Check for ApiProperty decorators
     expect(userModel).toContain('@ApiProperty({');
     expect(userModel).toContain('type: "integer"');
@@ -36,17 +38,17 @@ describe('Swagger Generation', () => {
     const outputPath = path.resolve(__dirname, 'generated/swagger');
     const postModelPath = path.join(outputPath, 'models', 'Post.model.ts');
     const postModel = readFileSync(postModelPath, 'utf-8');
-    
+
     // Check for DateTime format
     expect(postModel).toContain('format: "date-time"');
-    
+
     // Check for boolean type
     expect(postModel).toContain('type: "boolean"');
-    
+
     // Check for Float handling
     expect(postModel).toContain('type: "number"');
     expect(postModel).toContain('@IsNumber()');
-    
+
     // Check for default value examples
     expect(postModel).toContain('example: false');
     expect(postModel).toContain('example: 0');
@@ -56,14 +58,14 @@ describe('Swagger Generation', () => {
     const outputPath = path.resolve(__dirname, 'generated/swagger');
     const userModelPath = path.join(outputPath, 'models', 'User.model.ts');
     const userModel = readFileSync(userModelPath, 'utf-8');
-    
+
     // Check for class-validator decorators
     expect(userModel).toContain('@IsInt()');
     expect(userModel).toContain('@IsString()');
     expect(userModel).toContain('@IsDefined()');
     expect(userModel).toContain('@IsOptional()');
-    
+
     // Check for Swagger decorators
     expect(userModel).toContain('@ApiProperty({');
   });
-});
+});
