@platformatic/db 3.4.1 → 3.5.0

package/lib/gen-schema.mjs

@@ -1,68 +0,0 @@
-import pino from 'pino'
-import pretty from 'pino-pretty'
-import Fastify from 'fastify'
-import graphql from 'graphql'
-import { writeFile } from 'fs/promises'
-import { loadConfig } from '@platformatic/config'
-import { createServerConfig } from '@platformatic/utils'
-import { platformaticDB } from '../index.js'
-import { schema as platformaticDBschema } from './schema.js'
-
-async function buildServer (_args, onServer) {
-  const logger = pino(pretty({
-    translateTime: 'SYS:HH:MM:ss',
-    ignore: 'hostname,pid',
-    minimumLevel: 'error',
-  }))
-
-  try {
-    const { configManager } = await loadConfig({}, _args, platformaticDB)
-
-    await configManager.parseAndValidate()
-    const config = configManager.current
-    delete config.logger
-    config.loggerInstance = logger
-
-    const serverConfig = createServerConfig(config)
-    serverConfig.originalConfig = config
-    serverConfig.configManager = configManager
-    delete serverConfig.logger
-    serverConfig.loggerInstance = logger
-
-    const app = Fastify(serverConfig)
-    app.decorate('platformatic', { configManager, config: configManager.current })
-    app.register(platformaticDB, serverConfig)
-
-    await app.ready()
-
-    await onServer(app)
-    /* c8 ignore next 4 */
-  } catch (err) {
-    logger.error(err)
-    process.exit(1)
-  }
-}
-
-function printGraphQLSchema (_args) {
-  buildServer(_args, async function (app) {
-    const schema = graphql.printSchema(app.graphql.schema)
-    console.log(schema)
-    await app.close()
-  })
-}
-
-function printOpenAPISchema (_args) {
-  buildServer(_args, async function (app) {
-    const schema = app.swagger()
-    console.log(JSON.stringify(schema, null, 2))
-    await app.close()
-  })
-}
-
-const filenameConfigJsonSchema = 'platformatic.db.schema.json'
-
-async function generateJsonSchemaConfig () {
-  await writeFile(filenameConfigJsonSchema, JSON.stringify(platformaticDBschema, null, 2))
-}
-
-export { printGraphQLSchema, printOpenAPISchema, generateJsonSchemaConfig, filenameConfigJsonSchema }

package/lib/gen-types.mjs

