Use dataSource instead of ormconfig

erlendfh · erlendfh · commit cc8963150536 · 2022-10-18T10:32:10.000+02:00
diff --git a/sample/test/datasource.ts b/sample/test/datasource.ts
@@ -0,0 +1,11 @@
+import { join } from 'path'
+import { DataSource } from 'typeorm'
+
+const ds = new DataSource({
+  name: 'file',
+  type: 'sqlite',
+  database: ':memory:',
+  entities: ['sample/entities/**/*{.ts,.js}'],
+})
+
+export default ds
diff --git a/sample/test/sample.integration.test.ts b/sample/test/sample.integration.test.ts
@@ -4,29 +4,53 @@ import {
   tearDownDatabase,
   factory,
   setConnectionOptions,
+  ConnectionOptions,
+  configureConnection,
 } from '../../src/typeorm-seeding'
 import { User } from '../entities/User.entity'
-import { Connection } from 'typeorm'
+import { DataSource } from 'typeorm'
+import { join } from 'path'
+
+const inMemoryDb: ConnectionOptions = {
+  name: 'memory',
+  type: 'sqlite',
+  database: ':memory:',
+  entities: ['sample/entities/**/*{.ts,.js}'],
+  factories: ['sample/factories/**/*{.ts,.js}'],
+  seeds: ['sample/seeds/**/*{.ts,.js}'],
+}
 
 describe('Sample Integration Test', () => {
-  let connection: Connection
-  beforeAll(async () => {
-    setConnectionOptions({
-      type: 'sqlite',
-      database: ':memory:',
-      entities: ['sample/entities/**/*{.ts,.js}'],
-    })
-    connection = await useRefreshDatabase()
-    await useSeeding()
-  })
+  let dataSource: DataSource
 
-  afterAll(async () => {
+  afterEach(async () => {
     await tearDownDatabase()
   })
 
   test('Should create a user with the entity factory', async () => {
+    setConnectionOptions(inMemoryDb)
+    dataSource = await useRefreshDatabase()
+    await useSeeding()
+
     const createdUser = await factory(User)().create()
-    const user = await connection.getRepository(User).findOne({ where: { id: createdUser.id } })
+    const user = await dataSource.getRepository(User).findOne({ where: { id: createdUser.id } })
     expect(createdUser.firstName).toBe(user.firstName)
   })
+
+  test('Should be able to load a datasource.ts file', async () => {
+    setConnectionOptions({})
+    configureConnection({
+      dataSourcePath: join(__dirname, 'datasource.ts'),
+    })
+
+    dataSource = await useRefreshDatabase()
+    expect(dataSource.options).toEqual(
+      expect.objectContaining({
+        database: ':memory:',
+        entities: ['sample/entities/**/*{.ts,.js}'],
+        name: 'file',
+        type: 'sqlite',
+      }),
+    )
+  })
 })
diff --git a/src/commands/config.command.ts b/src/commands/config.command.ts
@@ -1,29 +1,18 @@
 import * as yargs from 'yargs'
 import * as chalk from 'chalk'
 import { printError } from '../utils/log.util'
-import { configureConnection, getConnectionOptions } from '../connection'
+import { configureConnection, loadDataSource } from '../connection'
 
 export class ConfigCommand implements yargs.CommandModule {
   command = 'config'
   describe = 'Show the TypeORM config'
 
   builder(args: yargs.Argv) {
-    return args
-      .option('n', {
-        alias: 'configName',
-        default: '',
-        describe: 'Name of the typeorm config file (json or js).',
-      })
-      .option('c', {
-        alias: 'connection',
-        default: '',
-        describe: 'Name of the typeorm connection',
-      })
-      .option('r', {
-        alias: 'root',
-        default: process.cwd(),
-        describe: 'Path to your typeorm config file',
-      })
+    return args.option('d', {
+      alias: 'dataSource',
+      demandOption: true,
+      describe: 'Path to the file where your DataSource instance is defined.',
+    })
   }
 
   async handler(args: yargs.Arguments) {
@@ -32,12 +21,10 @@ export class ConfigCommand implements yargs.CommandModule {
     log('🌱  ' + chalk.bold(`TypeORM Seeding v${(pkg as any).version}`))
     try {
       configureConnection({
-        root: args.root as string,
-        configName: args.configName as string,
-        connection: args.connection as string,
+        dataSourcePath: args.dataSource as string,
       })
-      const option = await getConnectionOptions()
-      log(option)
+      const ds = await loadDataSource()
+      log(ds.options)
     } catch (error) {
       printError('Could not find the orm config file', error)
       process.exit(1)
diff --git a/src/commands/seed.command.ts b/src/commands/seed.command.ts
@@ -4,28 +4,19 @@ import * as chalk from 'chalk'
 import { importSeed } from '../importer'
 import { loadFiles, importFiles } from '../utils/file.util'
 import { runSeeder } from '../typeorm-seeding'
-import { configureConnection, getConnectionOptions, ConnectionOptions, createConnection } from '../connection'
+import { DataSource } from 'typeorm'
+import { configureConnection, getConnectionOptions, ConnectionOptions, loadDataSource } from '../connection'
 
 export class SeedCommand implements yargs.CommandModule {
   command = 'seed'
   describe = 'Runs the seeds'
 
   builder(args: yargs.Argv) {
     return args
-      .option('n', {
-        alias: 'configName',
-        default: '',
-        describe: 'Name of the typeorm config file (json or js).',
-      })
-      .option('c', {
-        alias: 'connection',
-        default: '',
-        describe: 'Name of the typeorm connection',
-      })
-      .option('r', {
-        alias: 'root',
-        default: process.cwd(),
-        describe: 'Path to your typeorm config file',
+      .option('d', {
+        alias: 'dataSource',
+        demandOption: true,
+        describe: 'Path to the file where your DataSource instance is defined.',
       })
       .option('seed', {
         alias: 's',
@@ -39,16 +30,16 @@ export class SeedCommand implements yargs.CommandModule {
     log('🌱  ' + chalk.bold(`TypeORM Seeding v${(pkg as any).version}`))
     const spinner = ora('Loading ormconfig').start()
     const configureOption = {
-      root: args.root as string,
-      configName: args.configName as string,
-      connection: args.connection as string,
+      dataSourcePath: args.dataSource as string,
     }
 
+    let dataSource: DataSource | null = null
     // Get TypeORM config file
     let option: ConnectionOptions
     try {
       configureConnection(configureOption)
       option = await getConnectionOptions()
+      dataSource = await loadDataSource()
       spinner.succeed('ORM Config loaded')
     } catch (error) {
       panic(spinner, error, 'Could not load the config file!')
@@ -81,7 +72,7 @@ export class SeedCommand implements yargs.CommandModule {
     // Get database connection and pass it to the seeder
     spinner.start('Connecting to the database')
     try {
-      await createConnection()
+      await loadDataSource()
       spinner.succeed('Database connected')
     } catch (error) {
       panic(spinner, error, 'Database connection failed! Check your typeORM config file.')
diff --git a/src/connection.ts b/src/connection.ts
@@ -1,112 +1,73 @@
-import {
-  ConnectionOptionsReader,
-  Connection as TypeORMConnection,
-  ConnectionOptions as TypeORMConnectionOptions,
-  createConnection as TypeORMCreateConnection,
-  getConnection as TypeORMGetConnection,
-} from 'typeorm'
-import { printError } from './utils/log.util'
+import { resolve } from 'path'
+import { DataSource, DataSourceOptions } from 'typeorm'
 
 interface SeedingOptions {
   factories: string[]
   seeds: string[]
 }
 
-export declare type ConnectionOptions = TypeORMConnectionOptions & SeedingOptions
+export declare type ConnectionOptions = DataSourceOptions & SeedingOptions
 
 export interface ConfigureOption {
-  root?: string
-  configName?: string
-  connection?: string
+  dataSourcePath?: string
 }
 
 const KEY = 'TypeORM_Seeding_Connection'
 
-const defaultConfigureOption: ConfigureOption = {
-  root: process.cwd(),
-  configName: '',
-  connection: '',
-}
-
 if ((global as any)[KEY] === undefined) {
   ;(global as any)[KEY] = {
-    configureOption: defaultConfigureOption,
+    dataSource: undefined as DataSource | undefined,
+    dataSourcePath: undefined as string | undefined,
     ormConfig: undefined,
     connection: undefined,
-    overrideConnectionOptions: {},
+    overrideConnectionOptions: {
+      factories: [process.env.TYPEORM_SEEDING_FACTORIES || 'src/database/factories/**/*{.ts,.js}'],
+      seeds: [process.env.TYPEORM_SEEDING_SEEDS || 'src/database/seeds/**/*{.ts,.js}'],
+    } as ConnectionOptions,
   }
 }
 
 export const configureConnection = (option: ConfigureOption = {}) => {
-  ;(global as any)[KEY].configureOption = {
-    ...defaultConfigureOption,
+  ;(global as any)[KEY] = {
+    ...(global as any)[KEY],
     ...option,
   }
 }
 
-export const setConnectionOptions = (options: Partial<TypeORMConnectionOptions>): void => {
-  ;(global as any)[KEY].overrideConnectionOptions = options
+export const setConnectionOptions = (options: Partial<ConnectionOptions>): void => {
+  ;(global as any)[KEY].overrideConnectionOptions = {
+    ...(global as any)[KEY].overrideConnectionOptions,
+    ...options,
+  }
 }
 
 export const getConnectionOptions = async (): Promise<ConnectionOptions> => {
-  const ormConfig = (global as any)[KEY].ormConfig
-  const overrideConnectionOptions = (global as any)[KEY].overrideConnectionOptions
-  if (ormConfig === undefined) {
-    const configureOption = (global as any)[KEY].configureOption
-    const connection = configureOption.connection
-    const reader = new ConnectionOptionsReader({
-      root: configureOption.root,
-      configName: configureOption.configName,
-    })
-    let options = (await reader.all()) as any[]
-    if (connection !== undefined && connection !== '') {
-      const filteredOptions = options.filter((o) => o.name === connection)
-      if (filteredOptions.length === 1) {
-        options = filteredOptions
-      }
-    }
-    if (options.length > 1) {
-      const filteredOptions = options.filter((o) => o.name === 'default')
-      if (filteredOptions.length === 1) {
-        options = filteredOptions
-      }
-    }
-    if (options.length === 1) {
-      const option = options[0]
-      if (!option.factories) {
-        option.factories = [process.env.TYPEORM_SEEDING_FACTORIES || 'src/database/factories/**/*{.ts,.js}']
-      }
-      if (!option.seeds) {
-        option.seeds = [process.env.TYPEORM_SEEDING_SEEDS || 'src/database/seeds/**/*{.ts,.js}']
-      }
-      ;(global as any)[KEY].ormConfig = {
-        ...option,
-        ...overrideConnectionOptions,
-      }
-      return (global as any)[KEY].ormConfig
-    }
-    printError('There are multiple connections please provide a connection name')
-  }
-  return ormConfig
+  return (global as any)[KEY].overrideConnectionOptions
 }
 
-export const createConnection = async (option?: TypeORMConnectionOptions): Promise<TypeORMConnection> => {
-  const configureOption = (global as any)[KEY].configureOption
-  let connection = (global as any)[KEY].connection
-  let ormConfig = (global as any)[KEY].ormConfig
-
-  if (option !== undefined) {
-    ormConfig = option
+export const resetDataSource = async () => {
+  ;(global as any)[KEY].overrideConnectionOptions = {}
+  const ds = (global as any)[KEY].dataSource as DataSource
+  if (ds) {
+    ;(global as any)[KEY].dataSource = undefined
+    return ds && ds.isInitialized ? ds.destroy() : undefined
   }
+}
+
+export const loadDataSource = async (options?: DataSourceOptions): Promise<DataSource> => {
+  const { dataSourcePath, dataSource, overrideConnectionOptions } = (global as any)[KEY]
 
-  if (connection === undefined) {
-    try {
-      connection = await TypeORMGetConnection(configureOption.name)
-    } catch (_) {}
-    if (connection === undefined) {
-      connection = await TypeORMCreateConnection(ormConfig)
+  let ds: DataSource | undefined
+  if (!dataSource) {
+    if (dataSourcePath) {
+      ds = (await require(resolve(process.cwd(), dataSourcePath))).default as DataSource
+      ds.setOptions({ ...overrideConnectionOptions, ...options })
+    } else {
+      ds = new DataSource({ ...overrideConnectionOptions, ...options })
     }
-    ;(global as any)[KEY].connection = connection
+    await ds.initialize()
+    ;(global as any)[KEY].dataSource = ds
   }
-  return connection
+
+  return (global as any)[KEY].dataSource
 }
diff --git a/src/entity-factory.ts b/src/entity-factory.ts
@@ -3,7 +3,7 @@ import { ObjectLiteral, ObjectType, SaveOptions } from 'typeorm'
 import { FactoryFunction, EntityProperty } from './types'
 import { isPromiseLike } from './utils/factory.util'
 import { printError, printWarning } from './utils/log.util'
-import { getConnectionOptions, createConnection } from './connection'
+import { getConnectionOptions, loadDataSource } from './connection'
 
 export class EntityFactory<Entity extends ObjectLiteral, Context> {
   private mapFunction: (entity: Entity) => Promise<Entity>
@@ -39,10 +39,9 @@ export class EntityFactory<Entity extends ObjectLiteral, Context> {
    * Create makes a new entity and does persist it
    */
   public async create(overrideParams: EntityProperty<Entity> = {}, saveOptions?: SaveOptions): Promise<Entity> {
-    const option = await getConnectionOptions()
-    const connection = await createConnection(option)
-    if (connection && connection.isConnected) {
-      const em = connection.createEntityManager()
+    const dataSource = await loadDataSource()
+    if (dataSource && dataSource.isInitialized) {
+      const em = dataSource.createEntityManager()
       try {
         const entity = await this.makeEnity(overrideParams, true)
         return await em.save<Entity>(entity, saveOptions)
@@ -52,6 +51,7 @@ export class EntityFactory<Entity extends ObjectLiteral, Context> {
         throw new Error(message)
       }
     } else {
+      console.warn('No db connection is given: ', dataSource.isInitialized, dataSource)
       const message = 'No db connection is given'
       printError(message)
       throw new Error(message)
diff --git a/src/typeorm-seeding.ts b/src/typeorm-seeding.ts
diff --git a/src/types.ts b/src/types.ts
