@platformatic/db 2.74.3 → 3.0.0-alpha.2

package/lib/commands/print-schema.js

@@ -0,0 +1,30 @@
+import { abstractLogger, kMetadata, loadConfiguration } from '@platformatic/foundation'
+import { printSchema as printGraphqlSchema } from 'graphql'
+import { create } from '../../index.js'
+import { schema } from '../schema.js'
+
+export async function printSchema (logger, configFile, args, { colorette: { bold }, logFatalError }) {
+  const config = await loadConfiguration(configFile, schema)
+
+  const type = args[0]
+
+  if (!type) {
+    logFatalError(logger, `Please specify a schema type between ${bold('openapi')} and ${bold('graphql')}.`)
+  } else if (type !== 'openapi' && type !== 'graphql') {
+    logFatalError(logger, `Invalid schema type ${bold(type)}. Use ${bold('openapi')} or ${bold('graphql')}.`)
+  }
+
+  const app = await create(config[kMetadata].root, configFile, { logger: abstractLogger })
+  await app.init()
+
+  let output
+  if (type === 'openapi') {
+    await app.start({ listen: true })
+    output = JSON.stringify(app.getApplication().swagger(), null, 2)
+  } else {
+    output = printGraphqlSchema(app.getApplication().graphql.schema)
+  }
+
+  console.log(output)
+  await app.stop()
+}

package/lib/commands/seed.js

@@ -0,0 +1,72 @@
+import { loadConfiguration, loadModule } from '@platformatic/foundation'
+import { access } from 'fs/promises'
+import { createRequire } from 'node:module'
+import { resolve } from 'node:path'
+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)
+
+  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 seedFile = resolve(process.cwd(), args[0])
+  await access(seedFile)
+
+  logger.info(`Seeding from ${bold(seedFile)}`)
+
+  const importedModule = await loadModule(createRequire(resolve(process.cwd(), 'noop.js')), seedFile)
+
+  const seedFunction = typeof importedModule?.seed !== 'function' ? importedModule : importedModule
+
+  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,21 @@
+import { loadConfiguration } from '@platformatic/foundation'
+import { schema } from '../schema.js'
+import { execute } from '../types.js'
+
+export async function generateTypes (logger, configFile, _args) {
+  const config = await loadConfiguration(configFile, schema)
+
+  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/errors.js

@@ -1,14 +1,18 @@
-'use strict'
-
-const createError = require('@fastify/error')
+import createError from '@fastify/error'
 
 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 { 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,9 +44,7 @@ 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
 
@@ -59,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 () {
@@ -100,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)
       }
     }
   }
@@ -178,7 +167,7 @@ class Migrator {
       }
     } catch (err) {
       if (err.code === 'ENOENT') {
-        throw new errors.MigrateMissingMigrationsDirError(this.migrationDir)
+        throw new MigrateMissingMigrationsDirError(this.migrationDir)
       }
     }
   }
@@ -192,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' }
-    },
+    }
   })
 }

package/lib/schema.js

@@ -1,12 +1,22 @@
 #! /usr/bin/env node
-'use strict'
 
-const { metrics, server, plugins, watch, openApiDefs, openApiBase, clients } = require('@platformatic/service').schemas
-const { schemaComponents } = require('@platformatic/utils')
-const telemetry = require('@platformatic/telemetry').schema
-const pkg = require('../package.json')
+import { schemaComponents as basicSchemaComponents } from '@platformatic/basic'
+import {
+  fastifyServer as server,
+  schemaComponents as utilsSchemaComponents,
+  watch,
+  wrappedRuntime
+} from '@platformatic/foundation'
+import { schemaComponents as serviceSchemaComponents } from '@platformatic/service'
+import { readFileSync } from 'node:fs'
+import { resolve } from 'node:path'
 
-const db = {
+export const packageJson = JSON.parse(readFileSync(resolve(import.meta.dirname, '../package.json'), 'utf8'))
+export const version = packageJson.version
+
+const { plugins, openApiBase, $defs } = serviceSchemaComponents
+
+export const db = {
   type: 'object',
   properties: {
     connectionString: {
@@ -235,7 +245,7 @@ const db = {
   required: ['connectionString']
 }
 
-const sharedAuthorizationRule = {
+export const sharedAuthorizationRule = {
   role: {
     type: 'string',
     description: 'the role name to match the rule'
@@ -261,7 +271,7 @@ const sharedAuthorizationRule = {
   }
 }
 
-const authorization = {
+export const authorization = {
   type: 'object',
   properties: {
     adminSecret: {
@@ -367,7 +377,7 @@ const authorization = {
   additionalProperties: false
 }
 
-const migrations = {
+export const migrations = {
   type: 'object',
   properties: {
     dir: {
@@ -410,7 +420,7 @@ const migrations = {
   required: ['dir']
 }
 
-const types = {
+export const types = {
   type: 'object',
   properties: {
     autogenerate: {
@@ -433,10 +443,18 @@ const types = {
   additionalProperties: false
 }
 
-const platformaticDBschema = {
-  $id: `https://schemas.platformatic.dev/@platformatic/db/${pkg.version}.json`,
+export const schemaComponents = {
+  db,
+  sharedAuthorizationRule,
+  authorization,
+  migrations,
+  types
+}
+
+export const schema = {
+  $id: `https://schemas.platformatic.dev/@platformatic/db/${packageJson.version}.json`,
   $schema: 'http://json-schema.org/draft-07/schema#',
-  title: 'Platformatic DB',
+  title: 'Platformatic Database Config',
   type: 'object',
   properties: {
     basePath: {
@@ -455,12 +473,11 @@ const platformaticDBschema = {
     db,
     authorization,
     migrations,
-    metrics,
     types,
     plugins,
-    telemetry,
-    clients,
-    runtime: schemaComponents.wrappedRuntime,
+    application: basicSchemaComponents.application,
+    telemetry: utilsSchemaComponents.telemetry,
+    runtime: wrappedRuntime,
     watch: {
       anyOf: [
         watch,
@@ -482,7 +499,7 @@ const platformaticDBschema = {
   additionalProperties: false,
   required: ['db'],
   $defs: {
-    ...openApiDefs,
+    ...$defs,
     'crud-operation-auth': {
       oneOf: [
         {
@@ -534,8 +551,7 @@ const platformaticDBschema = {
   }
 }
 
-module.exports.schema = platformaticDBschema
-
-if (require.main === module) {
-  console.log(JSON.stringify(platformaticDBschema, null, 2))
+/* c8 ignore next 3 */
+if (process.argv[1] === import.meta.filename) {
+  console.log(JSON.stringify(schema, null, 2))
 }