@platformatic/db 3.4.1 → 3.5.1

package/lib/commands/seed.js

@@ -0,0 +1,74 @@
+import { kMetadata, loadConfiguration, loadModule } from '@platformatic/foundation'
+import { access } from 'fs/promises'
+import { createRequire } from 'node:module'
+import { resolve } from 'node:path'
+import { transform } from '../config.js'
+import { MissingSeedFileError } from '../errors.js'
+import { Migrator } from '../migrator.js'
+import { schema } from '../schema.js'
+import { setupDB } from '../utils.js'
+
+export async function seed (logger, configFile, args, { colorette: { bold }, logFatalError }) {
+  const config = await loadConfiguration(configFile, schema, { transform })
+
+  if (config.migrations !== undefined) {
+    const migrator = new Migrator(config.migrations, config.db, logger)
+
+    try {
+      const hasMigrationsToApply = await migrator.hasMigrationsToApply()
+      if (hasMigrationsToApply) {
+        logFatalError(logger, 'You must apply migrations before seeding the database.')
+        return
+      }
+    } finally {
+      await migrator.close()
+    }
+  }
+
+  if (!args.length) {
+    throw new MissingSeedFileError()
+  }
+
+  const root = config[kMetadata].root
+  const seedFile = resolve(root, args[0])
+  await access(seedFile)
+
+  logger.info(`Seeding from ${bold(seedFile)}`)
+
+  const importedModule = await loadModule(createRequire(resolve(root, 'noop.js')), seedFile)
+
+  const seedFunction = typeof importedModule?.seed !== 'function' ? importedModule : importedModule.seed
+
+  if (typeof seedFunction !== 'function') {
+    logFatalError(logger, 'Cannot find seed function.')
+    logFatalError(logger, "If you use an ESM module use the signature 'export async function seed (opts)'.")
+    logFatalError(logger, "If you use a CJS module use the signature 'module.exports = async function seed (opts)'.")
+    logFatalError(logger, "If you use Typescript use the signature 'export async function seed(opts)'")
+    return
+  }
+
+  const { db, sql, entities } = await setupDB(logger, config.db)
+  await seedFunction({ db, sql, entities, logger })
+  logger.info('Seeding complete.')
+
+  // Once done seeding, close your connection.
+  await db.dispose()
+}
+
+export const helpFooter = `
+This is a convenience method that loads a JavaScript file and configure @platformatic/sql-mapper to connect to the database specified in the configuration file.
+
+Here is an example of a seed file:
+
+\`\`\`
+'use strict'
+
+module.exports = async function ({ entities, db, sql }) {
+  await entities.graph.save({ input: { name: 'Hello' } })
+  await db.query(sql\`INSERT INTO graphs (name) VALUES ('Hello 2');\`)
+}
+\`\`\`
+
+You can find more details about the configuration format here:
+* [Platformatic DB Configuration](https://docs.platformatic.dev/docs/db/configuration)
+`

package/lib/commands/types.js

@@ -0,0 +1,22 @@
+import { loadConfiguration } from '@platformatic/foundation'
+import { transform } from '../config.js'
+import { schema } from '../schema.js'
+import { execute } from '../types.js'
+
+export async function generateTypes (logger, configFile, _args) {
+  const config = await loadConfiguration(configFile, schema, { transform })
+
+  const count = await execute({ logger, config })
+
+  if (count === 0) {
+    logger.warn('No entities found in your schema. Types were NOT generated.')
+    logger.warn('Make sure you have applied all the migrations and try again.')
+  }
+}
+
+export const helpFooter = `
+As a result of executing this command, the Platformatic DB will generate a \`types\` folder with a typescript file for each database entity. It will also generate a \`plt-env.d.ts\` file that injects the types into the Application instance.
+
+You can find more details about the configuration format here:
+* [Platformatic DB Configuration](https://docs.platformatic.dev/docs/db/configuration)
+`

package/lib/config.js

