6150350773

Committed 11 Sep 2023 06:31PM UTC coverage: 100.0%. Remained the same

Build # 6150350773

Build Type

push

github

Committed by

jorgebodega

Commit Message

chore: update all non-major dependencies

Run Details

14 of 14 branches covered (100.0%)

Branch coverage included in aggregate %.

107 of 107 relevant lines covered (100.0%)

4.76 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

100.0

/src/commands/seed.command.ts

import { resolve } from 'node:path'
import { Command } from 'commander'
import ora from 'ora'
import type { DataSource } from 'typeorm'
import { SeederImportationError } from '../errors'
import { DataSourceImportationError } from '../errors/DataSourceImportationError'
import { SeederExecutionError } from '../errors/SeederExecutionError'
import { useDataSource, useSeeders } from '../helpers'
import type { Seeder } from '../seeder'
import type { Constructable, SeedCommandArguments } from '../types'
import { calculateFilePath, CommandUtils } from '../utils'

async function run(paths: string[]) {
  const opts = seedCommand.opts<SeedCommandArguments>()
  const spinner = ora({ isSilent: process.env['NODE_ENV'] === 'test' }).start()

  spinner.start('Loading datasource')
  let dataSource!: DataSource
  try {
    const dataSourcePath = resolve(process.cwd(), opts.dataSource)

    dataSource = await CommandUtils.loadDataSource(dataSourcePath)

    spinner.succeed('Datasource loaded')
  } catch (error: any) {
    spinner.fail('Could not load the data source!')
    throw new DataSourceImportationError('Could not load the data source!', { cause: error })
  }

  spinner.start('Importing seeders')
  let seeders!: Constructable<Seeder>[]
  try {
    const seederFiles = paths.flatMap(calculateFilePath)

    seeders = await CommandUtils.loadSeeders(seederFiles)

    spinner.succeed('Seeder imported')
  } catch (error: any) {
    spinner.fail('Could not load seeders!')
    throw new SeederImportationError('Could not load default seeders!', { cause: error })
  }

  spinner.info(`Executing seeders...`)
  try {
    await useDataSource(dataSource, true)

    for (const seeder of seeders) {
      spinner.start(`Executing ${seeder.name}`)
      await useSeeders(seeder)
      spinner.succeed(`Seeder ${seeder.name} executed`)
    }
  } catch (error: any) {
    spinner.fail('Could not execute seeder!')
    await dataSource.destroy()
    throw new SeederExecutionError('Could not execute seeder!', { cause: error })
  }

  spinner.succeed('Finished seeding')
  await dataSource.destroy()
}

const seedCommand = new Command('seed')
  .description('Run the seeders specified by the path. Glob pattern is allowed.')
  .requiredOption(
    '-d, --dataSource <dataSourcePath>',
    'Path to the file where your DataSource instance is defined.',
    './datasource.ts',
  )
  .argument('<path...>', 'Paths to the seeders. Glob pattern is allowed.')
  .action(run)

export async function bootstrap(argv: string[]) {
  await seedCommand.parseAsync(argv)
}

1	import { resolve } from 'node:path'	1✔
2	import { Command } from 'commander'	1✔
3	import ora from 'ora'	1✔
4	import type { DataSource } from 'typeorm'
5	import { SeederImportationError } from '../errors'	1✔
6	import { DataSourceImportationError } from '../errors/DataSourceImportationError'	1✔
7	import { SeederExecutionError } from '../errors/SeederExecutionError'	1✔
8	import { useDataSource, useSeeders } from '../helpers'	1✔
9	import type { Seeder } from '../seeder'
10	import type { Constructable, SeedCommandArguments } from '../types'
11	import { calculateFilePath, CommandUtils } from '../utils'	1✔
12
13	async function run(paths: string[]) {
14	const opts = seedCommand.opts<SeedCommandArguments>()	5✔
15	const spinner = ora({ isSilent: process.env['NODE_ENV'] === 'test' }).start()	5✔
16
17	spinner.start('Loading datasource')	5✔
18	let dataSource!: DataSource
19	try {	5✔
20	const dataSourcePath = resolve(process.cwd(), opts.dataSource)	5✔
21
22	dataSource = await CommandUtils.loadDataSource(dataSourcePath)	5✔
23
24	spinner.succeed('Datasource loaded')	4✔
25	} catch (error: any) {
26	spinner.fail('Could not load the data source!')	1✔
27	throw new DataSourceImportationError('Could not load the data source!', { cause: error })	1✔
28	}
29
30	spinner.start('Importing seeders')	4✔
31	let seeders!: Constructable<Seeder>[]
32	try {	4✔
33	const seederFiles = paths.flatMap(calculateFilePath)	4✔
34
35	seeders = await CommandUtils.loadSeeders(seederFiles)	4✔
36
37	spinner.succeed('Seeder imported')	3✔
38	} catch (error: any) {
39	spinner.fail('Could not load seeders!')	1✔
40	throw new SeederImportationError('Could not load default seeders!', { cause: error })	1✔
41	}
42
43	spinner.info(`Executing seeders...`)	3✔
44	try {	3✔
45	await useDataSource(dataSource, true)	3✔
46
47	for (const seeder of seeders) {	3✔
48	spinner.start(`Executing ${seeder.name}`)	4✔
49	await useSeeders(seeder)	4✔
50	spinner.succeed(`Seeder ${seeder.name} executed`)	3✔
51	}
52	} catch (error: any) {
53	spinner.fail('Could not execute seeder!')	1✔
54	await dataSource.destroy()	1✔
55	throw new SeederExecutionError('Could not execute seeder!', { cause: error })	1✔
56	}
57
58	spinner.succeed('Finished seeding')	2✔
59	await dataSource.destroy()	2✔
60	}
61
62	const seedCommand = new Command('seed')	1✔
63	.description('Run the seeders specified by the path. Glob pattern is allowed.')
64	.requiredOption(
65	'-d, --dataSource <dataSourcePath>',
66	'Path to the file where your DataSource instance is defined.',
67	'./datasource.ts',
68	)
69	.argument('<path...>', 'Paths to the seeders. Glob pattern is allowed.')
70	.action(run)
71
72	export async function bootstrap(argv: string[]) {	1✔
73	await seedCommand.parseAsync(argv)	5✔
74	}

jorgebodega / typeorm-seeding / 6150350773

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous