@platformatic/db 3.4.1 → 3.5.0

package/lib/schema.js

@@ -1,11 +1,22 @@
 #! /usr/bin/env node
-'use strict'
 
-const { metrics, server, plugins, watch, openApiDefs, openApiBase, clients } = require('@platformatic/service').schemas
-const telemetry = require('@platformatic/telemetry').schema
-const pkg = require('../package.json')
+import { schemaComponents as basicSchemaComponents } from '@platformatic/basic'
+import {
+  fastifyServer as server,
+  schemaComponents as utilsSchemaComponents,
+  watch,
+  wrappedRuntime
+} from '@platformatic/foundation'
+import { schemaComponents as serviceSchemaComponents } from '@platformatic/service'
+import { readFileSync } from 'node:fs'
+import { resolve } from 'node:path'
 
-const db = {
+export const packageJson = JSON.parse(readFileSync(resolve(import.meta.dirname, '../package.json'), 'utf8'))
+export const version = packageJson.version
+
+const { plugins, openApiBase, $defs } = serviceSchemaComponents
+
+export const db = {
   type: 'object',
   properties: {
     connectionString: {
@@ -234,7 +245,7 @@ const db = {
   required: ['connectionString']
 }
 
-const sharedAuthorizationRule = {
+export const sharedAuthorizationRule = {
   role: {
     type: 'string',
     description: 'the role name to match the rule'
@@ -254,10 +265,13 @@ const sharedAuthorizationRule = {
   },
   delete: {
     $ref: '#/$defs/crud-operation-auth'
+  },
+  updateMany: {
+    $ref: '#/$defs/crud-operation-auth'
   }
 }
 
-const authorization = {
+export const authorization = {
   type: 'object',
   properties: {
     adminSecret: {
@@ -363,7 +377,7 @@ const authorization = {
   additionalProperties: false
 }
 
-const migrations = {
+export const migrations = {
   type: 'object',
   properties: {
     dir: {
@@ -406,7 +420,7 @@ const migrations = {
   required: ['dir']
 }
 
-const types = {
+export const types = {
   type: 'object',
   properties: {
     autogenerate: {
@@ -429,10 +443,18 @@ const types = {
   additionalProperties: false
 }
 
-const platformaticDBschema = {
-  $id: `https://schemas.platformatic.dev/@platformatic/db/${pkg.version}.json`,
+export const schemaComponents = {
+  db,
+  sharedAuthorizationRule,
+  authorization,
+  migrations,
+  types
+}
+
+export const schema = {
+  $id: `https://schemas.platformatic.dev/@platformatic/db/${packageJson.version}.json`,
   $schema: 'http://json-schema.org/draft-07/schema#',
-  title: 'Platformatic DB',
+  title: 'Platformatic Database Config',
   type: 'object',
   properties: {
     basePath: {
@@ -451,11 +473,11 @@ const platformaticDBschema = {
     db,
     authorization,
     migrations,
-    metrics,
     types,
     plugins,
-    telemetry,
-    clients,
+    application: basicSchemaComponents.application,
+    telemetry: utilsSchemaComponents.telemetry,
+    runtime: wrappedRuntime,
     watch: {
       anyOf: [
         watch,
@@ -477,7 +499,7 @@ const platformaticDBschema = {
   additionalProperties: false,
   required: ['db'],
   $defs: {
-    ...openApiDefs,
+    ...$defs,
     'crud-operation-auth': {
       oneOf: [
         {
@@ -529,8 +551,7 @@ const platformaticDBschema = {
   }
 }
 
-module.exports.schema = platformaticDBschema
-
-if (require.main === module) {
-  console.log(JSON.stringify(platformaticDBschema, null, 2))
+/* c8 ignore next 3 */
+if (process.argv[1] === import.meta.filename) {
+  console.log(JSON.stringify(schema, null, 2))
 }

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,161 @@
+import { createDirectory, isFileAccessible, kMetadata } 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 root = config[kMetadata].root
+  const typesFolderPath = resolve(root, 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(root, 'plt-env.d.ts')
+  const pltEnvironment = await generateEnvironmentTypes(relative(root, 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,13 +1,11 @@
 {
   "name": "@platformatic/db",
-  "version": "3.4.1",
+  "version": "3.5.0",
   "description": "",
   "main": "index.js",
   "types": "index.d.ts",
-  "bin": {
-    "plt-db": "./db.mjs"
-  },
-  "author": "Matteo Collina <hello@matteocollina.com>",
+  "type": "module",
+  "author": "Platformatic Inc. <oss@platformatic.dev> (https://platformatic.dev)",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/platformatic/platformatic.git"
@@ -20,22 +18,21 @@
   "devDependencies": {
     "@databases/pg": "^5.5.0",
     "@databases/sql": "^3.3.0",
-    "@opentelemetry/api": "^1.8.0",
+    "@opentelemetry/api": "^1.9.0",
     "ajv": "^8.12.0",
     "bindings": "^1.5.0",
-    "borp": "^0.17.0",
     "c8": "^10.0.0",
+    "cleaner-spec-reporter": "^0.5.0",
     "eslint": "9",
-    "execa": "^8.0.1",
+    "execa": "^9.0.0",
     "json-schema-to-typescript": "^15.0.0",
-    "mercurius": "^15.0.0",
-    "neostandard": "^0.11.1",
+    "mercurius": "^16.0.0",
+    "neostandard": "^0.12.0",
     "openapi-types": "^12.1.3",
     "split2": "^4.2.0",
-    "strip-ansi": "^7.1.0",
-    "tsd": "^0.31.0",
+    "tsd": "^0.33.0",
     "typescript": "^5.5.4",
-    "undici": "^6.9.0",
+    "undici": "^7.0.0",
     "vscode-json-languageservice": "^5.3.9",
     "why-is-node-running": "^2.2.2",
     "yaml": "^2.4.1"
@@ -51,49 +48,44 @@
     "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": "^5.2.1",
-    "es-main": "^1.3.0",
-    "execa": "^8.0.1",
+    "env-schema": "^6.0.0",
+    "execa": "^9.0.0",
     "fastify": "^5.0.0",
     "fastify-metrics": "^12.0.0",
     "fastify-plugin": "^5.0.0",
-    "fastify-print-routes": "^3.1.1",
+    "fastify-print-routes": "^4.0.0",
     "graphql": "^16.8.1",
     "help-me": "^5.0.0",
     "minimist": "^1.2.8",
     "my-ua-parser": "^2.0.2",
     "ora": "^6.3.1",
-    "pino": "^8.19.0",
-    "pino-pretty": "^11.0.0",
-    "postgrator": "^7.2.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": "3.4.1",
-    "@platformatic/db-authorization": "3.4.1",
-    "@platformatic/generators": "3.4.1",
-    "@platformatic/sql-events": "3.4.1",
-    "@platformatic/service": "3.4.1",
-    "@platformatic/sql-graphql": "3.4.1",
-    "@platformatic/sql-json-schema-mapper": "3.4.1",
-    "@platformatic/sql-mapper": "3.4.1",
-    "@platformatic/telemetry": "3.4.1",
-    "@platformatic/ts-compiler": "3.4.1",
-    "@platformatic/utils": "3.4.1",
-    "@platformatic/db-core": "3.4.1",
-    "@platformatic/sql-openapi": "3.4.1"
+    "@platformatic/basic": "3.5.0",
+    "@platformatic/db-authorization": "3.5.0",
+    "@platformatic/db-core": "3.5.0",
+    "@platformatic/foundation": "3.5.0",
+    "@platformatic/service": "3.5.0",
+    "@platformatic/sql-events": "3.5.0",
+    "@platformatic/sql-graphql": "3.5.0",
+    "@platformatic/sql-json-schema-mapper": "3.5.0",
+    "@platformatic/sql-mapper": "3.5.0",
+    "@platformatic/telemetry": "3.5.0",
+    "@platformatic/sql-openapi": "3.5.0"
+  },
+  "engines": {
+    "node": ">=22.19.0"
   },
   "scripts": {
-    "test": "pnpm run lint && borp -T --concurrency=1 --timeout=180000 && tsd ",
-    "test:postgresql": "DB=postgresql borp -T --concurrency=1 --timeout=180000",
-    "test:mariadb": "DB=mariadb borp -T --concurrency=1 --timeout=180000",
-    "test:mysql": "DB=mysql borp -T --concurrency=1 --timeout=180000",
+    "test": "node --test --test-reporter=cleaner-spec-reporter --test-concurrency=1 --test-timeout=2000000 test/*.test.js test/**/*.test.js",
     "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",
+    "build": "npm run gen-schema && npm run gen-types",
     "lint": "eslint"
   }
 }