@platformatic/basic 2.0.0-alpha.3 → 2.0.0-alpha.4

package/config.d.ts

@@ -0,0 +1,159 @@
+/* eslint-disable */
+/**
+ * This file was automatically generated by json-schema-to-typescript.
+ * DO NOT MODIFY IT BY HAND. Instead, modify the source JSONSchema file,
+ * and run json-schema-to-typescript to regenerate this file.
+ */
+
+export interface PlatformaticStackable {
+  $schema?: string;
+  server?: {
+    hostname?: string;
+    port?: number | string;
+    pluginTimeout?: number;
+    healthCheck?:
+      | boolean
+      | {
+          enabled?: boolean;
+          interval?: number;
+          [k: string]: unknown;
+        };
+    ignoreTrailingSlash?: boolean;
+    ignoreDuplicateSlashes?: boolean;
+    connectionTimeout?: number;
+    keepAliveTimeout?: number;
+    maxRequestsPerSocket?: number;
+    forceCloseConnections?: boolean | string;
+    requestTimeout?: number;
+    bodyLimit?: number;
+    maxParamLength?: number;
+    disableRequestLogging?: boolean;
+    exposeHeadRoutes?: boolean;
+    logger?:
+      | boolean
+      | {
+          level?: string;
+          transport?:
+            | {
+                target?: string;
+                options?: {
+                  [k: string]: unknown;
+                };
+              }
+            | {
+                targets?: {
+                  target?: string;
+                  options?: {
+                    [k: string]: unknown;
+                  };
+                  level?: string;
+                  additionalProperties?: never;
+                  [k: string]: unknown;
+                }[];
+                options?: {
+                  [k: string]: unknown;
+                };
+              };
+          pipeline?: {
+            target?: string;
+            options?: {
+              [k: string]: unknown;
+            };
+          };
+          [k: string]: unknown;
+        };
+    serializerOpts?: {
+      schema?: {
+        [k: string]: unknown;
+      };
+      ajv?: {
+        [k: string]: unknown;
+      };
+      rounding?: "floor" | "ceil" | "round" | "trunc";
+      debugMode?: boolean;
+      mode?: "debug" | "standalone";
+      largeArraySize?: number | string;
+      largeArrayMechanism?: "default" | "json-stringify";
+      [k: string]: unknown;
+    };
+    caseSensitive?: boolean;
+    requestIdHeader?: string | false;
+    requestIdLogLabel?: string;
+    jsonShorthand?: boolean;
+    trustProxy?: boolean | string | string[] | number;
+    http2?: boolean;
+    https?: {
+      allowHTTP1?: boolean;
+      key:
+        | string
+        | {
+            path?: string;
+          }
+        | (
+            | string
+            | {
+                path?: string;
+              }
+          )[];
+      cert:
+        | string
+        | {
+            path?: string;
+          }
+        | (
+            | string
+            | {
+                path?: string;
+              }
+          )[];
+      requestCert?: boolean;
+      rejectUnauthorized?: boolean;
+    };
+    cors?: {
+      origin?:
+        | boolean
+        | string
+        | (
+            | string
+            | {
+                regexp: string;
+                [k: string]: unknown;
+              }
+          )[]
+        | {
+            regexp: string;
+            [k: string]: unknown;
+          };
+      methods?: string[];
+      /**
+       * Comma separated string of allowed headers.
+       */
+      allowedHeaders?: string;
+      exposedHeaders?: string[] | string;
+      credentials?: boolean;
+      maxAge?: number;
+      preflightContinue?: boolean;
+      optionsSuccessStatus?: number;
+      preflight?: boolean;
+      strictPreflight?: boolean;
+      hideOptionsRoute?: boolean;
+    };
+  };
+  watch?:
+    | {
+        enabled?: boolean | string;
+        /**
+         * @minItems 1
+         */
+        allow?: [string, ...string[]];
+        ignore?: string[];
+      }
+    | boolean
+    | string;
+  application?: {
+    base?: string;
+  };
+  vite?: {
+    configFile?: string | boolean;
+  };
+}