@@ -1,202 +0,0 @@
-import { loadConfig } from '@platformatic/config'
-import { mapOpenAPItoTypes, mapSQLEntityToJSONSchema } from '@platformatic/sql-json-schema-mapper'
-import utils, { createDirectory } from '@platformatic/utils'
-import camelcase from 'camelcase'
-import { readFile, readdir, unlink, writeFile } from 'fs/promises'
-import { createRequire } from 'node:module'
-import { basename, join, parse, posix, relative, resolve } from 'path'
-import pino from 'pino'
-import pretty from 'pino-pretty'
-import { platformaticDB } from '../index.js'
-import { isFileAccessible, setupDB } from './utils.js'
-
-const checkForDependencies = utils.checkForDependencies
-
-const GLOBAL_TYPES_TEMPLATE = `\
-import type { PlatformaticApp, PlatformaticDBMixin, PlatformaticDBConfig, Entity, Entities, EntityHooks } from '@platformatic/db'
-ENTITIES_IMPORTS_PLACEHOLDER
-
-interface AppEntities extends Entities {
-  ENTITIES_DEFINITION_PLACEHOLDER
-}
-
-interface AppEntityHooks {
-  HOOKS_DEFINITION_PLACEHOLDER
-}
-
-declare module 'fastify' {
-  interface FastifyInstance {
-    platformatic: PlatformaticApp<PlatformaticDBConfig> &
-      PlatformaticDBMixin<AppEntities> &
-      AppEntityHooks
-  }
-}
-`
-
-async function removeUnusedTypeFiles (entities, dir) {
-  const entityTypes = await readdir(dir)
-  const entityNames = Object.values(entities).map(entity => entity.name)
-  const removedEntityNames = entityTypes.filter(file => !entityNames.includes(basename(file, '.d.ts')))
-  await Promise.all(removedEntityNames.map(file => unlink(join(dir, file))))
-}
-
-function getTypesFolderPath (cwd, config) {
-  return resolve(cwd, config.types?.dir ?? 'types')
-}
-
-async function generateEntityType (entity) {
-  const jsonSchema = mapSQLEntityToJSONSchema(entity)
-  const fieldDefinitions = Object.fromEntries(
-    Object.entries(entity.fields).map(([, value]) => [value.camelcase, value])
-  )
-  const tsCode = mapOpenAPItoTypes(jsonSchema, fieldDefinitions)
-  entity.name = camelcase(entity.name).replace(/^\w/, c => c.toUpperCase())
-  return tsCode + `\nexport { ${entity.name} };\n`
-}
-
-async function generateEntityGroupExport (entities) {
-  const completeTypesImports = []
-  const interfaceRows = []
-  for (const name of entities) {
-    completeTypesImports.push(`import { ${name} } from './${name}'`)
-    interfaceRows.push(`${name}: ${name}`)
-  }
-
-  const content = `${completeTypesImports.join('\n')}
-  
-interface EntityTypes  {
-  ${interfaceRows.join('\n    ')}
-}
-  
-export { EntityTypes, ${entities.join(', ')} }`
-  return content
-}
-
-async function generateGlobalTypes (entities, config) {
-  const globalTypesImports = []
-  const globalTypesInterface = []
-  const globalHooks = []
-  const completeTypesImports = []
-
-  let typesRelativePath = relative(process.cwd(), getTypesFolderPath(process.cwd(), config))
-  {
-    const parsedPath = parse(typesRelativePath)
-    typesRelativePath = posix.format(parsedPath)
-  }
-
-  const schemaIdTypes = []
-  const names = []
-  const keys = Object.keys(entities).sort()
-  for (const key of keys) {
-    const { name, singularName } = entities[key]
-    schemaIdTypes.push(name)
-    completeTypesImports.push(`import { ${name} } from './${typesRelativePath}/${name}'`)
-    globalTypesInterface.push(`${key}: Entity<${name}>,`)
-    globalHooks.push(`addEntityHooks(entityName: '${singularName}', hooks: EntityHooks<${name}>): any`)
-    names.push(name)
-  }
-  globalTypesImports.push(`import { EntityTypes, ${names.join(',')} } from './${typesRelativePath}'`)
-
-  const schemaIdType = schemaIdTypes.length === 0 ? 'string' : schemaIdTypes.map(type => `'${type}'`).join(' | ')
-
-  globalTypesImports.push(`
-declare module 'fastify' {
-  interface FastifyInstance {
-    getSchema<T extends ${schemaIdType}>(schemaId: T): {
-      '$id': string,
-      title: string,
-      description: string,
-      type: string,
-      properties: {
-        [x in keyof EntityTypes[T]]: { type: string, nullable?: boolean }
-      },
-      required: string[]
-    };
-  }
-}`)
-
-  return GLOBAL_TYPES_TEMPLATE.replace('ENTITIES_IMPORTS_PLACEHOLDER', globalTypesImports.join('\n'))
-    .replace('ENTITIES_DEFINITION_PLACEHOLDER', globalTypesInterface.join('\n    '))
-    .replace('HOOKS_DEFINITION_PLACEHOLDER', globalHooks.join('\n    '))
-}
-
-async function writeFileIfChanged (filename, content) {
-  const isFileExists = await isFileAccessible(filename)
-  if (isFileExists) {
-    const fileContent = await readFile(filename, 'utf-8')
-    if (fileContent === content) return false
-  }
-  await writeFile(filename, content)
-  return true
-}
-
-async function execute ({ logger, config, configManager }) {
-  const wrap = await setupDB(logger, config.db)
-  const { db, entities } = wrap
-  if (Object.keys(entities).length === 0) {
-    // do not generate types if no schema is found
-    return 0
-  }
-
-  const servicePath = configManager.dirname
-  const typesFolderPath = getTypesFolderPath(servicePath, config)
-
-  const isTypeFolderExists = await isFileAccessible(typesFolderPath)
-  if (isTypeFolderExists) {
-    await removeUnusedTypeFiles(entities, typesFolderPath)
-  } else {
-    await createDirectory(typesFolderPath)
-  }
-
-  let count = 0
-  const entitiesValues = Object.values(entities)
-  const entitiesNames = entitiesValues.map(({ name }) => name).sort()
-  for (const entity of entitiesValues) {
-    count++
-    const types = await generateEntityType(entity)
-
-    const pathToFile = join(typesFolderPath, entity.name + '.d.ts')
-    const isTypeChanged = await writeFileIfChanged(pathToFile, types)
-
-    if (isTypeChanged) {
-      logger.info(`Generated type for ${entity.name} entity.`)
-    }
-  }
-  const pathToFile = join(typesFolderPath, 'index.d.ts')
-  // maybe better to check here for changes
-  const content = await generateEntityGroupExport(entitiesNames)
-  const isTypeChanged = await writeFileIfChanged(pathToFile, content)
-  if (isTypeChanged) {
-    logger.info('Regenerating global.d.ts')
-  }
-
-  const globalTypes = await generateGlobalTypes(entities, config)
-  const globalTypesFilePath = join(servicePath, 'global.d.ts')
-  await writeFileIfChanged(globalTypesFilePath, globalTypes)
-
-  await db.dispose()
-  return count
-}
-
-async function generateTypes (_args) {
-  const logger = pino(
-    pretty({
-      translateTime: 'SYS:HH:MM:ss',
-      ignore: 'hostname,pid',
-    })
-  )
-
-  const { configManager, args } = await loadConfig({}, _args, platformaticDB)
-
-  await configManager.parseAndValidate()
-  const config = configManager.current
-
-  const count = await execute({ logger, config, configManager })
-  if (count === 0) {
-    logger.warn('No entities found in your schema. Types were NOT generated.')
-    logger.warn('Please run `platformatic db migrations apply` to generate types.')
-  }
-  await checkForDependencies(logger, args, createRequire(import.meta.url), config, ['@platformatic/db'])
-}
-
-export { execute, generateTypes }

