fix: Duplicate import

closes: #18

Author: unlight

src/generate.spec.ts

@@ -330,17 +330,18 @@ describe('model with one id int', () => {
     });
 });
 
-it('duplicated fields in exising file', async () => {
-    await testGenerate({
-        schema: `
-            model User {
-              id Int @id
-            }
-        `,
-        createSouceFile: {
-            type: 'input',
-            name: 'UserCreateInput',
-            text: `
+describe('duplicated', () => {
+    it('duplicated fields in exising file', async () => {
+        await testGenerate({
+            schema: `
+                model User {
+                    id Int @id
+                }
+            `,
+            createSouceFile: {
+                type: 'input',
+                name: 'UserCreateInput',
+                text: `
             import { Int } from '@nestjs/graphql';
             @InputType()
             export class UserCreateInput {
@@ -349,14 +350,41 @@ it('duplicated fields in exising file', async () => {
                 })
                 id?: string;
             `,
-        },
+            },
+        });
+        setSourceFile('/user-create.input.ts');
+        const classFile = sourceFile.getClass(() => true)!;
+        const names = classFile.getProperties().map(p => p.getName());
+        expect(names).toStrictEqual(['id']);
+    });
+
+    it('duplicated import decorators', async () => {
+        await testGenerate({
+            schema: `
+                model User {
+                    id Int @id
+                    xl Int
+                    xs Int
+                }
+            `,
+            createSouceFile: {
+                type: 'model',
+                name: 'User',
+                text: `
+            import { Field, ObjectType } from '@nestjs/graphql';
+            import { Int, ID } from '@nestjs/graphql';
+            @ObjectType()
+            export class User {
+                @Field(() => ID) id: number;
+                @Field(() => Int) xl: number;
+                @Field(() => Int) xs: number;
+            `,
+            },
+        });
+        setSourceFile('user.model.ts');
+        expect(imports.filter(x => x.name === 'Field')).toHaveLength(1);
+        expect(imports.filter(x => x.name === 'ObjectType')).toHaveLength(1);
     });
-    sourceFile = project.getSourceFile(s =>
-        s.getFilePath().endsWith('/user-create.input.ts'),
-    )!;
-    const classFile = sourceFile.getClass(() => true)!;
-    const names = classFile.getProperties().map(p => p.getName());
-    expect(names).toStrictEqual(['id']);
 });
 
 describe('one model with scalar types', () => {

src/handlers/model-output-type.ts

@@ -1,9 +1,13 @@
 import assert from 'assert';
 import JSON5 from 'json5';
+import { remove } from 'lodash';
 import {
     ClassDeclarationStructure,
     CommentStatement,
     ExportSpecifierStructure,
+    ImportDeclarationStructure,
+    ImportSpecifierStructure,
+    OptionalKind,
     StatementStructures,
     StructureKind,
 } from 'ts-morph';
@@ -32,7 +36,21 @@ export function modelOutputType(outputType: OutputType, args: EventArguments) {
         type: 'model',
     });
     const sourceFileStructure = sourceFile.getStructure();
-    const importDeclarations = new ImportDeclarationMap();
+    const imports = remove(
+        sourceFileStructure.statements as StatementStructures[],
+        s => s.kind === StructureKind.ImportDeclaration,
+    ).flatMap(s => {
+        return ((s as ImportDeclarationStructure)
+            .namedImports as OptionalKind<ImportSpecifierStructure>[]).map(x => [
+            x.name || x.alias,
+            {
+                moduleSpecifier: (s as ImportDeclarationStructure).moduleSpecifier,
+                namedImports: [{ name: x.name, alias: x.alias }],
+            },
+        ]);
+    }) as Array<[string, OptionalKind<ImportDeclarationStructure>]>;
+    const importDeclarations = new ImportDeclarationMap(imports);
+
     let classStructure = (sourceFileStructure.statements as StatementStructures[]).find(
         (s: StatementStructures) => s.kind === StructureKind.Class,
     ) as ClassDeclarationStructure | undefined;

src/helpers/import-declaration-map.ts

@@ -4,10 +4,10 @@ export class ImportDeclarationMap extends Map<
     string,
     OptionalKind<ImportDeclarationStructure>
 > {
-    add(name: string, moduleSpecifier: string);
-    add(name: string, value: OptionalKind<ImportDeclarationStructure>);
+    add(name: string, moduleSpecifier: string): void;
+    add(name: string, value: OptionalKind<ImportDeclarationStructure>): void;
 
-    add(name: string, value: OptionalKind<ImportDeclarationStructure> | string) {
+    add(name: string, value: OptionalKind<ImportDeclarationStructure> | string): void {
         if (!this.has(name)) {
             const structure: OptionalKind<ImportDeclarationStructure> =
                 typeof value === 'string'