@platformatic/db 2.74.3 → 3.0.0-alpha.2

package/lib/generator/db-generator.js

@@ -1,262 +0,0 @@
-'use strict'
-
-const { BaseGenerator, generateTests } = require('@platformatic/generators')
-const { jsHelperSqlite, jsHelperMySQL, jsHelperPostgres, moviesTestTS, moviesTestJS } = require('./code-templates')
-const { join } = require('node:path')
-const { readFile } = require('node:fs/promises')
-
-class DBGenerator extends BaseGenerator {
-  constructor (opts = {}) {
-    super({
-      ...opts,
-      module: '@platformatic/db',
-    })
-    this.connectionStrings = {
-      postgres: 'postgres://postgres:postgres@127.0.0.1:5432/postgres',
-      sqlite: 'sqlite://./db.sqlite',
-      mysql: 'mysql://root@127.0.0.1:3306/platformatic',
-      mariadb: 'mysql://root@127.0.0.1:3306/platformatic',
-    }
-  }
-
-  getDefaultConfig () {
-    const defaultBaseConfig = super.getDefaultConfig()
-    return {
-      ...defaultBaseConfig,
-      database: 'sqlite',
-      connectionString: null,
-      plugin: true,
-      tests: true,
-      types: true,
-      migrations: 'migrations',
-      createMigrations: true,
-    }
-  }
-
-  async _getConfigFileContents () {
-    const { isRuntimeContext, migrations, plugin, types } = this.config
-    const version = this.platformaticVersion
-
-    const config = {
-      $schema: `https://schemas.platformatic.dev/@platformatic/db/${version}.json`,
-      db: {
-        connectionString: `{${this.getEnvVarName('DATABASE_URL')}}`,
-        graphql: true,
-        openapi: true,
-        schemalock: true,
-      },
-      watch: {
-        ignore: ['*.sqlite', '*.sqlite-journal'],
-      },
-    }
-
-    if (!isRuntimeContext) {
-      config.server = {
-        hostname: '{PLT_SERVER_HOSTNAME}',
-        port: '{PORT}',
-        logger: {
-          level: '{PLT_SERVER_LOGGER_LEVEL}',
-        },
-      }
-    }
-
-    if (migrations) {
-      config.migrations = {
-        dir: migrations,
-        autoApply: `{${this.getEnvVarName('PLT_APPLY_MIGRATIONS')}}`,
-      }
-
-      this.addFile({ path: 'migrations', file: '.gitkeep', contents: '' })
-    }
-
-    if (plugin === true) {
-      config.plugins = {
-        paths: [{
-          path: './plugins',
-          encapsulate: false,
-        }, {
-          path: './routes',
-        }],
-        typescript: `{${this.getEnvVarName('PLT_TYPESCRIPT')}}`,
-      }
-    }
-
-    if (types === true) {
-      config.types = {
-        autogenerate: true,
-      }
-    }
-
-    return config
-  }
-
-  async _beforePrepare () {
-    if (!this.config.isUpdating) {
-      this.config.connectionString = this.config.connectionString || this.connectionStrings[this.config.database]
-      this.config.dependencies = {
-        '@platformatic/db': `^${this.platformaticVersion}`,
-      }
-
-      if (!this.config.isRuntimeContext) {
-        this.addEnvVars({
-          PLT_SERVER_HOSTNAME: this.config.hostname,
-          PLT_SERVER_LOGGER_LEVEL: 'info',
-          PORT: 3042,
-        }, { overwrite: false, default: true })
-      }
-
-      this.addEnvVars({
-        PLT_TYPESCRIPT: this.config.typescript,
-        DATABASE_URL: this.connectionStrings[this.config.database],
-        PLT_APPLY_MIGRATIONS: 'true',
-      }, { overwrite: false, default: true })
-    }
-  }
-
-  async _afterPrepare () {
-    if (!this.config.isUpdating) {
-      if (this.config.createMigrations) {
-        this.createMigrationFiles()
-      }
-
-      this.addFile({ path: '', file: 'README.md', contents: await readFile(join(__dirname, 'README.md'), 'utf-8') })
-
-      if (this.config.plugin) {
-        let jsHelper = { pre: '', config: '', post: '' }
-        switch (this.config.database) {
-          case 'sqlite':
-            jsHelper = jsHelperSqlite
-            break
-          case 'mysql':
-            jsHelper = jsHelperMySQL(this.config.connectionString)
-            break
-          case 'postgres':
-            jsHelper = jsHelperPostgres(this.config.connectionString)
-            break
-          case 'mariadb':
-            jsHelper = jsHelperMySQL(this.config.connectionString)
-            break
-        }
-
-        if (this.config.createMigrations) {
-          if (this.config.typescript) {
-            this.addFile({ path: join('test', 'routes'), file: 'movies.test.ts', contents: moviesTestTS })
-          } else {
-            this.addFile({ path: join('test', 'routes'), file: 'movies.test.js', contents: moviesTestJS })
-          }
-        }
-
-        // TODO(leorossi): this is unfortunate. We have already generated tests in BaseGenerator
-        // next line will override the test files
-        generateTests(this.config.typescript, '@platformatic/db', jsHelper).forEach((fileObject) => {
-          this.addFile(fileObject)
-        })
-
-        if (this.config.isRuntimeContext) {
-          // remove .env file and env variables since they are all for the config.server property
-          const envFile = this.getFileObject('.env')
-          if (envFile) {
-            envFile.contents = ''
-          }
-        }
-      }
-
-      const GLOBAL_TYPES_TEMPLATE = `
-import { FastifyInstance } from 'fastify'
-import { PlatformaticApp, PlatformaticDBConfig, PlatformaticDBMixin, Entities } from '@platformatic/db'
-
-declare module 'fastify' {
-  interface FastifyInstance {
-    platformatic: PlatformaticApp<PlatformaticDBConfig> & PlatformaticDBMixin<Entities>
-  }
-}
-`
-      this.addFile({ path: '', file: 'global.d.ts', contents: GLOBAL_TYPES_TEMPLATE })
-    }
-  }
-
-  createMigrationFiles () {
-    this.addFile({ path: 'migrations', file: '001.do.sql', contents: this.getMoviesMigrationDo() })
-    this.addFile({ path: 'migrations', file: '001.undo.sql', contents: this.getMoviesMigrationUndo() })
-  }
-
-  getMoviesMigrationDo () {
-    const key = {
-      postgres: 'SERIAL',
-      sqlite: 'INTEGER',
-      mysql: 'INTEGER UNSIGNED AUTO_INCREMENT',
-      mariadb: 'INTEGER UNSIGNED AUTO_INCREMENT',
-    }
-
-    return `
-  -- Add SQL in this file to create the database tables for your API
-  CREATE TABLE IF NOT EXISTS movies (
-    id ${key[this.config.database]} PRIMARY KEY,
-    title TEXT NOT NULL
-  );
-  `
-  }
-
-  getMoviesMigrationUndo () {
-    return '-- Add SQL in this file to drop the database tables\nDROP TABLE movies;'
-  }
-
-  setConfigFields (fields) {
-    super.setConfigFields(fields)
-    this.config.database = this.getDatabaseFromConnectionString()
-  }
-
-  getDatabaseFromConnectionString () {
-    if (this.config.connectionString) {
-      if (this.config.connectionString.indexOf('://') !== -1) {
-        const splitted = this.config.connectionString.split('://')
-        return splitted[0]
-      }
-      return null
-    }
-    return null
-  }
-
-  getConfigFieldsDefinitions () {
-    return [
-      {
-        var: 'DATABASE_URL',
-        label: 'What is the connection string?',
-        default: this.connectionStrings.sqlite,
-        type: 'string',
-        configValue: 'connectionString',
-      },
-      {
-        var: 'PLT_APPLY_MIGRATIONS',
-        label: 'Should migrations be applied automatically on startup?',
-        default: true,
-        type: 'boolean',
-      },
-    ]
-  }
-
-  async prepareQuestions () {
-    await super.prepareQuestions()
-    if (!this.config.connectionString) {
-      const def = this.getConfigFieldsDefinitions().find((q) => q.var === 'DATABASE_URL')
-      this.questions.push({
-        type: 'input',
-        name: def.configValue,
-        message: def.label,
-        default: def.default,
-      })
-    }
-
-    this.questions.push({
-      type: 'list',
-      name: 'createMigrations',
-      message: 'Do you want to create default migrations?',
-      default: true,
-      choices: [{ name: 'yes', value: true }, { name: 'no', value: false }],
-    })
-  }
-}
-
-module.exports = DBGenerator
-module.exports.DBGenerator = DBGenerator
-module.exports.Generator = DBGenerator