@@ -0,0 +1,52 @@
+import { kMetadata } from '@platformatic/foundation'
+import { transform as serviceTransform } from '@platformatic/service'
+import { readFile } from 'node:fs/promises'
+import { resolve as resolvePath } from 'node:path'
+
+export async function transform (config) {
+  config = await serviceTransform(config)
+
+  if (
+    config.db &&
+    config.db.connectionString.indexOf('sqlite') === 0 &&
+    config.db.connectionString !== 'sqlite://:memory:'
+  ) {
+    const originalSqlitePath = config.db.connectionString.replace('sqlite://', '')
+    const sqliteFullPath = resolvePath(config[kMetadata].root, originalSqlitePath)
+    config.db.connectionString = 'sqlite://' + sqliteFullPath
+  }
+
+  /* c8 ignore next 3 */
+  if (config.db.graphql?.schemaPath) {
+    config.db.graphql.schema = await readFile(config.db.graphql.schemaPath, 'utf8')
+  }
+
+  /* c8 ignore next 2 */
+  const arePostgresqlSchemaDefined =
+    config.db?.connectionString.indexOf('postgres') === 0 && config.db?.schema?.length > 0
+  const migrationsTableName = arePostgresqlSchemaDefined ? 'public.versions' : 'versions'
+
+  // relative-to-absolute migrations path
+  if (config.migrations) {
+    config.migrations.table = config.migrations.table || migrationsTableName
+  }
+
+  if (config.migrations && config.db) {
+    // TODO remove the ignores
+    /* c8 ignore next 4 */
+    config.db.ignore = config.db.ignore || {}
+    config.db.ignore = Object.assign(
+      {},
+      {
+        [config.migrations.table || migrationsTableName]: true
+      },
+      config.db.ignore
+    )
+  }
+
+  if (config.types?.autogenerate === 'true') {
+    config.types.autogenerate = true
+  }
+
+  return config
+}

package/lib/errors.js

@@ -1,14 +1,18 @@
-'use strict'
+import createError from '@fastify/error'
 
-const createError = require('@fastify/error')
+export const ERROR_PREFIX = 'PLT_DB'
 
-const ERROR_PREFIX = 'PLT_DB'
-
-module.exports = {
-  MigrateMissingMigrationsError: createError(`${ERROR_PREFIX}_MIGRATE_ERROR`, 'Missing "migrations" section in config file'),
-  UnknownDatabaseError: createError(`${ERROR_PREFIX}_UNKNOWN_DATABASE_ERROR`, 'Unknown database'),
-  MigrateMissingMigrationsDirError: createError(`${ERROR_PREFIX}_MIGRATE_ERROR`, 'Migrations directory %s does not exist'),
-  MissingSeedFileError: createError(`${ERROR_PREFIX}_MISSING_SEED_FILE_ERROR`, 'Missing seed file'),
-  MigrationsToApplyError: createError(`${ERROR_PREFIX}_MIGRATIONS_TO_APPLY_ERROR`, 'You have migrations to apply. Please run `platformatic db migrations apply` first.'),
-
-}
+export const MigrateMissingMigrationsError = createError(
+  `${ERROR_PREFIX}_MIGRATE_ERROR`,
+  'Missing "migrations" section in config file'
+)
+export const UnknownDatabaseError = createError(`${ERROR_PREFIX}_UNKNOWN_DATABASE_ERROR`, 'Unknown database')
+export const MigrateMissingMigrationsDirError = createError(
+  `${ERROR_PREFIX}_MIGRATE_ERROR`,
+  'Migrations directory %s does not exist'
+)
+export const MissingSeedFileError = createError(`${ERROR_PREFIX}_MISSING_SEED_FILE_ERROR`, 'Missing seed file')
+export const MigrationsToApplyError = createError(
+  `${ERROR_PREFIX}_MIGRATIONS_TO_APPLY_ERROR`,
+  'You have migrations to apply.'
+)

package/lib/generator.js

