@platformatic/db 2.74.3 → 3.0.0-alpha.2

package/index.test-d.ts

@@ -1,43 +0,0 @@
-import { buildServer, PlatformaticApp, PlatformaticDBMixin, PlatformaticDBConfig, Entities, errors } from '.'
-import ConfigManager from '@platformatic/config'
-import type { Database } from '@platformatic/sql-mapper'
-import { SQL } from '@databases/sql'
-import { expectType } from 'tsd'
-import { OpenAPI } from 'openapi-types'
-import type { MercuriusPlugin } from 'mercurius'
-import { FastifyError } from '@fastify/error'
-
-declare module 'fastify' {
-  interface FastifyInstance {
-    platformatic: PlatformaticApp<PlatformaticDBConfig> & PlatformaticDBMixin<Entities>
-  }
-}
-
-async function main (): Promise<void> {
-  // TODO this configuration is incomplete, type it fully
-  const server = await buildServer({
-    server: {
-      port: 3042,
-      host: '127.0.0.1',
-    },
-  })
-
-  expectType<Database>(server.platformatic.db)
-  expectType<SQL>(server.platformatic.sql)
-  expectType<ConfigManager<PlatformaticDBConfig>>(server.platformatic.configManager)
-  expectType<PlatformaticDBConfig>(server.platformatic.config)
-  expectType<OpenAPI.Document>(server.swagger())
-  expectType<MercuriusPlugin>(server.graphql)
-}
-
-main().catch(console.error)
-
-// Errors
-type ErrorWithNoParams = () => FastifyError
-type ErrorWithOneParam = (param: string) => FastifyError
-
-expectType<ErrorWithNoParams>(errors.MigrateMissingMigrationsError)
-expectType<ErrorWithNoParams>(errors.UnknownDatabaseError)
-expectType<ErrorWithOneParam>(errors.MigrateMissingMigrationsDirError)
-expectType<ErrorWithNoParams>(errors.MissingSeedFileError)
-expectType<ErrorWithNoParams>(errors.MigrationsToApplyError)

package/lib/adjust-config.js

@@ -1,42 +0,0 @@
-'use strict'
-const { resolve } = require('path')
-const { readFile } = require('fs/promises')
-const { platformaticService } = require('@platformatic/service')
-
-module.exports = async function adjustConfig (configManager) {
-  await platformaticService.configManagerConfig.transformConfig.call(configManager)
-
-  const dirOfConfig = configManager.dirname
-  if (configManager.current.db && configManager.current.db.connectionString.indexOf('sqlite') === 0 && configManager.current.db.connectionString !== 'sqlite://:memory:') {
-    const originalSqlitePath = configManager.current.db.connectionString.replace('sqlite://', '')
-    const sqliteFullPath = resolve(dirOfConfig, originalSqlitePath)
-    configManager.current.db.connectionString = 'sqlite://' + sqliteFullPath
-  }
-
-  /* c8 ignore next 3 */
-  if (configManager.current.db.graphql?.schemaPath) {
-    configManager.current.db.graphql.schema = await readFile(configManager.current.db.graphql.schemaPath, 'utf8')
-  }
-
-  /* c8 ignore next 2 */
-  const arePostgresqlSchemaDefined = configManager.current.db?.connectionString.indexOf('postgres') === 0 && configManager.current.db?.schema?.length > 0
-  const migrationsTableName = arePostgresqlSchemaDefined ? 'public.versions' : 'versions'
-
-  // relative-to-absolute migrations path
-  if (configManager.current.migrations) {
-    configManager.current.migrations.table = configManager.current.migrations.table || migrationsTableName
-  }
-
-  if (configManager.current.migrations && configManager.current.db) {
-    // TODO remove the ignores
-    /* c8 ignore next 4 */
-    configManager.current.db.ignore = configManager.current.db.ignore || {}
-    configManager.current.db.ignore = Object.assign({}, {
-      [configManager.current.migrations.table || migrationsTableName]: true,
-    }, configManager.current.db.ignore)
-  }
-
-  if (configManager.current.types?.autogenerate === 'true') {
-    configManager.current.types.autogenerate = true
-  }
-}