package/lib/generator.d.ts

@@ -1,7 +0,0 @@
-import { BaseGenerator } from '@platformatic/generators'
-
-type DBGeneratorOptions = BaseGenerator.BaseGeneratorOptions
-export class DBGenerator extends BaseGenerator.BaseGenerator {
-  connectionStrings: string[]
-  constructor (opts?: DBGeneratorOptions)
-}

package/lib/migrate.mjs

@@ -1,87 +0,0 @@
-#! /usr/bin/env node
-
-import { loadConfig } from '@platformatic/config'
-import { checkForDependencies } from '@platformatic/utils'
-import { utimesSync } from 'fs'
-import { createRequire } from 'node:module'
-import pino from 'pino'
-import pretty from 'pino-pretty'
-import { platformaticDB } from '../index.js'
-import errors from './errors.js'
-import { execute as generateTypes } from './gen-types.mjs'
-import { Migrator } from './migrator.mjs'
-import { updateSchemaLock } from './utils.js'
-
-async function execute ({ logger, rollback, to, config }) {
-  const migrationsConfig = config.migrations
-  if (migrationsConfig === undefined) {
-    throw new errors.MigrateMissingMigrationsError()
-  }
-  const migrator = new Migrator(migrationsConfig, config.db, logger)
-
-  try {
-    if (rollback) {
-      await migrator.rollbackMigration()
-    } else {
-      await migrator.applyMigrations(to)
-    }
-    return migrator.appliedMigrationsCount > 0
-  } finally {
-    await migrator.close()
-  }
-}
-
-async function applyMigrations (_args) {
-  const logger = pino(
-    pretty({
-      translateTime: 'SYS:HH:MM:ss',
-      ignore: 'hostname,pid'
-    })
-  )
-
-  try {
-    const { configManager, args } = await loadConfig(
-      {
-        string: ['to'],
-        boolean: ['rollback'],
-        alias: {
-          t: 'to',
-          r: 'rollback'
-        }
-      },
-      _args,
-      platformaticDB
-    )
-
-    const config = configManager.current
-    const appliedMigrations = await execute({ logger, ...args, config })
-
-    if (config.types && config.types.autogenerate) {
-      await generateTypes({ logger, config, configManager })
-      const modules = ['@platformatic/db']
-      if (config.plugins?.typescript) {
-        modules.push('typescript')
-      }
-      await checkForDependencies(logger, args, createRequire(import.meta.url), config, modules)
-    }
-
-    if (appliedMigrations) {
-      await updateSchemaLock(logger, configManager)
-    }
-
-    // touch the platformatic db config to trigger a restart
-    const now = new Date()
-
-    const configPath = configManager.fullPath
-    utimesSync(configPath, now, now)
-  } catch (err) {
-    if (err.code === 'PTL_DB_MIGRATE_ERROR') {
-      logger.error(err.message)
-      process.exit(1)
-    }
-    /* c8 ignore next 2 */
-    throw err
-  }
-}
-
-export { applyMigrations, execute }

