@platformatic/service 1.53.3 → 2.0.0-alpha.10

package/config.d.ts

@@ -61,6 +61,9 @@ export interface PlatformaticService {
           };
           [k: string]: unknown;
         };
+    loggerInstance?: {
+      [k: string]: unknown;
+    };
     serializerOpts?: {
       schema?: {
         [k: string]: unknown;
@@ -151,7 +154,6 @@ export interface PlatformaticService {
         defaultMetrics?: {
           enabled: boolean;
         };
-        prefix?: string;
         auth?: {
           username: string;
           password: string;
@@ -173,6 +175,7 @@ export interface PlatformaticService {
     | boolean
     | string;
   $schema?: string;
+  module?: string;
   service?: {
     openapi?:
       | {
@@ -214,22 +217,6 @@ export interface PlatformaticService {
     fullRequest?: boolean;
     validateResponse?: boolean;
   }[];
-  versions?: {
-    /**
-     * The path to the directory containing the versions mappers
-     */
-    dir: string;
-    configs: {
-      version: string;
-      openapi?: {
-        prefix?: string;
-        path?: string;
-      };
-      plugins?: {
-        [k: string]: unknown;
-      };
-    }[];
-  };
 }
 export interface OpenTelemetry {
   /**

package/eslint.config.js

@@ -0,0 +1,14 @@
+'use strict'
+
+const neostandard = require('neostandard')
+
+module.exports = neostandard({
+  ts: true,
+  ignores: [
+    ...neostandard.resolveIgnoresFromGitignore(),
+    'test/tmp/**/*',
+    'test/fixtures/*/dist/**/*',
+    '**/dist/*',
+    'fixtures/**/*',
+  ],
+})

package/help/help.txt

@@ -6,5 +6,3 @@ Available commands:
 * `start` - start the server.
 * `schema config` - generate the schema configuration file.
 * `compile` - compile the typescript files.
-* `versions bump` - bump a new version of the API.
-* `versions update` - update the latest version of the API.

package/index.d.ts

@@ -1,15 +1,14 @@
-/* eslint-disable @typescript-eslint/triple-slash-reference */
 /// <reference types="mercurius" />
 /// <reference types="@fastify/swagger" />
 import { FastifyInstance, FastifyBaseLogger } from 'fastify'
 import ConfigManager from '@platformatic/config'
-import type { IConfigManagerOptions } from '@platformatic/config'
+import type { ConfigManagerConfig } from '@platformatic/config'
+import type { Stackable as _Stackable, StackableInterface } from '@platformatic/config'
 import { BaseGenerator } from '@platformatic/generators'
 import { PlatformaticService } from './config'
 import type { JSONSchemaType } from 'ajv'
 import { ServiceGenerator } from './lib/generator/service-generator'
 
-/* eslint-disable @typescript-eslint/no-unused-vars */
 export import Generator = ServiceGenerator.ServiceGenerator
 
 export interface PlatformaticApp<T> {
@@ -28,28 +27,16 @@ declare module 'fastify' {
   }
 }
 
-export interface ConfigManagerConfig<T> extends Omit<IConfigManagerOptions, 'source' | 'watch' | 'schema' | 'configVersion'> {
-  transformConfig: (this: ConfigManager<T>) => Promise<void>
-  schema: object
-}
-
-export interface Stackable<ConfigType> {
-  (app: FastifyInstance, opts: object): Promise<void>
-
-  configType: string
-  configManagerConfig: ConfigManagerConfig<ConfigType>
-  schema: object
-  Generator?: new () => BaseGenerator.BaseGenerator
+type DefaultGenerator = new () => BaseGenerator.BaseGenerator
 
+export interface Stackable<ConfigType, Generator = DefaultGenerator> extends _Stackable<ConfigType> {
+  app: (app: FastifyInstance, opts: object) => Promise<void>
+  Generator?: Generator
   version?: string
   upgrade?: (config: any, version: string) => Promise<any>
   transformConfig?: (config: any) => Promise<any>
 }
 
-interface SchemaExport {
-  schema: JSONSchemaType<PlatformaticServiceConfig>
-}
-
 interface TSCompilerOptions {
   clean: boolean
 }
@@ -57,10 +44,22 @@ interface TSCompiler {
   compile: (cwd: string, config: object, originalLogger: FastifyBaseLogger, options: TSCompilerOptions) => Promise<boolean>
 }
 
-export const schema: SchemaExport
+export const schema: JSONSchemaType<PlatformaticServiceConfig>
+export const configManagerConfig: ConfigManagerConfig<PlatformaticServiceConfig>
 
 export declare const platformaticService: Stackable<PlatformaticServiceConfig>
 
-export default platformaticService
+export declare const app: (app: FastifyInstance, opts: object) => Promise<void>
 
 export const tsCompiler: TSCompiler
+
+type defaultExport = Stackable<PlatformaticServiceConfig> & {
+  buildServer: (opts: object, app?: object, ConfigManagerConstructor?: object) => Promise<FastifyInstance>,
+  start: <ConfigType>(app: Stackable<ConfigType>, args: string[]) => Promise<void>,
+  tsCompiler: TSCompiler,
+  schema: JSONSchemaType<PlatformaticServiceConfig>,
+}
+
+export function buildStackable (opts: { config: string }, app?: object): Promise<StackableInterface>
+
+export default defaultExport

package/index.js

@@ -1,10 +1,10 @@
 'use strict'
 
 const { isKeyEnabled } = require('@platformatic/utils')
+const { loadConfig, ConfigManager } = require('@platformatic/config')
 const { readFile } = require('fs/promises')
 const { join } = require('path')
 
-const compiler = require('./lib/compile')
 const setupCors = require('./lib/plugins/cors')
 const setupOpenAPI = require('./lib/plugins/openapi.js')
 const setupGraphQL = require('./lib/plugins/graphql.js')
@@ -13,14 +13,15 @@ const setupMetrics = require('./lib/plugins/metrics')
 const setupTsCompiler = require('./lib/plugins/typescript')
 const setupHealthCheck = require('./lib/plugins/health-check')
 const loadPlugins = require('./lib/plugins/plugins')
-const loadVersions = require('./lib/plugins/versions')
 const upgrade = require('./lib/upgrade')
 const { telemetry } = require('@platformatic/telemetry')
 
+const { buildCompileCmd, extractTypeScriptCompileOptionsFromConfig } = require('./lib/compile')
 const { schema } = require('./lib/schema')
 const { addLoggerToTheConfig } = require('./lib/utils')
 const { start, buildServer } = require('./lib/start')
 const ServiceGenerator = require('./lib/generator/service-generator.js')
+const { ServiceStackable } = require('./lib/stackable')
 
 const { version } = require('./package.json')
 
@@ -40,7 +41,7 @@ async function platformaticService (app, opts) {
   }
 
   // This must be done before loading the plugins, so they can inspect if the
-  // openTelemetry decoretor exists and then configure accordingly.
+  // openTelemetry decorator exists and then configure accordingly.
   if (isKeyEnabled('telemetry', config)) {
     await app.register(telemetry, config.telemetry)
   }
@@ -61,8 +62,7 @@ async function platformaticService (app, opts) {
 
   if (isKeyEnabled('openapi', serviceConfig)) {
     const openapi = serviceConfig.openapi
-    const versions = config.versions
-    app.register(setupOpenAPI, { openapi, versions })
+    app.register(setupOpenAPI, { openapi })
   }
 
   if (isKeyEnabled('graphql', serviceConfig)) {
@@ -80,18 +80,11 @@ async function platformaticService (app, opts) {
     }
 
     if (registerTsCompiler) {
-      app.register(setupTsCompiler)
+      app.register(setupTsCompiler, { context: opts.context })
     }
-    app.register(loadPlugins)
+    app.register(loadPlugins, { context: opts.context })
   }
 
-  await app.register(async (app) => {
-    if (config.versions) {
-      // TODO: Add typescript mappers support
-      await app.register(loadVersions)
-    }
-  })
-
   if (isKeyEnabled('cors', config.server)) {
     app.register(setupCors, config.server.cors)
   }
@@ -102,9 +95,8 @@ async function platformaticService (app, opts) {
 }
 
 platformaticService[Symbol.for('skip-override')] = true
-platformaticService.schema = schema
-platformaticService.configType = 'service'
-platformaticService.configManagerConfig = {
+
+module.exports.configManagerConfig = {
   version,
   schema,
   allowToWatch: ['.env'],
@@ -112,7 +104,7 @@ platformaticService.configManagerConfig = {
     useDefaults: true,
     coerceTypes: true,
     allErrors: true,
-    strict: false
+    strict: false,
   },
   async transformConfig () {
     // Set watch to true by default. This is not possible
@@ -142,17 +134,59 @@ platformaticService.configManagerConfig = {
       this.current.watch.ignore.push(outDir + '/**/*')
     }
   },
-  upgrade
+  upgrade,
 }
 
+platformaticService.configType = 'service'
+platformaticService.schema = schema
+platformaticService.configManagerConfig = module.exports.configManagerConfig
+
 function _buildServer (options, app) {
-  return buildServer(options, app || platformaticService)
+  return buildServer(options, app || module.exports)
+}
+
+async function buildStackable (
+  options,
+  app = platformaticService,
+  Stackable = ServiceStackable
+) {
+  let configManager = options.configManager
+
+  if (configManager === undefined) {
+    if (typeof options.config === 'string') {
+      ({ configManager } = await loadConfig({}, ['-c', options.config], app, {
+        onMissingEnv: options.onMissingEnv,
+        context: options.context,
+      }, true))
+    } else {
+      configManager = new ConfigManager({
+        ...app.configManagerConfig,
+        source: options.config,
+      })
+      await configManager.parseAndValidate()
+    }
+  }
+
+  const stackable = new Stackable({
+    init: () => buildServer(configManager.current, app, options.context),
+    stackable: app,
+    configManager,
+    context: options.context,
+  })
+
+  return stackable
 }
 
+module.exports.configType = 'service'
+module.exports.app = platformaticService
+module.exports.schema = schema
 module.exports.buildServer = _buildServer
-module.exports.schema = require('./lib/schema')
+module.exports.buildStackable = buildStackable
+module.exports.schemas = require('./lib/schema')
 module.exports.platformaticService = platformaticService
 module.exports.addLoggerToTheConfig = addLoggerToTheConfig
-module.exports.tsCompiler = compiler
 module.exports.start = start
 module.exports.Generator = ServiceGenerator
+module.exports.ServiceStackable = ServiceStackable
+module.exports.buildCompileCmd = buildCompileCmd
+module.exports.extractTypeScriptCompileOptionsFromConfig = extractTypeScriptCompileOptionsFromConfig

package/index.test-d.ts

@@ -12,7 +12,7 @@ import {
   platformaticService,
   Stackable,
   Generator,
-  PlatformaticServiceConfig
+  PlatformaticServiceConfig,
 } from '.'
 
 declare module 'fastify' {
@@ -32,21 +32,23 @@ expectType<MercuriusPlugin>(server.graphql)
 expectType<Promise<void>>(server.restart())
 
 function buildStackable (): Stackable<PlatformaticServiceConfig> {
-  async function myApp (app: FastifyInstance, opts: object): Promise<void> {
-    await platformaticService(app, opts)
-  }
+  const myApp: Stackable<PlatformaticServiceConfig> = {
+    async app (app: FastifyInstance, opts: object): Promise<void> {
+      await platformaticService.app(app, opts)
+    },
 
-  myApp.schema = platformaticService.configManagerConfig.schema
-  myApp.configType = 'myApp'
-  myApp.configManagerConfig = {
-    version: platformaticService.configManagerConfig.version,
-    ...platformaticService.configManagerConfig,
-    async transformConfig (this: ConfigManager<PlatformaticServiceConfig>) {
-      this.current.plugins = {
-        paths: [{
-          path: 'my-plugin'
-        }]
-      }
+    schema: platformaticService.schema,
+    configType: 'myApp',
+    configManagerConfig: {
+      version: platformaticService.configManagerConfig.version,
+      ...platformaticService.configManagerConfig,
+      async transformConfig (this: ConfigManager<PlatformaticServiceConfig>) {
+        this.current.plugins = {
+          paths: [{
+            path: 'my-plugin',
+          }],
+        }
+      },
     },
     async upgrade (config: PlatformaticServiceConfig, version: string) {
       const upgrade = platformaticService.configManagerConfig.upgrade
@@ -54,7 +56,7 @@ function buildStackable (): Stackable<PlatformaticServiceConfig> {
         return upgrade.call(this, config, version)
       }
       return config
-    }
+    },
   }
 
   // configVersion is not part of ConfigManagerConfig
@@ -77,21 +79,22 @@ expectType<MyGenerator>(myGenerator)
 expectType<BaseGenerator.BaseGeneratorConfig>(myGenerator.config)
 
 function buildStackable2 (): Stackable<PlatformaticServiceConfig> {
-  async function myApp (app: FastifyInstance, opts: object): Promise<void> {
-    await platformaticService(app, opts)
-  }
-
-  myApp.schema = platformaticService.configManagerConfig.schema
-  myApp.configType = 'myApp'
-  myApp.configManagerConfig = {
-    ...platformaticService.configManagerConfig,
-    async transformConfig (this: ConfigManager<PlatformaticServiceConfig>) {
-      this.current.plugins = {
-        paths: [{
-          path: 'my-plugin'
-        }]
-      }
-    }
+  const myApp: Stackable<PlatformaticServiceConfig> = {
+    async app (app: FastifyInstance, opts: object): Promise<void> {
+      await platformaticService.app(app, opts)
+    },
+    schema: platformaticService.schema,
+    configType: 'myApp',
+    configManagerConfig: {
+      ...platformaticService.configManagerConfig,
+      async transformConfig (this: ConfigManager<PlatformaticServiceConfig>) {
+        this.current.plugins = {
+          paths: [{
+            path: 'my-plugin',
+          }],
+        }
+      },
+    },
   }
 
   await start(myApp, ['--help'])

package/lib/compile.js

@@ -1,110 +1,19 @@
 'use strict'
 
-const { resolve, join, dirname } = require('path')
+const { compile } = require('@platformatic/ts-compiler')
+const { loadConfig } = require('@platformatic/config')
 const pino = require('pino')
 const pretty = require('pino-pretty')
-const { loadConfig } = require('@platformatic/config')
-const { isFileAccessible } = require('./utils.js')
-const { readFile, rm } = require('fs/promises')
-
-async function getTSCExecutablePath (cwd) {
-  const typescriptPath = require.resolve('typescript')
-  const typescriptPathCWD = require.resolve('typescript', { paths: [process.cwd()] })
-
-  const tscLocalPath = join(typescriptPath, '..', '..', 'bin', 'tsc')
-  const tscGlobalPath = join(typescriptPathCWD, '..', '..', 'bin', 'tsc')
-
-  const [tscLocalExists, tscGlobalExists] = await Promise.all([
-    isFileAccessible(tscLocalPath),
-    isFileAccessible(tscGlobalPath)
-  ])
-
-  /* c8 ignore next 7 */
-  if (tscLocalExists) {
-    return tscLocalPath
-  }
-
-  if (tscGlobalExists) {
-    return tscGlobalPath
-  }
-}
-
-async function setup (cwd, config, logger) {
-  if (!logger) {
-    logger = pino(
-      pretty({
-        translateTime: 'SYS:HH:MM:ss',
-        ignore: 'hostname,pid'
-      })
-    )
-
-    if (config?.server.logger) {
-      logger.level = config.server.logger.level
-    }
-  }
-
-  const { execa } = await import('execa')
-
-  const tscExecutablePath = await getTSCExecutablePath(cwd)
-  /* c8 ignore next 4 */
-  if (tscExecutablePath === undefined) {
-    const msg = 'The tsc executable was not found.'
-    logger.warn(msg)
-  }
-
-  const tsConfigPath = config?.plugins?.typescript?.tsConfig || resolve(cwd, 'tsconfig.json')
-  const tsConfigExists = await isFileAccessible(tsConfigPath)
-
-  if (!tsConfigExists) {
-    const msg = 'No typescript configuration file was found, skipping compilation.'
-    logger.info(msg)
-  }
-
-  return { execa, logger, tscExecutablePath, tsConfigPath, tsConfigExists }
-}
-
-async function compile (cwd, config, originalLogger, options) {
-  const { execa, logger, tscExecutablePath, tsConfigPath, tsConfigExists } = await setup(cwd, config, originalLogger)
-  /* c8 ignore next 3 */
-  if (!tscExecutablePath || !tsConfigExists) {
-    return false
-  }
-
-  try {
-    const tsFlags = config?.plugins?.typescript?.flags || ['--project', tsConfigPath, '--rootDir', '.']
-    const env = {
-      ...process.env
-    }
-    delete env.NODE_V8_COVERAGE
-    // somehow c8 does not pick up these lines even if there is a specific test
-    /* c8 ignore start */
-    if (options && options.clean) {
-      // delete outdir directory
-      const tsConfigContents = JSON.parse(await readFile(tsConfigPath, 'utf8'))
-      const outDir = tsConfigContents.compilerOptions.outDir
-      if (outDir) {
-        const outDirFullPath = join(dirname(tsConfigPath), outDir)
-        originalLogger.info(`Removing build directory ${outDirFullPath}`)
-        await rm(outDirFullPath, { recursive: true })
-      }
-    }
-    /* c8 ignore stop */
-    await execa(tscExecutablePath, tsFlags, { cwd, env })
-    logger.info('Typescript compilation completed successfully.')
-    return true
-  } catch (error) {
-    logger.error(error.message)
-    return false
-  }
-}
+const { dirname } = require('path')
 
 function buildCompileCmd (app) {
   return async function compileCmd (_args) {
     let fullPath = null
     let config = null
+
     try {
       const { configManager } = await loadConfig({}, _args, app, {
-        watch: false
+        watch: false,
       })
       await configManager.parseAndValidate()
       config = configManager.current
@@ -114,21 +23,34 @@ function buildCompileCmd (app) {
       console.error(err)
       process.exit(1)
     }
-    const compileOptions = {
-      clean: _args.includes('--clean')
-    }
+
     const logger = pino(
       pretty({
         translateTime: 'SYS:HH:MM:ss',
-        ignore: 'hostname,pid'
+        ignore: 'hostname,pid',
       })
     )
 
-    if (!await compile(fullPath, config, logger, compileOptions)) {
+    const compileOptions = {
+      ...extractTypeScriptCompileOptionsFromConfig(config),
+      cwd: fullPath,
+      logger,
+      clean: _args.includes('--clean'),
+    }
+
+    if (!await compile(compileOptions)) {
       process.exit(1)
     }
   }
 }
 
-module.exports.compile = compile
 module.exports.buildCompileCmd = buildCompileCmd
+
+function extractTypeScriptCompileOptionsFromConfig (config) {
+  return {
+    tsConfig: config.plugins?.typescript?.tsConfig,
+    flags: config.plugins?.typescript?.flags,
+  }
+}
+
+module.exports.extractTypeScriptCompileOptionsFromConfig = extractTypeScriptCompileOptionsFromConfig

package/lib/create.mjs

@@ -16,14 +16,14 @@ function printAppSummary (args, logger) {
     { 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: 'Sample Plugin and Tests', value: args.plugin },
   ]
 
   const p = new Table({
     columns: [
       { name: 'config', alignment: 'right' },
-      { name: 'value', alignment: 'left' }
-    ]
+      { name: 'value', alignment: 'left' },
+    ],
   })
 
   p.addRows(table)
@@ -34,7 +34,7 @@ async function createService (_args) {
     translateTime: 'SYS:HH:MM:ss',
     ignore: 'hostname,pid',
     minimumLevel: 'debug',
-    sync: true
+    sync: true,
   })
 
   const logger = pino(stream)
@@ -49,8 +49,8 @@ async function createService (_args) {
       plugin: true,
       typescript: false,
       git: false,
-      install: true
-    }
+      install: true,
+    },
 
   })
 
@@ -64,7 +64,7 @@ async function createService (_args) {
     tests: args.plugin,
     typescript: args.typescript,
     initGitRepository: args.git,
-    targetDirectory: args.dir
+    targetDirectory: args.dir,
   })
 
   try {

package/lib/gen-schema.js

@@ -11,5 +11,5 @@ async function generateJsonSchemaConfig () {
 
 module.exports = {
   generateJsonSchemaConfig,
-  filenameConfigJsonSchema
+  filenameConfigJsonSchema,
 }

package/lib/gen-types.mjs

@@ -4,7 +4,7 @@ import { writeFile } from 'fs/promises'
 import pino from 'pino'
 import pretty from 'pino-pretty'
 import { loadConfig } from '@platformatic/config'
-import { platformaticService } from '../index.js'
+import platformaticService from '../index.js'
 import { checkForDependencies } from '@platformatic/utils'
 
 const GLOBAL_TYPES_TEMPLATE = `
@@ -25,7 +25,7 @@ async function execute ({ logger, configManager }) {
 async function generateTypes (_args) {
   const logger = pino(pretty({
     translateTime: 'SYS:HH:MM:ss',
-    ignore: 'hostname,pid'
+    ignore: 'hostname,pid',
   }))
   const { configManager, args } = await loadConfig({}, _args, platformaticService)
   await configManager.parseAndValidate()