@platformatic/db 2.71.1-alpha.0 → 3.0.0-alpha.1

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.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 }