package/lib/seed.mjs

@@ -1,90 +0,0 @@
-import pino from 'pino'
-import pretty from 'pino-pretty'
-import { access, readFile } from 'fs/promises'
-import { setupDB } from './utils.js'
-import { Migrator } from './migrator.mjs'
-import { pathToFileURL } from 'url'
-import { loadConfig } from '@platformatic/config'
-import { platformaticDB } from '../index.js'
-import errors from './errors.js'
-import tsCompiler from '@platformatic/ts-compiler'
-import { join, resolve } from 'node:path'
-
-async function execute (logger, seedFile, config) {
-  const { db, sql, entities } = await setupDB(logger, config.db)
-
-  await access(seedFile)
-
-  logger.info(`seeding from ${seedFile}`)
-  let seedFunction
-  const importedFunction = await import(pathToFileURL(seedFile))
-
-  if (typeof importedFunction === 'function') {
-    seedFunction = importedFunction
-  } else if (typeof importedFunction.seed === 'function') {
-    seedFunction = importedFunction.seed
-  } else if (typeof importedFunction.default === 'function') {
-    seedFunction = importedFunction.default
-  }
-
-  if (!seedFunction) {
-    logger.error('Cannot find seed function.')
-    logger.error('If you use an ESM module use the signature \'export async function seed (opts)\'.')
-    logger.error('If you use a CJS module use the signature \'module.exports = async function seed (opts)\'.')
-    logger.error('If you use Typescript use the signature \'export async function seed(opts)\'')
-    return
-  }
-  await seedFunction({ db, sql, entities, logger })
-  logger.info('seeding complete')
-
-  // Once done seeding, close your connection.
-  await db.dispose()
-}
-
-async function seed (_args) {
-  const logger = pino(pretty({
-    translateTime: 'SYS:HH:MM:ss',
-    ignore: 'hostname,pid',
-  }))
-
-  const { configManager, args } = await loadConfig({
-    alias: {
-      c: 'config',
-    },
-  }, _args, platformaticDB)
-  await configManager.parseAndValidate()
-  const config = configManager.current
-
-  if (config.migrations !== undefined) {
-    const migrator = new Migrator(config.migrations, config.db, logger)
-
-    try {
-      const hasMigrationsToApply = await migrator.hasMigrationsToApply()
-      if (hasMigrationsToApply) {
-        throw new errors.MigrationsToApplyError()
-      }
-    } finally {
-      await migrator.close()
-    }
-  }
-  let seedFile = args._[0]
-  if (!seedFile) {
-    throw new errors.MissingSeedFileError()
-  }
-  // check if we are in Typescript and, in case, compile it
-  if (seedFile.endsWith('.ts')) {
-    await tsCompiler.compile({
-      cwd: process.cwd(),
-      logger,
-      tsConfig: configManager.current.plugins?.typescript?.tsConfig,
-      flags: configManager.current.plugins?.typescript?.flags,
-    })
-    const tsConfigPath = config?.plugins?.typescript?.tsConfig || resolve(process.cwd(), 'tsconfig.json')
-    const tsConfig = JSON.parse(await readFile(tsConfigPath, 'utf8'))
-    const outDir = tsConfig.compilerOptions.outDir
-    seedFile = join(outDir, seedFile.replace('.ts', '.js'))
-  }
-  await execute(logger, seedFile, config)
-}
-
-export { seed, execute }