@@ -0,0 +1,229 @@
+import { Generator as ServiceGenerator } from '@platformatic/service'
+import { join } from 'node:path'
+import {
+  ENVIRONMENT_TEMPLATE,
+  jsHelperMySQL,
+  jsHelperPostgres,
+  jsHelperSqlite,
+  moviesTestJS,
+  moviesTestTS,
+  README
+} from './templates.js'
+
+export class Generator extends ServiceGenerator {
+  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'
+    }
+  }
+
+  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'
+      }
+    ]
+  }
+
+  getDefaultConfig () {
+    const defaultBaseConfig = super.getDefaultConfig()
+
+    return {
+      ...defaultBaseConfig,
+      database: 'sqlite',
+      connectionString: null,
+      plugin: true,
+      tests: true,
+      types: true,
+      migrations: 'migrations',
+      createMigrations: true
+    }
+  }
+
+  async 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 }
+      ]
+    })
+
+    await super.prepareQuestions()
+  }
+
+  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
+  }
+
+  async _beforePrepare () {
+    if (this.config.isUpdating) {
+      return
+    }
+
+    await super._beforePrepare()
+
+    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(
+      {
+        DATABASE_URL: this.connectionStrings[this.config.database],
+        PLT_APPLY_MIGRATIONS: 'true'
+      },
+      { overwrite: false, default: true }
+    )
+  }
+
+  async _afterPrepare () {
+    if (this.config.isUpdating) {
+      return
+    }
+
+    if (this.config.createMigrations) {
+      this.addFile({ path: 'migrations', file: '001.do.sql', contents: this.getMoviesMigrationDo() })
+      this.addFile({ path: 'migrations', file: '001.undo.sql', contents: this.getMoviesMigrationUndo() })
+    }
+
+    this.addFile({ path: '', file: 'README.md', contents: README })
+
+    if (this.config.plugin) {
+      switch (this.config.database) {
+        case 'sqlite':
+          this.testHelperCustomizations = jsHelperSqlite
+          break
+        case 'mysql':
+          this.testHelperCustomizations = jsHelperMySQL(this.config.connectionString)
+          break
+        case 'postgres':
+          this.testHelperCustomizations = jsHelperPostgres(this.config.connectionString)
+          break
+        case 'mariadb':
+          this.testHelperCustomizations = 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 })
+        }
+      }
+    }
+
+    super._afterPrepare()
+
+    this.addFile({ path: '', file: 'plt-env.d.ts', contents: ENVIRONMENT_TEMPLATE })
+  }
+
+  async _getConfigFileContents () {
+    const config = await super._getConfigFileContents()
+    delete config.service
+    config.$schema = `https://schemas.platformatic.dev/@platformatic/db/${this.platformaticVersion}.json`
+
+    config.db = {
+      connectionString: `{${this.getEnvVarName('DATABASE_URL')}}`,
+      graphql: true,
+      openapi: true,
+      schemalock: true
+    }
+
+    config.watch = {
+      ignore: ['*.sqlite', '*.sqlite-journal']
+    }
+
+    if (this.config.migrations) {
+      config.migrations = {
+        dir: this.config.migrations,
+        autoApply: `{${this.getEnvVarName('PLT_APPLY_MIGRATIONS')}}`
+      }
+
+      this.addFile({ path: 'migrations', file: '.gitkeep', contents: '' })
+    }
+
+    if (this.config.types === true) {
+      config.types = {
+        autogenerate: true
+      }
+    }
+
+    return config
+  }
+}

package/lib/{migrator.mjs → migrator.js}

@@ -1,10 +1,10 @@
-import { join, basename } from 'path'
-import Postgrator from 'postgrator'
 import { createConnectionPool } from '@platformatic/sql-mapper'
-import { stat, readdir } from 'fs/promises'
-import errors from './errors.js'
+import { readdir, stat } from 'node:fs/promises'
+import { basename } from 'node:path'
+import Postgrator from 'postgrator'
+import { MigrateMissingMigrationsDirError, MigrateMissingMigrationsError } from './errors.js'
 