package/lib/generator/README.md

@@ -1,38 +0,0 @@
-# Platformatic DB API
-
-This is a generated [Platformatic DB](https://docs.platformatic.dev/docs/db/overview) application.
-
-## Requirements
-
-Platformatic supports macOS, Linux and Windows ([WSL](https://docs.microsoft.com/windows/wsl/) recommended).
-You'll need to have [Node.js](https://nodejs.org/) >= v18.8.0 or >= v20.6.0
-
-## Setup
-
-1. Install dependencies:
-
-```bash
-npm install
-```
-
-2. Apply migrations:
-
-```bash
-npm run migrate
-```
-
-
-## Usage
-
-Run the API with:
-
-```bash
-npm start
-```
-
-### Explore
-- ⚡ The Platformatic DB server is running at http://localhost:3042/
-- 📔 View the REST API's Swagger documentation at http://localhost:3042/documentation/
-- 🔍 Try out the GraphiQL web UI at http://localhost:3042/graphiql
-
-

package/lib/generator/db-generator.js

@@ -1,260 +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')}}`,
-      }
-    }
-
-    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,81 +0,0 @@
-#! /usr/bin/env node
-
-import { Migrator } from './migrator.mjs'
-import pino from 'pino'
-import pretty from 'pino-pretty'
-import { checkForDependencies } from '@platformatic/utils'
-import { createRequire } from 'node:module'
-import { execute as generateTypes } from './gen-types.mjs'
-import { utimesSync } from 'fs'
-import { updateSchemaLock } from './utils.js'
-import { loadConfig } from '@platformatic/config'
-import { platformaticDB } from '../index.js'
-import errors from './errors.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 }