package/lib/create.mjs

@@ -1,89 +0,0 @@
-'use strict'
-import minimist from 'minimist'
-import { Generator } from '../lib/generator/db-generator.js'
-import { join } from 'node:path'
-import { getPkgManager } from '@platformatic/utils'
-import { execa } from 'execa'
-import ora from 'ora'
-import { Table } from 'console-table-printer'
-import pino from 'pino'
-import pinoPretty from 'pino-pretty'
-
-function printAppSummary (args, logger) {
-  logger.info('Creating a Platformatic DB app with this config: ')
-  const table = [
-    { config: 'Directory', value: args.dir },
-    { config: 'Connection String', value: args.connectionString },
-    { config: 'Language', value: args.typescript ? 'Typescript' : 'Javascript' },
-    { config: 'Init Git Repository', value: args.git },
-    { config: 'Install Dependencies', value: args.install },
-    { config: 'Sample Plugin and Tests', value: args.plugin },
-    { config: 'Create Sample Migrations', value: args.migrations },
-  ]
-
-  const p = new Table({
-    columns: [
-      { name: 'config', alignment: 'right' },
-      { name: 'value', alignment: 'left' },
-    ],
-  })
-
-  p.addRows(table)
-  p.printTable()
-}
-async function createDB (_args) {
-  const stream = pinoPretty({
-    translateTime: 'SYS:HH:MM:ss',
-    ignore: 'hostname,pid',
-    minimumLevel: 'debug',
-    sync: true,
-  })
-
-  const logger = pino(stream)
-
-  const args = minimist(process.argv.slice(2), {
-    string: ['dir', 'port', 'hostname', 'connectionString'],
-    boolean: ['typescript', 'install', 'migrations', 'plugin', 'git'],
-    default: {
-      dir: join(process.cwd(), 'platformatic-db'),
-      port: 3042,
-      hostname: '0.0.0.0',
-      plugin: true,
-      typescript: false,
-      git: false,
-      install: true,
-      migrations: true,
-      connectionString: 'sqlite://./db.sqlite',
-    },
-
-  })
-
-  printAppSummary(args, logger)
-
-  const gen = new Generator({})
-  gen.setConfig({
-    port: args.port,
-    hostname: args.hostname,
-    plugin: args.plugin,
-    tests: args.plugin,
-    typescript: args.typescript,
-    initGitRepository: args.git,
-    targetDirectory: args.dir,
-  })
-
-  try {
-    await gen.run()
-    if (args.install) {
-      const pkgManager = getPkgManager()
-      const spinner = ora('Installing dependencies...').start()
-      await execa(pkgManager, ['install'], { cwd: args.dir })
-      spinner.succeed()
-    }
-
-    logger.info('Done! 🎉')
-  } catch (err) {
-    logger.error(err.message)
-  }
-}
-
-export { createDB }

package/lib/gen-migration.mjs

@@ -1,53 +0,0 @@
-import { join } from 'path'
-import { writeFile } from 'fs/promises'
-import pino from 'pino'
-import pretty from 'pino-pretty'
-import { loadConfig } from '@platformatic/config'
-import { Migrator } from './migrator.mjs'
-import { platformaticDB } from '../index.js'
-import errors from './errors.js'
-
-async function generateMigration (_args) {
-  const logger = pino(pretty({
-    translateTime: 'SYS:HH:MM:ss',
-    ignore: 'hostname,pid',
-  }))
-
-  const { configManager } = await loadConfig({}, _args, platformaticDB)
-  await configManager.parseAndValidate()
-  const config = configManager.current
-
-  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({ do: doFile, undo: undoFile }, 'Created migration files')
-  } catch (error) {
-    logger.error(error.message)
-  } finally {
-    if (migrator !== null) {
-      await migrator.close()
-    }
-  }
-}
-
-export { generateMigration }

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