-class Migrator {
+export class Migrator {
   constructor (migrationConfig, coreConfig, logger) {
     this.coreConfig = coreConfig
     this.migrationDir = migrationConfig.dir
@@ -28,7 +28,7 @@ class Migrator {
 
     const { db, sql } = await createConnectionPool({
       ...this.coreConfig,
-      log: this.logger,
+      log: this.logger
     })
 
     let driver
@@ -44,13 +44,12 @@ class Migrator {
       driver = 'sqlite3'
     }
 
-    const database = driver !== 'sqlite3'
-      ? new URL(this.coreConfig.connectionString).pathname.replace(/^\//, '')
-      : ''
+    const database = driver !== 'sqlite3' ? new URL(this.coreConfig.connectionString).pathname.replace(/^\//, '') : ''
 
     this.db = db
 
-    const migrationPattern = join(this.migrationDir, '*')
+    // Glob patterns should always use / as a path separator, even on Windows systems, as \ is used to escape glob characters.
+    const migrationPattern = this.migrationDir + '/*'
     this.logger.debug(`Migrating from ${migrationPattern}`)
 
     this.postgrator = new Postgrator({
@@ -58,40 +57,31 @@ class Migrator {
       driver,
       database,
       schemaTable: this.migrationsTable || 'versions',
-      execQuery: async (query) => {
+      execQuery: async query => {
         const res = await db.query(sql`${sql.__dangerous__rawValue(query)}`)
         return { rows: res }
       },
       validateChecksums: this.validateChecksums,
       newline: this.newline,
-      currentSchema: ['pg', 'mysql'].includes(driver) ? this.currentSchema : undefined,
+      currentSchema: ['pg', 'mysql'].includes(driver) ? this.currentSchema : undefined
     })
 
     if (this.validateChecksums === true) {
-      this.postgrator.on(
-        'validation-started',
-        (migration) => {
-          /* c8 ignore next 3 */
-          const migrationName = basename(migration.filename)
-          this.logger.info(`verifying checksum of migration ${migrationName}`)
-        }
-      )
-    }
-    this.postgrator.on(
-      'migration-started',
-      (migration) => {
-        const migrationName = basename(migration.filename)
-        this.logger.info(`running ${migrationName}`)
-      }
-    )
-    this.postgrator.on(
-      'migration-finished',
-      (migration) => {
-        this.appliedMigrationsCount++
+      this.postgrator.on('validation-started', migration => {
+        /* c8 ignore next 3 */
         const migrationName = basename(migration.filename)
-        this.logger.debug(`completed ${migrationName}`)
-      }
-    )
+        this.logger.info(`verifying checksum of migration ${migrationName}`)
+      })
+    }
+    this.postgrator.on('migration-started', migration => {
+      const migrationName = basename(migration.filename)
+      this.logger.info(`running ${migrationName}`)
+    })
+    this.postgrator.on('migration-finished', migration => {
+      this.appliedMigrationsCount++
+      const migrationName = basename(migration.filename)
+      this.logger.debug(`completed ${migrationName}`)
+    })
   }
 
   async checkMigrationsDirectoryExists () {
@@ -99,7 +89,7 @@ class Migrator {
       await stat(this.migrationDir)
     } catch (err) {
       if (err.code === 'ENOENT') {
-        throw new errors.MigrateMissingMigrationsDirError(this.migrationDir)
+        throw new MigrateMissingMigrationsDirError(this.migrationDir)
       }
     }
   }
@@ -177,7 +167,7 @@ class Migrator {
       }
     } catch (err) {
       if (err.code === 'ENOENT') {
-        throw new errors.MigrateMissingMigrationsDirError(this.migrationDir)
+        throw new MigrateMissingMigrationsDirError(this.migrationDir)
       }
     }
   }
@@ -191,4 +181,22 @@ class Migrator {
   }
 }
 
-export { Migrator }
+export async function execute (logger, config, to, rollback) {
+  const migrationsConfig = config.migrations
+  if (migrationsConfig === undefined) {
+    throw new 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()
+  }
+}

package/lib/{root-endpoint/index.js → root.js}

@@ -1,11 +1,10 @@
-'use strict'
-const path = require('path')
-const fastifyStatic = require('@fastify/static')
-const userAgentParser = require('my-ua-parser')
+import fastifyStatic from '@fastify/static'
+import userAgentParser from 'my-ua-parser'
+import path from 'node:path'
 
-module.exports = async (app, opts) => {
+export async function root (app) {
   app.register(fastifyStatic, {
-    root: path.join(__dirname, 'public'),
+    root: path.join(import.meta.dirname, '../public')
   })
   // root endpoint
   app.route({
@@ -21,6 +20,6 @@ module.exports = async (app, opts) => {
         }
       }
       return { message: 'Welcome to Platformatic! Please visit https://docs.platformatic.dev' }
-    },
+    }
   })
 }