@platformatic/db 2.72.0 → 3.0.0-alpha.1

package/config.d.ts

@@ -22,7 +22,7 @@ export type CrudOperationAuth =
     }
   | boolean;
 
-export interface PlatformaticDB {
+export interface PlatformaticDatabaseConfig {
   basePath?: string;
   server?: {
     hostname?: string;
@@ -387,24 +387,6 @@ export interface PlatformaticDB {
      */
     currentSchema?: string;
   };
-  metrics?:
-    | boolean
-    | {
-        port?: number | string;
-        hostname?: string;
-        endpoint?: string;
-        server?: "own" | "parent" | "hide";
-        defaultMetrics?: {
-          enabled: boolean;
-        };
-        auth?: {
-          username: string;
-          password: string;
-        };
-        labels?: {
-          [k: string]: string;
-        };
-      };
   types?: {
     /**
      * Should types be auto generated.

package/eslint.config.js

@@ -1,8 +1,12 @@
-'use strict'
+import neostandard from 'neostandard'
 
-const neostandard = require('neostandard')
-
-module.exports = neostandard({
+export default neostandard({
   ts: true,
-  ignores: [...neostandard.resolveIgnoresFromGitignore(), 'test/tmp/**/*'],
+  ignores: [
+    ...neostandard.resolveIgnoresFromGitignore(),
+    'test/tmp/**/*',
+    'test/fixtures/*/dist/**/*',
+    '**/dist/*',
+    'tmp/**/*'
+  ]
 })

package/index.d.ts

@@ -1,42 +1,67 @@
-/// <reference types="@platformatic/sql-graphql" />
-/// <reference types="@platformatic/sql-openapi" />
-import { FastifyInstance } from 'fastify'
-import { PlatformaticDB } from './config'
-import ConfigManager from '@platformatic/config'
-import type { ConfigManagerConfig, StackableInterface } from '@platformatic/config'
-import { SQLMapperPluginInterface, Entities } from '@platformatic/sql-mapper'
-import { SQLEventsPluginInterface } from '@platformatic/sql-events'
 import { DBAuthorizationPluginInterface } from '@platformatic/db-authorization'
-import { FastifyError } from '@fastify/error'
+import { BaseGenerator } from '@platformatic/generators'
+import { PlatformaticApplication, ServiceStackable } from '@platformatic/service'
+import { SQLEventsPluginInterface } from '@platformatic/sql-events'
+import { Entities, SQLMapperPluginInterface } from '@platformatic/sql-mapper'
+import { Configuration, ConfigurationOptions } from '@platformatic/utils'
+import { JSONSchemaType } from 'ajv'
+import { FastifyError, FastifyInstance } from 'fastify'
+import { PlatformaticDatabaseConfig } from './config'
 
-export { Entities, EntityHooks, Entity, createConnectionPool } from '@platformatic/sql-mapper'
-export { PlatformaticApp } from '@platformatic/service'
+export { PlatformaticApplication } from '@platformatic/service'
+export { createConnectionPool, Entities, Entity, EntityHooks } from '@platformatic/sql-mapper'
+export { PlatformaticDatabaseConfig } from './config'
 
-export type PlatformaticDBMixin<T extends Entities> =
-  SQLMapperPluginInterface<T> &
+export type PlatformaticDatabaseMixin<T extends Entities> = SQLMapperPluginInterface<T> &
   SQLEventsPluginInterface &
   DBAuthorizationPluginInterface
 
-export type PlatformaticDBConfig = PlatformaticDB
+export type DatabaseStackable = ServiceStackable<PlatformaticDatabaseConfig>
+
+export type ServerInstance<T = {}> = FastifyInstance & {
+  platformatic: PlatformaticApplication<PlatformaticDatabaseConfig> & PlatformaticDatabaseMixin<Entities> & T
+}
+
+export type DatabaseConfiguration = Configuration<PlatformaticDatabaseConfig>
+
+export declare function transform (
+  config: DatabaseConfiguration
+): Promise<DatabaseConfiguration> | DatabaseConfiguration
 
-export function buildServer (opts: object, app?: object, ConfigManagerContructor?: object): Promise<FastifyInstance>
+export declare function loadConfiguration (
+  root: string | PlatformaticDatabaseConfig,
+  source?: string | PlatformaticDatabaseConfig,
+  context?: ConfigurationOptions
+): Promise<DatabaseConfiguration>
 
-export function buildStackable (opts: object, app?: object): Promise<{
-  configType: string,
-  configManager?: ConfigManager<PlatformaticDBConfig>,
-  configManagerConfig?: ConfigManagerConfig<PlatformaticDBConfig>,
-  schema?: object,
-  stackable?: StackableInterface
-}>
+export declare function create (
+  root: string,
+  source?: string | PlatformaticDatabaseConfig,
+  context?: ConfigurationOptions
+): Promise<ServiceStackable>
 
-/**
- * All the errors thrown by the plugin.
- */
-export module errors {
+export declare const skipTelemetryHooks: boolean
 
-  export const MigrateMissingMigrationsError: () => FastifyError
-  export const UnknownDatabaseError: () => FastifyError
-  export const MigrateMissingMigrationsDirError: (dir: string) => FastifyError
-  export const MissingSeedFileError: () => FastifyError
-  export const MigrationsToApplyError: () => FastifyError
+export declare function platformaticDatabase (app: FastifyInstance, stackable: DatabaseStackable): Promise<void>
+
+export declare class Generator extends BaseGenerator.BaseGenerator {}
+
+export declare const packageJson: Record<string, unknown>
+
+export declare const schema: JSONSchemaType<PlatformaticDatabaseConfig>
+
+export declare const schemaComponents: {
+  db: JSONSchemaType<object>
+  sharedAuthorizationRule: JSONSchemaType<object>
+  authorization: JSONSchemaType<object>
+  migrations: JSONSchemaType<object>
+  types: JSONSchemaType<object>
 }
+
+export declare const version: string
+
+export declare function MigrateMissingMigrationsError (): FastifyError
+export declare function UnknownDatabaseError (): FastifyError
+export declare function MigrateMissingMigrationsDirError (dir: string): FastifyError
+export declare function MissingSeedFileError (): FastifyError
+export declare function MigrationsToApplyError (): FastifyError

package/index.js

@@ -1,146 +1,85 @@
-'use strict'
-
-const core = require('@platformatic/db-core')
-const auth = require('@platformatic/db-authorization')
-const { createConnectionPool } = require('@platformatic/sql-mapper')
-const { platformaticService, buildServer, buildStackable } = require('@platformatic/service')
-const { isKeyEnabled } = require('@platformatic/utils')
-const { schema } = require('./lib/schema')
-const ConfigManager = require('@platformatic/config')
-const adjustConfig = require('./lib/adjust-config')
-const { locateSchemaLock, updateSchemaLock } = require('./lib/utils')
-const errors = require('./lib/errors')
-const upgrade = require('./lib/upgrade')
-const fs = require('fs/promises')
-const { DbStackable } = require('./lib/stackable')
-const version = require('./package.json').version
-
-async function platformaticDB (app, opts) {
-  const configManager = app.platformatic.configManager
-  const config = configManager.current
-
-  let createSchemaLock = false
-  await loadSchemaLock()
-
-  async function loadSchemaLock () {
-    if (config.db.schemalock) {
-      // ignore errors, this is an optimization
-      try {
-        const path = locateSchemaLock(configManager)
-        const dbschema = JSON.parse(await fs.readFile(path, 'utf8'))
-        config.db.dbschema = dbschema
-        app.log.trace({ dbschema }, 'loaded schema lock')
-        createSchemaLock = false
-      } catch (err) {
-        app.log.trace({ err }, 'failed to load schema lock')
-        app.log.info('no schema lock found, will create one')
-        createSchemaLock = true
-      }
-    }
+import { resolve, validationOptions } from '@platformatic/basic'
+import { transform as serviceTransform } from '@platformatic/service'
+import { kMetadata, loadConfiguration as utilsLoadConfiguration } from '@platformatic/utils'
+import { readFile } from 'node:fs/promises'
+import { resolve as resolvePath } from 'node:path'
+import { schema } from './lib/schema.js'
+import { DatabaseStackable } from './lib/stackable.js'
+import { upgrade } from './lib/upgrade.js'
+
+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
   }
 
-  if (config.migrations && config.migrations.autoApply === true && !app.restarted) {
-    app.log.debug({ migrations: config.migrations }, 'running migrations')
-    const { execute } = await import('./lib/migrate.mjs')
-    const migrationsApplied = await execute({ logger: app.log, config })
-    if (migrationsApplied) {
-      // reload schema lock
-      await updateSchemaLock(app.log, configManager)
-      await loadSchemaLock()
-    }
-
-    if (config.types && config.types.autogenerate === true) {
-      app.log.debug({ types: config.types }, 'generating types')
-      const { execute } = await import('./lib/gen-types.mjs')
-      await execute({ logger: app.log, config, configManager })
-    }
+  /* c8 ignore next 3 */
+  if (config.db.graphql?.schemaPath) {
+    config.db.graphql.schema = await readFile(config.db.graphql.schemaPath, 'utf8')
   }
 
-  if (isKeyEnabled('healthCheck', config.server)) {
-    if (typeof config.server.healthCheck !== 'object') {
-      config.server.healthCheck = {}
-    }
-    config.server.healthCheck.fn = healthCheck
-  }
+  /* c8 ignore next 2 */
+  const arePostgresqlSchemaDefined =
+    config.db?.connectionString.indexOf('postgres') === 0 && config.db?.schema?.length > 0
+  const migrationsTableName = arePostgresqlSchemaDefined ? 'public.versions' : 'versions'
 
-  if (createSchemaLock) {
-    try {
-      const path = locateSchemaLock(configManager)
-      await fs.writeFile(path, JSON.stringify(app.platformatic.dbschema, null, 2))
-      app.log.info({ path }, 'created schema lock')
-    } catch (err) {
-      app.log.trace({ err }, 'unable to save schema lock')
-    }
+  // relative-to-absolute migrations path
+  if (config.migrations) {
+    config.migrations.table = config.migrations.table || migrationsTableName
   }
 
-  async function toLoad (app) {
-    await app.register(core, config.db)
-
-    if (config.authorization) {
-      await app.register(auth, config.authorization)
-    }
-
-    if (Object.keys(app.platformatic.entities).length === 0) {
-      app.log.warn(
-        'No tables found in the database. Are you connected to the right database? Did you forget to run your migrations? ' +
-        'This guide can help with debugging Platformatic DB: https://docs.platformatic.dev/docs/guides/debug-platformatic-db'
-      )
-    }
+  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
+    )
   }
-  toLoad[Symbol.for('skip-override')] = true
-
-  await app.register(platformaticService, {
-    ...opts,
-    beforePlugins: [toLoad],
-  })
 
-  if (!app.hasRoute({ url: '/', method: 'GET' }) && !app.hasRoute({ url: '/*', method: 'GET' })) {
-    app.register(require('./lib/root-endpoint'), config)
+  if (config.types?.autogenerate === 'true') {
+    config.types.autogenerate = true
   }
-}
 
-async function healthCheck (app) {
-  const { db, sql } = app.platformatic
-  try {
-    await db.query(sql`SELECT 1`)
-    return true
-  } catch (err) {
-    app.log.warn({ err }, 'Healthcheck failed')
-    return false
-  }
+  return config
 }
 
-platformaticDB[Symbol.for('skip-override')] = true
-platformaticDB.schema = schema
-platformaticDB.configType = 'db'
-platformaticDB.isPLTService = true
-platformaticDB.configManagerConfig = {
-  version,
-  schema,
-  allowToWatch: ['.env'],
-  schemaOptions: platformaticService.configManagerConfig.schemaOptions,
-  replaceEnvIgnore: ['$.db.openapi.ignoreRoutes'],
-  async transformConfig () {
-    await adjustConfig(this)
-  },
-  upgrade,
+export async function loadConfiguration (configOrRoot, sourceOrConfig, context) {
+  const { root, source } = await resolve(configOrRoot, sourceOrConfig, 'db')
+
+  return utilsLoadConfiguration(source, context?.schema ?? schema, {
+    validationOptions,
+    transform,
+    upgrade,
+    replaceEnv: true,
+    replaceEnvIgnore: ['$.db.openapi.ignoreRoutes'],
+    root,
+    ...context
+  })
 }
 
-function _buildServer (options) {
-  return buildServer(options, platformaticDB)
+export async function create (configOrRoot, sourceOrConfig, context) {
+  const config = await loadConfiguration(configOrRoot, sourceOrConfig, context)
+  return new DatabaseStackable(config[kMetadata].root, config, context)
 }
 
-async function buildDbStackable (options) {
-  return buildStackable(options, platformaticDB, DbStackable)
-}
+export const skipTelemetryHooks = true
 
-module.exports = platformaticDB
-module.exports.buildServer = _buildServer
-module.exports.schema = schema
-module.exports.platformaticDB = platformaticDB
-module.exports.ConfigManager = ConfigManager
-module.exports.errors = errors
-module.exports.createConnectionPool = createConnectionPool
-module.exports.Generator = require('./lib/generator/db-generator').Generator
-module.exports.buildStackable = buildDbStackable
-module.exports.DbStackable = DbStackable
+export { platformaticDatabase } from './lib/application.js'
+export * from './lib/commands/index.js'
+export * from './lib/errors.js'
+export * as errors from './lib/errors.js'
+export { Generator } from './lib/generator.js'
+export { packageJson, schema, schemaComponents, version } from './lib/schema.js'
+export { DatabaseStackable } from './lib/stackable.js'

package/lib/application.js

@@ -0,0 +1,102 @@
+import auth from '@platformatic/db-authorization'
+import core from '@platformatic/db-core'
+import { platformaticService } from '@platformatic/service'
+import { isKeyEnabled } from '@platformatic/utils'
+import { readFile, writeFile } from 'node:fs/promises'
+import { execute as applyMigrations } from './migrator.js'
+import { root } from './root.js'
+import { execute as generateTypes } from './types.js'
+import { locateSchemaLock, updateSchemaLock } from './utils.js'
+
+async function healthCheck (app) {
+  const { db, sql } = app.platformatic
+  try {
+    await db.query(sql`SELECT 1`)
+    return true
+  } catch (err) {
+    app.log.warn({ err }, 'Healthcheck failed')
+    return false
+  }
+}
+
+export async function platformaticDatabase (app, stackable) {
+  const config = await stackable.getConfig(true)
+
+  let createSchemaLock = false
+  await loadSchemaLock()
+
+  async function loadSchemaLock () {
+    if (config.db.schemalock) {
+      // ignore errors, this is an optimization
+      try {
+        const path = locateSchemaLock(config)
+        const dbschema = JSON.parse(await readFile(path, 'utf8'))
+        config.db.dbschema = dbschema
+        app.log.trace({ dbschema }, 'loaded schema lock')
+        createSchemaLock = false
+      } catch (err) {
+        app.log.trace({ err }, 'failed to load schema lock')
+        app.log.info('no schema lock found, will create one')
+        createSchemaLock = true
+      }
+    }
+  }
+
+  if (config.migrations && config.migrations.autoApply === true && !app.restarted) {
+    app.log.debug({ migrations: config.migrations }, 'running migrations')
+
+    const migrationsApplied = await applyMigrations(app.log, config)
+    if (migrationsApplied) {
+      // reload schema lock
+      await updateSchemaLock(app.log, config)
+      await loadSchemaLock()
+    }
+
+    if (config.types && config.types.autogenerate === true) {
+      app.log.debug({ types: config.types }, 'generating types')
+      await generateTypes({ logger: app.log, config })
+    }
+  }
+
+  if (isKeyEnabled('healthCheck', config.server)) {
+    const serverConfig = config.server
+
+    if (typeof serverConfig.healthCheck !== 'object') {
+      serverConfig.healthCheck = {}
+    }
+
+    serverConfig.healthCheck.fn = healthCheck
+    await stackable.updateContext({ serverConfig })
+  }
+
+  if (createSchemaLock) {
+    try {
+      const path = locateSchemaLock(config)
+      await writeFile(path, JSON.stringify(app.platformatic.dbschema, null, 2))
+      app.log.info({ path }, 'created schema lock')
+    } catch (err) {
+      app.log.trace({ err }, 'unable to save schema lock')
+    }
+  }
+
+  await app.register(core, config.db)
+
+  if (config.authorization) {
+    await app.register(auth, config.authorization)
+  }
+
+  await platformaticService(app, stackable)
+
+  if (Object.keys(app.platformatic.entities).length === 0) {
+    app.log.warn(
+      'No tables found in the database. Are you connected to the right database? Did you forget to run your migrations? ' +
+        'This guide can help with debugging Platformatic DB: https://docs.platformatic.dev/docs/guides/debug-platformatic-db'
+    )
+  }
+
+  if (!app.hasRoute({ url: '/', method: 'GET' }) && !app.hasRoute({ url: '/*', method: 'GET' })) {
+    await app.register(root, config)
+  }
+}
+
+platformaticDatabase[Symbol.for('skip-override')] = true

package/lib/commands/index.js

@@ -0,0 +1,59 @@
+import { applyMigrations, helpFooter as applyMigrationsFooter } from './migrations-apply.js'
+import { createMigrations, helpFooter as createMigrationsFooter } from './migrations-create.js'
+import { printSchema } from './print-schema.js'
+import { seed, helpFooter as seedFooter } from './seed.js'
+import { generateTypes, helpFooter as typesFooter } from './types.js'
+
+export function createCommands (id) {
+  return {
+    commands: {
+      [`${id}:migrations:create`]: createMigrations,
+      [`${id}:migrations:apply`]: applyMigrations,
+      [`${id}:seed`]: seed,
+      [`${id}:types`]: generateTypes,
+      [`${id}:schema`]: printSchema
+    },
+    help: {
+      [`${id}:migrations:create`]: {
+        usage: `${id}:migrations:create`,
+        description: 'Create a new migration file',
+        footer: createMigrationsFooter
+      },
+      [`${id}:migrations:apply`]: {
+        usage: `${id}:migrations:apply`,
+        description: 'Apply all configured migrations to the database',
+        footer: applyMigrationsFooter,
+        options: [
+          {
+            usage: '-r, --rollback',
+            description: 'Rollback migrations instead of applying them'
+          },
+          {
+            usage: '-t, --to <version>',
+            description: 'Migrate to a specific version'
+          }
+        ]
+      },
+      [`${id}:seed`]: {
+        usage: `${id}:seed [file]`,
+        description: 'Load a seed into the database',
+        footer: seedFooter,
+        args: [
+          {
+            name: 'file',
+            description: 'The seed file to load.'
+          }
+        ]
+      },
+      [`${id}:types`]: {
+        usage: `${id}:types`,
+        description: 'Generate TypeScript types for your entities from the database',
+        footer: typesFooter
+      },
+      [`${id}:schema`]: {
+        usage: `${id}:schema [openapi|graphql]`,
+        description: 'Prints the OpenAPI or GraphQL schema for the database'
+      }
+    }
+  }
+}

package/lib/commands/migrations-apply.js

@@ -0,0 +1,62 @@
+import { loadConfiguration } from '@platformatic/utils'
+import { utimesSync } from 'node:fs'
+import { execute } from '../migrator.js'
+import { schema } from '../schema.js'
+import { updateSchemaLock } from '../utils.js'
+import { generateTypes } from './types.js'
+
+export async function applyMigrations (logger, configFile, args, context) {
+  const { parseArgs, logFatalError } = context
+  const config = await loadConfiguration(configFile, schema)
+
+  const {
+    values: { to, rollback }
+  } = parseArgs(
+    args,
+    {
+      rollback: {
+        type: 'boolean',
+        short: 'r'
+      },
+      to: {
+        type: 'string',
+        short: 't'
+      }
+    },
+    false
+  )
+
+  try {
+    const appliedMigrations = await execute(logger, config, to, rollback)
+
+    if (config.types && config.types.autogenerate) {
+      await generateTypes(logger, configFile, args, context)
+    }
+
+    if (appliedMigrations) {
+      await updateSchemaLock(logger, config)
+    }
+
+    // touch the @platformatic/db config to trigger a restart
+    const now = new Date()
+
+    utimesSync(configFile, now, now)
+  } catch (err) {
+    if (err.code === 'PTL_DB_MIGRATE_ERROR') {
+      logFatalError(logger, err.message)
+      return
+    }
+
+    /* c8 ignore next 2 */
+    throw err
+  }
+}
+
+export const helpFooter = `
+The migrations will be applied in the order they are specified in the
+folder defined in the configuration file. If you want to apply a specific migration,
+you can use the \`--to\` option (use \`000\` to reset to the initial state).
+
+You can find more details about the configuration format here:
+* [Platformatic DB Configuration](https://docs.platformatic.dev/docs/db/configuration)
+`

package/lib/commands/migrations-create.js

@@ -0,0 +1,48 @@
+import { loadConfiguration } from '@platformatic/utils'
+import { writeFile } from 'node:fs/promises'
+import { join, relative } from 'node:path'
+import * as errors from '../errors.js'
+import { Migrator } from '../migrator.js'
+import { schema } from '../schema.js'
+
+export async function createMigrations (logger, configFile, _, { colorette: { bold } }) {
+  const config = await loadConfiguration(configFile, schema)
+
+  let migrator = null
+  try {
+    const migrationsConfig = config.migrations
+    if (migrationsConfig === undefined) {
+      throw new errors.MigrateMissingMigrationsError()
+    }
+
+    migrator = new Migrator(migrationsConfig, config.db, logger)
+
+    const nextMigrationVersion = await migrator.getNextMigrationVersion()
+    const nextMigrationVersionStr = migrator.convertVersionToStr(nextMigrationVersion)
+
+    const nextDoMigrationName = `${nextMigrationVersionStr}.do.sql`
+    const nextUndoMigrationName = `${nextMigrationVersionStr}.undo.sql`
+
+    const doFile = join(migrator.migrationDir, nextDoMigrationName)
+    const undoFile = join(migrator.migrationDir, nextUndoMigrationName)
+
+    await Promise.all([writeFile(doFile, ''), writeFile(undoFile, '')])
+
+    logger.info(
+      `Created migration files ${bold(relative(process.cwd(), doFile))} and ${bold(relative(process.cwd(), undoFile))}.`
+    )
+  } catch (error) {
+    logger.error(error.message)
+  } finally {
+    await migrator?.close()
+  }
+}
+
+export const helpFooter = `
+It will generate do and undo sql files in the migrations folder. The name of the files will be the next migration number.
+
+The migration files are named \`001.<do|undo>.sql\`, \`002.<do|undo>.sql\` etc...
+
+You can find more details about the configuration format here:
+* [Platformatic DB Configuration](https://docs.platformatic.dev/docs/db/configuration)
+`

package/lib/commands/print-schema.js

@@ -0,0 +1,30 @@
+import { abstractLogger, kMetadata, loadConfiguration } from '@platformatic/utils'
+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()
+}