package/eslint.config.js

@@ -1,3 +1,5 @@
 import neostandard from 'neostandard'
 
-export default neostandard({})
+export default neostandard({
+  ignores: ['test/tmp/version.js', '**/.next'],
+})

package/index.js

@@ -6,8 +6,10 @@ import { resolve } from 'node:path'
 
 import { ConfigManager } from '@platformatic/config'
 
+import { NextStackable } from './lib/next.js'
 import { packageJson, schema } from './lib/schema.js'
 import { ServerStackable } from './lib/server.js'
+import { ViteStackable } from './lib/vite.js'
 
 const validFields = [
   'main',
@@ -84,12 +86,23 @@ function transformConfig () {
 
 export async function buildStackable (opts) {
   const root = opts.context.directory
-  const { entrypoint, hadEntrypointField } = await parsePackageJson(root)
+  const {
+    entrypoint,
+    hadEntrypointField,
+    packageJson: { dependencies, devDependencies },
+  } = await parsePackageJson(root)
 
   const configManager = new ConfigManager({ schema, source: opts.config ?? {} })
   await configManager.parseAndValidate()
 
-  const stackable = new ServerStackable(opts, root, configManager, entrypoint, hadEntrypointField)
+  let stackable
+  if (dependencies?.next || devDependencies?.next) {
+    stackable = new NextStackable(opts, root, configManager)
+  } else if (dependencies?.vite || devDependencies?.vite) {
+    stackable = new ViteStackable(opts, root, configManager)
+  } else {
+    stackable = new ServerStackable(opts, root, configManager, entrypoint, hadEntrypointField)
+  }
 
   return stackable
 }

package/lib/base.js

@@ -12,7 +12,9 @@ export class BaseStackable {
     this.getGraphqlSchema = null
 
     // Setup the logger
-    const pinoOptions = { level: this.serverConfig?.logger?.level ?? 'trace' }
+    const pinoOptions = {
+      level: (this.configManager.current.server ?? this.serverConfig)?.logger?.level ?? 'trace',
+    }
 
     if (this.id) {
       pinoOptions.name = this.id
@@ -21,8 +23,8 @@ export class BaseStackable {
 
     // Setup globals
     globalThis.platformatic = {
-      setOpenAPISchema: this.setOpenAPISchema.bind(this),
-      setGraphQLSchema: this.setGraphQLSchema.bind(this),
+      setOpenapiSchema: this.setOpenapiSchema.bind(this),
+      setGraphqlSchema: this.setGraphqlSchema.bind(this),
     }
   }
 
@@ -67,11 +69,11 @@ export class BaseStackable {
     return this.graphqlSchema
   }
 
-  setOpenAPISchema (schema) {
+  setOpenapiSchema (schema) {
     this.openapiSchema = schema
   }
 
-  setGraphQLSchema (schema) {
+  setGraphqlSchema (schema) {
     this.graphqlSchema = schema
   }
 

package/lib/errors.js

@@ -0,0 +1,8 @@
+import createError from '@fastify/error'
+
+const ERROR_PREFIX = 'PLT_BASIC'
+
+export const UnsupportedVersion = createError(
+  `${ERROR_PREFIX}_UNSUPPORTED_VERSION`,
+  '%s version %s is not supported. Please use version %s.'
+)

package/lib/next.js

@@ -0,0 +1,105 @@
+import { once } from 'node:events'
+import { readFile } from 'node:fs/promises'
+import { createRequire } from 'node:module'
+import { dirname, resolve as pathResolve } from 'node:path'
+import { pathToFileURL } from 'node:url'
+import { satisfies } from 'semver'
+import { BaseStackable } from './base.js'
+import { UnsupportedVersion } from './errors.js'
+import { importFile } from './utils.js'
+import { ChildManager } from './worker/child-manager.js'
+
+const supportedVersions = '^14.0.0'
+
+export class NextStackable extends BaseStackable {
+  #basePath
+  #next
+  #manager
+
+  constructor (options, root, configManager) {
+    super(options, root, configManager)
+    this.type = 'next'
+  }
+
+  async init () {
+    globalThis[Symbol.for('plt.runtime.itc')].handle('getServiceMeta', this.getMeta.bind(this))
+
+    this.#next = pathResolve(dirname(createRequire(this.root).resolve('next')), '../..')
+    const nextPackage = JSON.parse(await readFile(pathResolve(this.#next, 'package.json')))
+
+    if (!satisfies(nextPackage.version, supportedVersions)) {
+      throw new UnsupportedVersion('next', nextPackage.version, supportedVersions)
+    }
+  }
+
+  async start () {
+    // Make this idempotent
+    if (this.url) {
+      return this.url
+    }
+
+    const config = this.configManager.current
+    const require = createRequire(this.root)
+    const nextRoot = require.resolve('next')
+
+    const { hostname, port } = this.serverConfig ?? {}
+    const serverOptions = {
+      host: hostname || '127.0.0.1',
+      port: port || 0,
+    }
+
+    this.#basePath = config.application?.base
+      ? `/${config.application?.base}`.replaceAll(/\/+/g, '/').replace(/\/$/, '')
+      : ''
+
+    this.#manager = new ChildManager({
+      loader: new URL('./worker/next-loader.js', import.meta.url),
+      context: {
+        // Always use URL to avoid serialization problem in Windows
+        root: pathToFileURL(this.root),
+        basePath: this.#basePath,
+        logger: { id: this.id, level: this.logger.level },
+      },
+    })
+
+    this.#manager.on('config', config => {
+      this.#basePath = config.basePath.replace(/(^\/)|(\/$)/g, '')
+    })
+
+    const promise = once(this.#manager, 'url')
+    await this.#startNext(nextRoot, serverOptions)
+    this.url = (await promise)[0]
+  }
+
+  async stop () {
+    const exitPromise = once(this.#manager, 'exit')
+
+    this.#manager.close()
+    await exitPromise
+  }
+
+  async getWatchConfig () {
+    return {
+      enabled: false,
+    }
+  }
+
+  getMeta () {
+    return {
+      composer: {
+        tcp: true,
+        url: this.url,
+        prefix: this.#basePath,
+        wantsAbsoluteUrls: true,
+      },
+    }
+  }
+
+  async #startNext (nextRoot, serverOptions) {
+    const { nextDev } = await importFile(pathResolve(this.#next, './dist/cli/next-dev.js'))
+
+    this.#manager.inject()
+    await nextDev(serverOptions, 'default', this.root)
+    this.#manager.eject()
+  }
+}

package/lib/schema.js

@@ -25,6 +25,29 @@ export const schema = {
         },
       ],
     },
+    application: {
+      type: 'object',
+      properties: {
+        base: {
+          type: 'string',
+        },
+      },
+      additionalProperties: false,
+    },
+    vite: {
+      type: 'object',
+      properties: {
+        configFile: {
+          oneOf: [{ type: 'string' }, { type: 'boolean' }],
+        },
+      },
+      additionalProperties: false,
+    },
   },
   additionalProperties: false,
 }
+
+/* c8 ignore next 3 */
+if (process.argv[1] === import.meta.filename) {
+  console.log(JSON.stringify(schema, null, 2))
+}

package/lib/server.js

@@ -1,9 +1,9 @@
 import inject from 'light-my-request'
 import { Server } from 'node:http'
-import { join } from 'node:path'
-import { pathToFileURL } from 'node:url'
+import { resolve as pathResolve } from 'node:path'
 import { BaseStackable } from './base.js'
-import { createPortManager, getServerUrl, injectViaRequest, isFastify } from './utils.js'
+import { getServerUrl, importFile, injectViaRequest, isFastify } from './utils.js'
+import { createServerListener } from './worker/server-listener.js'
 
 export class ServerStackable extends BaseStackable {
   #entrypoint
@@ -39,16 +39,16 @@ export class ServerStackable extends BaseStackable {
       )
     }
 
-    // The port manager must be created before requiring the entrypoint even if it's not going to be used
+    // The server promise must be created before requiring the entrypoint even if it's not going to be used
     // at all. Otherwise there is chance we miss the listen event.
-    const portManager = createPortManager()
-    this.#module = await import(pathToFileURL(join(this.root, this.#entrypoint)))
+    const serverPromise = createServerListener()
+    this.#module = await importFile(pathResolve(this.root, this.#entrypoint))
     this.#module = this.#module.default || this.#module
 
     // Deal with application
     if (typeof this.#module.build === 'function') {
       // We have build function, this Stackable will not use HTTP unless it is the entrypoint
-      portManager.destroy()
+      serverPromise.cancel()
 
       this.#app = await this.#module.build()
       this.#isFastify = isFastify(this.#app)
@@ -61,9 +61,8 @@ export class ServerStackable extends BaseStackable {
       }
     } else {
       // User blackbox function, we wait for it to listen on a port
-      this.#server = await portManager.getServer()
+      this.#server = await serverPromise
       this.url = getServerUrl(this.#server)
-      portManager.destroy()
     }
 
     return this.url

package/lib/utils.js

@@ -1,6 +1,4 @@
-'use strict'
-
-import { tracingChannel } from 'node:diagnostics_channel'
+import { pathToFileURL } from 'node:url'
 import { request } from 'undici'
 
 export function getServerUrl (server) {
@@ -14,37 +12,6 @@ export function isFastify (app) {
   return Object.getOwnPropertySymbols(app).some(s => s.description === 'fastify.state')
 }
 
-export function createPortManager () {
-  let resolve
-  let reject
-
-  const promise = new Promise((_resolve, _reject) => {
-    resolve = _resolve
-    reject = _reject
-  })
-
-  const subscribers = {
-    asyncStart ({ options }) {
-      options.port = 0
-    },
-    asyncEnd: ({ server }) => {
-      resolve(server)
-    },
-    error: reject,
-  }
-
-  tracingChannel('net.server.listen').subscribe(subscribers)
-
-  return {
-    getServer () {
-      return promise
-    },
-    destroy () {
-      tracingChannel('net.server.listen').unsubscribe(subscribers)
-    },
-  }
-}
-
 export async function injectViaRequest (baseUrl, injectParams, onInject) {
   const url = new URL(injectParams.url, baseUrl).href
   const requestParams = { method: injectParams.method, headers: injectParams.headers }
@@ -75,3 +42,7 @@ export async function injectViaRequest (baseUrl, injectParams, onInject) {
     throw error
   }
 }
+
+export function importFile (path) {
+  return import(pathToFileURL(path))
+}

package/lib/vite.js

@@ -0,0 +1,105 @@
+import { createRequire } from 'node:module'
+import { dirname, resolve as pathResolve } from 'node:path'
+import { satisfies } from 'semver'
+import { BaseStackable } from './base.js'
+import { getServerUrl, importFile } from './utils.js'
+import { createServerListener } from './worker/server-listener.js'
+
+import { readFile } from 'node:fs/promises'
+import { UnsupportedVersion } from './errors.js'
+
+const supportedVersions = '^5.0.0'
+
+export class ViteStackable extends BaseStackable {
+  #vite
+  #app
+  #server
+  #basePath
+
+  constructor (options, root, configManager) {
+    super(options, root, configManager)
+    this.type = 'vite'
+  }
+
+  async init () {
+    globalThis[Symbol.for('plt.runtime.itc')].handle('getServiceMeta', this.getMeta.bind(this))
+
+    this.#vite = dirname(createRequire(this.root).resolve('vite'))
+    const vitePackage = JSON.parse(await readFile(pathResolve(this.#vite, 'package.json')))
+
+    if (!satisfies(vitePackage.version, supportedVersions)) {
+      throw new UnsupportedVersion('vite', vitePackage.version, supportedVersions)
+    }
+  }
+
+  async start () {
+    // Make this idempotent
+    if (this.url) {
+      return this.url
+    }
+
+    const config = this.configManager.current
+
+    // Prepare options
+    const { hostname, port, https, cors } = this.serverConfig ?? {}
+    const configFile = config.vite?.configFile ? pathResolve(this.root, config.vite?.configFile) : undefined
+    const basePath = config.application?.base
+      ? `/${config.application?.base}`.replaceAll(/\/+/g, '/').replace(/\/$/, '')
+      : undefined
+
+    const serverOptions = {
+      host: hostname || '127.0.0.1',
+      port: port || 0,
+      strictPort: false,
+      https,
+      cors,
+      origin: 'http://localhost',
+      hmr: true,
+    }
+
+    // Require Vite
+    const serverPromise = createServerListener()
+    const { createServer } = await importFile(pathResolve(this.#vite, 'dist/node/index.js'))
+
+    // Create the server and listen
+    this.#app = await createServer({
+      root: this.root,
+      base: basePath,
+      mode: 'development',
+      configFile,
+      logLevel: this.logger.level,
+      clearScreen: false,
+      optimizeDeps: { force: false },
+      server: serverOptions,
+    })
+
+    await this.#app.listen()
+    this.#server = await serverPromise
+    this.url = getServerUrl(this.#server)
+  }
+
+  async stop () {
+    return this.#app.close()
+  }
+
+  async getWatchConfig () {
+    return {
+      enabled: false,
+    }
+  }
+
+  getMeta () {
+    if (!this.#basePath) {
+      this.#basePath = this.#app.config.base.replace(/(^\/)|(\/$)/g, '')
+    }
+
+    return {
+      composer: {
+        tcp: true,
+        url: this.url,
+        prefix: this.#basePath,
+        wantsAbsoluteUrls: true,
+      },
+    }
+  }
+}

package/lib/worker/child-manager.js

@@ -0,0 +1,78 @@
+import { ITC } from '@platformatic/itc'
+import { subscribe, unsubscribe } from 'node:diagnostics_channel'
+import { once } from 'node:events'
+import { workerData } from 'node:worker_threads'
+
+export const childProcessWorkerFile = new URL('./child-process.js', import.meta.url)
+
+export class ChildManager extends ITC {
+  #child
+  #listener
+  #injectedNodeOptions
+  #originalNodeOptions
+
+  constructor ({ loader, context }) {
+    super({})
+
+    const childHandler = ({ process: child }) => {
+      unsubscribe('child_process', childHandler)
+
+      this.#child = child
+      this.#child.once('exit', () => {
+        this.emit('exit')
+      })
+
+      this.listen()
+    }
+
+    subscribe('child_process', childHandler)
+
+    this.handle('log', message => {
+      workerData.loggingPort.postMessage(JSON.parse(message))
+    })
+
+    this.#prepareChildEnvironment(loader, context)
+  }
+
+  inject () {
+    process.env.NODE_OPTIONS = this.#injectedNodeOptions
+  }
+
+  eject () {
+    process.env.NODE_OPTIONS = this.#originalNodeOptions
+  }
+
+  _setupListener (listener) {
+    this.#listener = listener
+    this.#child.on('message', this.#listener)
+  }
+
+  _send (request) {
+    this.#child.send(request)
+  }
+
+  _createClosePromise () {
+    return once(this.#child, 'exit')
+  }
+
+  _close () {
+    this.#child.removeListener('message', this.#listener)
+    this.#child.kill('SIGKILL')
+  }
+
+  #prepareChildEnvironment (loader, context) {
+    this.#originalNodeOptions = process.env.NODE_OPTIONS
+
+    const loaderScript = `
+      import { register } from 'node:module';
+      globalThis.platformatic=${JSON.stringify(context).replaceAll('"', '\\"')};    
+      register('${loader}',{ data: globalThis.platformatic });
+    `
+
+    this.#injectedNodeOptions = [
+      `--import="data:text/javascript,${loaderScript.replaceAll(/\n/g, '')}"`,
+      `--import=${childProcessWorkerFile}`,
+      process.env.NODE_OPTIONS ?? '',
+    ].join(' ')
+  }
+}