@platformatic/db 2.74.3 → 3.0.0-alpha.2

package/lib/stackable.js

@@ -1,38 +1,27 @@
-'use strict'
+import { ServiceStackable } from '@platformatic/service'
+import { platformaticDatabase } from './application.js'
+import { packageJson } from './schema.js'
 
-const { ServiceStackable } = require('@platformatic/service')
+export class DatabaseStackable extends ServiceStackable {
+  constructor (root, config, context) {
+    super(root, config, context)
+    this.type = 'db'
+    this.version = packageJson.version
 
-class DbStackable extends ServiceStackable {
-  constructor (options) {
-    super(options)
-    this.#updateConfig()
+    this.applicationFactory = this.context.applicationFactory ?? platformaticDatabase
   }
 
-  #updateConfig () {
-    if (!this.context) return
+  updateContext (context) {
+    super.updateContext(context)
 
-    const { isProduction } = this.context
-    const config = this.configManager.current
-
-    if (isProduction) {
-      if (config.autogenerate) {
-        config.autogenerate = false
-      }
+    if (this.context.isProduction && this.config.autogenerate) {
+      this.config.autogenerate = false
     }
-
-    this.configManager.update(config)
   }
 
   async getMeta () {
-    await this.init()
-    await this.app.ready()
-
     const serviceMeta = await super.getMeta()
-
-    const config = this.configManager.current
-
-    const dbConfig = config.db
-    const connectionString = dbConfig?.connectionString
+    const connectionString = this.config.db?.connectionString
 
     if (connectionString) {
       return {
@@ -44,4 +33,3 @@ class DbStackable extends ServiceStackable {
     return serviceMeta
   }
 }
-module.exports = { DbStackable }

package/lib/{generator/code-templates.js → templates.js}

@@ -1,6 +1,4 @@
-'use strict'
-
-const jsHelperSqlite = {
+export const jsHelperSqlite = {
   requires: `
 const os = require('node:os')
 const path = require('node:path')
@@ -21,10 +19,10 @@ let counter = 0
   t.after(async () => {
     await fs.unlink(dbPath)
   })
-`,
+`
 }
 
-function jsHelperPostgres (connectionString) {
+export function jsHelperPostgres (connectionString) {
   return {
     // TODO(mcollina): replace sql-mapper
     requires: `
@@ -62,11 +60,11 @@ let counter = 0
     \`)
     await db.dispose()
   })
-`,
+`
   }
 }
 
-function jsHelperMySQL (connectionString) {
+export function jsHelperMySQL (connectionString) {
   return {
     // TODO(mcollina): replace sql-mapper
     requires: `
@@ -104,11 +102,11 @@ let counter = 0
     \`)
     await db.dispose()
   })
-`,
+`
   }
 }
 
-const moviesTestJS = `\
+export const moviesTestJS = `\
 'use strict'
 
 const test = require('node:test')
@@ -160,7 +158,7 @@ test('movies', async (t) => {
 })
 `
 
-const moviesTestTS = `\
+export const moviesTestTS = `\
 import test from 'node:test'
 import assert from 'node:assert'
 import { getServer } from '../helper'
@@ -210,10 +208,53 @@ test('movies', async (t) => {
 })
 `
 
-module.exports = {
-  jsHelperMySQL,
-  jsHelperPostgres,
-  jsHelperSqlite,
-  moviesTestJS,
-  moviesTestTS,
+export const README = `
+# 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
+
+`
+
+export const ENVIRONMENT_TEMPLATE = `
+import { type FastifyInstance } from 'fastify'
+import { PlatformaticApplication, PlatformaticDatabaseConfig, PlatformaticDatabaseMixin, Entities } from '@platformatic/db'
+
+declare module 'fastify' {
+  interface FastifyInstance {
+    platformatic: PlatformaticApplication<PlatformaticDatabaseConfig> & PlatformaticDatabaseMixin<Entities>
+  }
 }
+`

package/lib/types.js

@@ -0,0 +1,160 @@
+import { createDirectory, isFileAccessible } from '@platformatic/foundation'
+import { mapOpenAPItoTypes, mapSQLEntityToJSONSchema } from '@platformatic/sql-json-schema-mapper'
+import camelcase from 'camelcase'
+import { readFile, readdir, unlink, writeFile } from 'node:fs/promises'
+import { basename, join, relative, resolve, sep } from 'node:path'
+import { setupDB } from './utils.js'
+
+async function removeUnusedTypeFiles (entities, dir) {
+  const entityTypes = await readdir(dir)
+  const entityNames = Object.keys(entities)
+  const removedEntityNames = entityTypes.filter(
+    file => file !== 'index.d.ts' && !entityNames.includes(basename(file, '.d.ts'))
+  )
+  await Promise.all(removedEntityNames.map(file => unlink(join(dir, file))))
+}
+
+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, { indentSpaces: 2 })
+
+  entity.name = camelcase(entity.name).replace(/^\w/, c => c.toUpperCase())
+  return tsCode.replaceAll(/^declare interface/gm, 'export interface')
+}
+
+async function generateIndexTypes (entities) {
+  const allImports = []
+  const allExports = []
+  const entityMembers = []
+  const entityTypesMembers = []
+  const entitiesHooks = []
+  const schemaGetters = []
+
+  const values = Object.entries(entities)
+    .map(([file, entity]) => [file, entity.name])
+    .sort((a, b) => a[0].localeCompare(b[0]))
+
+  for (const [name, type] of values) {
+    allImports.push(`import { ${type} } from './${name}'`)
+    allExports.push(`export { ${type} } from './${name}'`)
+    entityMembers.push(`  ${name}: Entity<${type}>`)
+    entityTypesMembers.push(`  ${name}: ${type}`)
+    entitiesHooks.push(`  addEntityHooks(entityName: '${name}', hooks: EntityHooks<${type}>): any`)
+    schemaGetters.push(`getSchema(schemaId: '${name}'): {
+    '$id': string,
+    title: string,
+    description: string,
+    type: string,
+    properties: { [x in keyof ${type}]: { type: string, nullable?: boolean } },
+    required: string[]
+  }`)
+  }
+
+  const content = `import { Entity, EntityHooks, Entities as DatabaseEntities, PlatformaticDatabaseConfig, PlatformaticDatabaseMixin } from '@platformatic/db'
+import { PlatformaticApplication, PlatformaticServiceConfig } from '@platformatic/service'
+import { type FastifyInstance } from 'fastify'
+
+${allImports.join('\n')}
+
+${allExports.join('\n')}
+
+export interface Entities extends DatabaseEntities {
+${entityMembers.join('\n')}
+}
+
+export interface EntityTypes {
+${entityTypesMembers.join('\n')}
+}
+
+export interface EntitiesHooks {
+${entitiesHooks.join('\n')}
+}
+
+export interface SchemaGetters {
+  ${schemaGetters.join('\n\n')}
+}
+
+export type ServerInstance<Configuration = PlatformaticDatabaseConfig> = FastifyInstance & {
+  platformatic: PlatformaticApplication<Configuration> & PlatformaticDatabaseMixin<Entities> & EntitiesHooks & SchemaGetters
+}
+`
+
+  return content
+}
+
+function generateEnvironmentTypes (folder) {
+  return `import { PlatformaticApplication, PlatformaticDatabaseConfig, PlatformaticDatabaseMixin } from "@platformatic/db";
+import { Entities, EntitiesHooks, SchemaGetters } from "./${folder.replaceAll(sep, '/')}/index.js";
+
+declare module "fastify" {
+  interface FastifyInstance {
+    platformatic: PlatformaticApplication<PlatformaticDatabaseConfig> & PlatformaticDatabaseMixin<Entities> & EntitiesHooks & SchemaGetters;
+  }
+}
+`
+}
+
+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
+}
+
+export async function execute ({ logger, config }) {
+  const wrap = await setupDB(logger, config.db)
+  const { db, entities } = wrap
+
+  const count = Object.keys(entities).length
+  if (count === 0) {
+    // do not generate types if no schema is found
+    return 0
+  }
+
+  const typesFolderPath = resolve(process.cwd(), config.types?.dir ?? 'types')
+
+  // Prepare the types folder
+  if (await isFileAccessible(typesFolderPath)) {
+    await removeUnusedTypeFiles(entities, typesFolderPath)
+  } else {
+    await createDirectory(typesFolderPath)
+  }
+
+  // Generate all entities
+  for (const [name, entity] of Object.entries(entities)) {
+    const types = await generateEntityType(entity)
+    const pathToFile = join(typesFolderPath, name + '.d.ts')
+
+    if (await writeFileIfChanged(pathToFile, types)) {
+      logger.info(`Generated type for ${entity.name} entity.`)
+    }
+  }
+
+  // Generate index.d.ts
+  const indexFilePath = join(typesFolderPath, 'index.d.ts')
+  const indexTypes = await generateIndexTypes(entities)
+  if (await writeFileIfChanged(indexFilePath, indexTypes)) {
+    logger.info('Regenerated index.d.ts.')
+  }
+
+  // Generate plt-env.d.ts
+  const environmentPath = join(process.cwd(), 'plt-env.d.ts')
+  const pltEnvironment = await generateEnvironmentTypes(relative(process.cwd(), typesFolderPath))
+  if (await writeFileIfChanged(environmentPath, pltEnvironment)) {
+    logger.info('Regenerated plt-env.d.ts.')
+  }
+
+  await db.dispose()
+  return count
+}

package/lib/upgrade.js

@@ -1,16 +1,12 @@
-'use strict'
+import { abstractLogger } from '@platformatic/foundation'
+import zeroSixteen from '@platformatic/service/lib/versions/0.16.0.js'
+import { join } from 'node:path'
+import { loadMigrationsFromPath, semgrator } from 'semgrator'
 
-const { join } = require('path')
-const zeroSixteen = require('@platformatic/service/lib/versions/0.16.0.js')
+export async function upgrade (logger, config, version) {
+  const iterator = loadMigrationsFromPath(join(import.meta.dirname, 'versions'))
 
-module.exports = async function upgrade (config, version) {
-  const { semgrator, loadMigrationsFromPath } = await import('semgrator')
-
-  const iterator = loadMigrationsFromPath(join(__dirname, 'versions'))
-
-  const migrations = [
-    zeroSixteen,
-  ]
+  const migrations = [zeroSixteen]
 
   for await (const migration of iterator) {
     migrations.push(migration)
@@ -20,7 +16,7 @@ module.exports = async function upgrade (config, version) {
     version,
     migrations,
     input: config,
-    logger: this.logger.child({ name: '@platformatic/db' }),
+    logger: logger?.child({ name: '@platformatic/db' }) ?? abstractLogger
   })
 
   let result

package/lib/utils.js

@@ -1,45 +1,34 @@
-'use strict'
+import { connect } from '@platformatic/db-core'
+import { kMetadata } from '@platformatic/foundation'
+import fs from 'node:fs/promises'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
 
-const { connect } = require('@platformatic/db-core')
-const { join, dirname } = require('path')
-const { fileURLToPath } = require('url')
-const fs = require('fs/promises')
-const { isFileAccessible } = require('@platformatic/utils')
-
-async function setupDB (log, config) {
+export async function setupDB (log, config) {
   const { db, sql, entities, dbschema } = await connect({ ...config, log })
 
   return {
     db,
     sql,
     entities,
-    dbschema,
+    dbschema
   }
 }
 
-function urlDirname (url) {
+export function urlDirname (url) {
   return dirname(fileURLToPath(url))
 }
 
-function locateSchemaLock (configManager) {
-  return configManager.current.db.schemalock.path ?? join(configManager.dirname, 'schema.lock')
+export function locateSchemaLock (config) {
+  return config.db.schemalock.path ?? join(config[kMetadata].root, 'schema.lock')
 }
 
-async function updateSchemaLock (logger, configManager) {
-  const config = configManager.current
+export async function updateSchemaLock (logger, config) {
   if (config.db.schemalock) {
     const conn = await setupDB(logger, { ...config.db, dbschema: null })
-    const schemaLockPath = locateSchemaLock(configManager)
+    const schemaLockPath = locateSchemaLock(config)
     await fs.writeFile(schemaLockPath, JSON.stringify(conn.dbschema, null, 2))
 
     await conn.db.dispose()
   }
 }
-
-module.exports = {
-  setupDB,
-  isFileAccessible,
-  urlDirname,
-  updateSchemaLock,
-  locateSchemaLock,
-}

package/lib/versions/0.18.0.js

@@ -1,10 +1,8 @@
-'use strict'
-
-module.exports = {
+export default {
   version: '0.18.0',
-  up: function (config) {
+  up (config) {
     config.db = config.core
     delete config.core
     return config
-  },
+  }
 }

package/lib/versions/{from-zero-twenty-height-to-will-see.js → 0.28.0.js}

@@ -1,8 +1,6 @@
-'use strict'
-
-module.exports.migration = {
+export default {
   version: '0.28.0',
-  up: function (config) {
+  up (config) {
     if (config.watch !== false) {
       config.watch = typeof config.watch === 'object' ? config.watch : {}
 
@@ -15,5 +13,5 @@ module.exports.migration = {
     delete config.db?.dashboard
 
     return config
-  },
+  }
 }

package/lib/versions/2.0.0.js

@@ -1,11 +1,9 @@
-'use strict'
+import { version } from '../schema.js'
 
-const pkg = require('../../package.json')
-
-module.exports = {
+export default {
   version: '2.0.0',
   up: function (config) {
-    config.$schema = `https://schemas.platformatic.dev/@platformatic/db/${pkg.version}.json`
+    config.$schema = `https://schemas.platformatic.dev/@platformatic/db/${version}.json`
     return config
   }
 }

package/lib/versions/3.0.0.js

@@ -0,0 +1,14 @@
+export default {
+  version: '2.99.0',
+  up (config) {
+    if (typeof config.plugins?.typescript !== 'undefined') {
+      delete config.plugins.typescript
+    }
+
+    if (typeof config.clients !== 'undefined') {
+      delete config.clients
+    }
+
+    return config
+  }
+}

package/package.json

@@ -1,12 +1,10 @@
 {
   "name": "@platformatic/db",
-  "version": "2.74.3",
+  "version": "3.0.0-alpha.2",
   "description": "",
   "main": "index.js",
   "types": "index.d.ts",
-  "bin": {
-    "plt-db": "./db.mjs"
-  },
+  "type": "module",
   "author": "Platformatic Inc. <oss@platformatic.dev> (https://platformatic.dev)",
   "repository": {
     "type": "git",
@@ -20,8 +18,7 @@
   "devDependencies": {
     "@databases/pg": "^5.5.0",
     "@databases/sql": "^3.3.0",
-    "@opentelemetry/api": "^1.8.0",
-    "@matteo.collina/snap": "^0.3.0",
+    "@opentelemetry/api": "^1.9.0",
     "ajv": "^8.12.0",
     "bindings": "^1.5.0",
     "borp": "^0.20.0",
@@ -33,7 +30,6 @@
     "neostandard": "^0.12.0",
     "openapi-types": "^12.1.3",
     "split2": "^4.2.0",
-    "strip-ansi": "^7.1.0",
     "tsd": "^0.32.0",
     "typescript": "^5.5.4",
     "undici": "^7.0.0",
@@ -52,11 +48,8 @@
     "camelcase": "^6.3.0",
     "close-with-grace": "^2.0.0",
     "code-block-writer": "^13.0.1",
-    "commist": "^3.2.0",
     "console-table-printer": "^2.12.0",
-    "desm": "^1.3.1",
     "env-schema": "^6.0.0",
-    "es-main": "^1.3.0",
     "execa": "^9.0.0",
     "fastify": "^5.0.0",
     "fastify-metrics": "^12.0.0",
@@ -67,31 +60,30 @@
     "minimist": "^1.2.8",
     "my-ua-parser": "^2.0.2",
     "ora": "^6.3.1",
-    "pino": "^9.0.0",
+    "pino": "^9.9.0",
     "pino-pretty": "^13.0.0",
     "postgrator": "^8.0.0",
     "rfdc": "^1.3.1",
     "rimraf": "^4.4.1",
     "semgrator": "^0.3.0",
-    "@platformatic/config": "2.74.3",
-    "@platformatic/db-authorization": "2.74.3",
-    "@platformatic/db-core": "2.74.3",
-    "@platformatic/generators": "2.74.3",
-    "@platformatic/service": "2.74.3",
-    "@platformatic/sql-graphql": "2.74.3",
-    "@platformatic/sql-json-schema-mapper": "2.74.3",
-    "@platformatic/sql-mapper": "2.74.3",
-    "@platformatic/sql-events": "2.74.3",
-    "@platformatic/sql-openapi": "2.74.3",
-    "@platformatic/telemetry": "2.74.3",
-    "@platformatic/ts-compiler": "2.74.3",
-    "@platformatic/utils": "2.74.3"
+    "@platformatic/db-authorization": "3.0.0-alpha.2",
+    "@platformatic/db-core": "3.0.0-alpha.2",
+    "@platformatic/generators": "3.0.0-alpha.2",
+    "@platformatic/sql-events": "3.0.0-alpha.2",
+    "@platformatic/sql-graphql": "3.0.0-alpha.2",
+    "@platformatic/service": "3.0.0-alpha.2",
+    "@platformatic/basic": "3.0.0-alpha.2",
+    "@platformatic/sql-mapper": "3.0.0-alpha.2",
+    "@platformatic/sql-openapi": "3.0.0-alpha.2",
+    "@platformatic/sql-json-schema-mapper": "3.0.0-alpha.2",
+    "@platformatic/telemetry": "3.0.0-alpha.2",
+    "@platformatic/foundation": "3.0.0-alpha.2"
+  },
+  "engines": {
+    "node": ">=22.18.0"
   },
   "scripts": {
-    "test": "pnpm run lint && borp -T --concurrency=1 --timeout=1200000 && tsd ",
-    "test:postgresql": "DB=postgresql borp -T --concurrency=1 --timeout=1200000",
-    "test:mariadb": "DB=mariadb borp -T --concurrency=1 --timeout=1200000",
-    "test:mysql": "DB=mysql borp -T --concurrency=1 --timeout=1200000",
+    "test": "pnpm run lint && borp -T --concurrency=1 --timeout 1200000",
     "gen-schema": "node lib/schema.js > schema.json",
     "gen-types": "json2ts > config.d.ts < schema.json",
     "build": "pnpm run gen-schema && pnpm run gen-types",