Entità TypeORM in NESTJS - Impossibile utilizzare l'istruzione import all'esterno di un modulo

Avviato un nuovo progetto con il comando 'annida nuovo'. Funziona bene fino a quando non aggiungo il file entità ad esso.

Si è verificato il seguente errore:

import {Entity, Column, PrimaryGeneratedColumn} da 'typeorm';

^^^^^^

SyntaxError: impossibile utilizzare l'istruzione import all'esterno di un modulo

Cosa mi manca

Aggiunta di entità al modulo:

import { Module } from '@nestjs/common';
import { BooksController } from './books.controller';
import { BooksService } from './books.service';
import { BookEntity } from './book.entity';
import { TypeOrmModule } from '@nestjs/typeorm';

@Module({
  imports: [TypeOrmModule.forFeature([BookEntity])],
  controllers: [BooksController],
  providers: [BooksService],
})
export class BooksModule {}

app.module.ts:

import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { TypeOrmModule } from '@nestjs/typeorm';
import { Connection } from 'typeorm';
import { BooksModule } from './books/books.module';

@Module({
  imports: [TypeOrmModule.forRoot()],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {}

La mia ipotesi è che tu abbia una TypeormModuleconfigurazione con una entitiesproprietà simile a questa:

entities: ['src/**/*.entity.{ts,js}']

o come

entities: ['../**/*.entity.{ts,js}']

L'errore che stai ricevendo è perché stai tentando di importare un tsfile in un jscontesto. Fino a quando non si utilizza il webpack, è possibile utilizzare questo in modo da ottenere i file corretti

entities: [join(__dirname, '**', '*.entity.{ts,js}`)]

dove joinviene importato dal pathmodulo. Ora __dirnamerisolverà in srco diste poi troverà il previsto tso il jsfile rispettivamente. fammi sapere se c'è ancora un problema in corso.

MODIFICA 1/10/2020

Quanto sopra presuppone che la configurazione sia un file compatibile con JavaScript ( .jso nei TypeormModule.forRoot()parametri passati). Se si utilizza ormconfig.jsoninvece un , è necessario utilizzare

entities: ['dist/**/*.entity.js']

in modo che tu stia usando i file js compilati e non hai alcuna possibilità di usare i file ts nel tuo codice.

Come ha spiegato Jay McDoniel nella sua risposta, il problema sembra essere il pattern matching dei file entità nel ormconfig.jsonfile: probabilmente un file dattiloscritto (modulo) viene importato da un file javascript (presumibilmente un file dattiloscritto precedentemente traspilato).

Dovrebbe essere sufficiente rimuovere un tsmodello glob esistente in ormconfig.json, in modo che TypeORM carichi solo file javascript. Il percorso dei file di entità deve essere relativo alla directory di lavoro in cui viene eseguito il nodo.

   "entities"   : [
      "dist/entity/**/*.js"
   ],
   "migrations" : [
      "dist/migration/**/*.js"
   ],
   "subscribers": [
      "dist/subscriber/**/*.js"
   ],

Nella documentazione di TypeORM, ho trovato una sezione specifica per Typescript .

Questa sezione dice:

Installa ts-node a livello globale:

npm install -g ts-node

Aggiungi il comando typeorm nella sezione script in package.json

"scripts" {
    ...
    "typeorm": "ts-node -r tsconfig-paths/register ./node_modules/typeorm/cli.js"    
}

Quindi puoi eseguire il comando in questo modo:

npm run typeorm migration:run

Se devi passare il parametro con trattino allo script npm, dovrai aggiungerli dopo -. Ad esempio, se è necessario generare, il comando è così:

npm run typeorm migration:generate -- -n migrationNameHere

Questo funziona con il mio file config:

{
    "type": "postgres",
    "host": "yourhost",
    "port": 5423,
    "username": "username",
    "password": "password",
    "database": "your_db",
    "synchronize": true,
    "entities": [
        "src/modules/**/*.entity.{ts,js}"
    ],
    "migrations": [
        "src/migrations/**/*.{ts,js}"
    ],
    "cli": {
        "entitiesDir": "src/modules",
        "migrationsDir": "src/migrations"
    }
}

Quindi è possibile eseguire il comando generate.

Devi avere qualcosa.module.ts per ogni sezione della tua app. Funziona come angolare. Questo è configurato con resolver e servizi GraphQL. REST è un po 'diverso con un controller. Ogni modulo avrà probabilmente un'entità e se GraphQL, projects.schema.graphql.

projects.module.ts

import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { ProjectsService } from './projects.service';
import { Projects } from './projects.entity';

import { ProjectsResolvers } from './projects.resolvers';

@Module({
  imports: [
    TypeOrmModule.forFeature([Projects])],
  providers: [
    ProjectsService,
    ProjectsResolvers
  ],

})

export class ProjectsModule {}