@platformatic/next 3.4.1 → 3.5.0

package/config.d.ts

@@ -5,7 +5,7 @@
  * and run json-schema-to-typescript to regenerate this file.
  */
 
-export interface PlatformaticNextJsStackable {
+export interface PlatformaticNextJsConfig {
   $schema?: string;
   logger?: {
     level: (
@@ -29,8 +29,6 @@ export interface PlatformaticNextJsStackable {
               [k: string]: unknown;
             };
             level?: string;
-            additionalProperties?: never;
-            [k: string]: unknown;
           }[];
           options?: {
             [k: string]: unknown;
@@ -42,6 +40,21 @@ export interface PlatformaticNextJsStackable {
         [k: string]: unknown;
       };
     };
+    formatters?: {
+      path: string;
+    };
+    timestamp?: "epochTime" | "unixTime" | "nullTime" | "isoTime";
+    redact?: {
+      paths: string[];
+      censor?: string;
+    };
+    base?: {
+      [k: string]: unknown;
+    } | null;
+    messageKey?: string;
+    customLevels?: {
+      [k: string]: unknown;
+    };
     [k: string]: unknown;
   };
   server?: {
@@ -49,6 +62,7 @@ export interface PlatformaticNextJsStackable {
     port?: number | string;
     http2?: boolean;
     https?: {
+      allowHTTP1?: boolean;
       key:
         | string
         | {
@@ -71,6 +85,8 @@ export interface PlatformaticNextJsStackable {
                 path?: string;
               }
           )[];
+      requestCert?: boolean;
+      rejectUnauthorized?: boolean;
     };
   };
   watch?:
@@ -95,4 +111,333 @@ export interface PlatformaticNextJsStackable {
       production?: string;
     };
   };
+  runtime?: {
+    preload?: string | string[];
+    basePath?: string;
+    services?: {
+      [k: string]: unknown;
+    }[];
+    workers?: number | string;
+    logger?: {
+      level: (
+        | ("fatal" | "error" | "warn" | "info" | "debug" | "trace" | "silent")
+        | {
+            [k: string]: unknown;
+          }
+      ) &
+        string;
+      transport?:
+        | {
+            target?: string;
+            options?: {
+              [k: string]: unknown;
+            };
+          }
+        | {
+            targets?: {
+              target?: string;
+              options?: {
+                [k: string]: unknown;
+              };
+              level?: string;
+            }[];
+            options?: {
+              [k: string]: unknown;
+            };
+          };
+      pipeline?: {
+        target?: string;
+        options?: {
+          [k: string]: unknown;
+        };
+      };
+      formatters?: {
+        path: string;
+      };
+      timestamp?: "epochTime" | "unixTime" | "nullTime" | "isoTime";
+      redact?: {
+        paths: string[];
+        censor?: string;
+      };
+      base?: {
+        [k: string]: unknown;
+      } | null;
+      messageKey?: string;
+      customLevels?: {
+        [k: string]: unknown;
+      };
+      [k: string]: unknown;
+    };
+    server?: {
+      hostname?: string;
+      port?: number | string;
+      http2?: boolean;
+      https?: {
+        allowHTTP1?: boolean;
+        key:
+          | string
+          | {
+              path?: string;
+            }
+          | (
+              | string
+              | {
+                  path?: string;
+                }
+            )[];
+        cert:
+          | string
+          | {
+              path?: string;
+            }
+          | (
+              | string
+              | {
+                  path?: string;
+                }
+            )[];
+        requestCert?: boolean;
+        rejectUnauthorized?: boolean;
+      };
+    };
+    startTimeout?: number;
+    restartOnError?: boolean | number;
+    exitOnUnhandledErrors?: boolean;
+    gracefulShutdown?: {
+      runtime: number | string;
+      application: number | string;
+    };
+    health?: {
+      enabled?: boolean | string;
+      interval?: number | string;
+      gracePeriod?: number | string;
+      maxUnhealthyChecks?: number | string;
+      maxELU?: number | string;
+      maxHeapUsed?: number | string;
+      maxHeapTotal?: number | string;
+      maxYoungGeneration?: number | string;
+    };
+    undici?: {
+      agentOptions?: {
+        [k: string]: unknown;
+      };
+      interceptors?:
+        | {
+            module: string;
+            options: {
+              [k: string]: unknown;
+            };
+            [k: string]: unknown;
+          }[]
+        | {
+            Client?: {
+              module: string;
+              options: {
+                [k: string]: unknown;
+              };
+              [k: string]: unknown;
+            }[];
+            Pool?: {
+              module: string;
+              options: {
+                [k: string]: unknown;
+              };
+              [k: string]: unknown;
+            }[];
+            Agent?: {
+              module: string;
+              options: {
+                [k: string]: unknown;
+              };
+              [k: string]: unknown;
+            }[];
+            [k: string]: unknown;
+          };
+      [k: string]: unknown;
+    };
+    httpCache?:
+      | boolean
+      | {
+          store?: string;
+          /**
+           * @minItems 1
+           */
+          methods?: [string, ...string[]];
+          cacheTagsHeader?: string;
+          maxSize?: number;
+          maxEntrySize?: number;
+          maxCount?: number;
+          [k: string]: unknown;
+        };
+    watch?: boolean | string;
+    managementApi?:
+      | boolean
+      | string
+      | {
+          logs?: {
+            maxSize?: number;
+          };
+        };
+    metrics?:
+      | boolean
+      | {
+          port?: number | string;
+          enabled?: boolean | string;
+          hostname?: string;
+          endpoint?: string;
+          auth?: {
+            username: string;
+            password: string;
+          };
+          labels?: {
+            [k: string]: string;
+          };
+          /**
+           * The label name to use for the application identifier in metrics (e.g., applicationId, serviceId)
+           */
+          applicationLabel?: string;
+          readiness?:
+            | boolean
+            | {
+                endpoint?: string;
+                success?: {
+                  statusCode?: number;
+                  body?: string;
+                };
+                fail?: {
+                  statusCode?: number;
+                  body?: string;
+                };
+              };
+          liveness?:
+            | boolean
+            | {
+                endpoint?: string;
+                success?: {
+                  statusCode?: number;
+                  body?: string;
+                };
+                fail?: {
+                  statusCode?: number;
+                  body?: string;
+                };
+              };
+          plugins?: string[];
+        };
+    telemetry?: {
+      enabled?: boolean | string;
+      /**
+       * The name of the application. Defaults to the folder name if not specified.
+       */
+      applicationName: string;
+      /**
+       * The version of the application (optional)
+       */
+      version?: string;
+      /**
+       * An array of paths to skip when creating spans. Useful for health checks and other endpoints that do not need to be traced.
+       */
+      skip?: {
+        /**
+         * The path to skip. Can be a string or a regex.
+         */
+        path?: string;
+        /**
+         * HTTP method to skip
+         */
+        method?: "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "OPTIONS";
+        [k: string]: unknown;
+      }[];
+      exporter?:
+        | {
+            type?: "console" | "otlp" | "zipkin" | "memory" | "file";
+            /**
+             * Options for the exporter. These are passed directly to the exporter.
+             */
+            options?: {
+              /**
+               * The URL to send the traces to. Not used for console or memory exporters.
+               */
+              url?: string;
+              /**
+               * Headers to send to the exporter. Not used for console or memory exporters.
+               */
+              headers?: {
+                [k: string]: unknown;
+              };
+              /**
+               * The path to write the traces to. Only for file exporter.
+               */
+              path?: string;
+              [k: string]: unknown;
+            };
+            additionalProperties?: never;
+            [k: string]: unknown;
+          }[]
+        | {
+            type?: "console" | "otlp" | "zipkin" | "memory" | "file";
+            /**
+             * Options for the exporter. These are passed directly to the exporter.
+             */
+            options?: {
+              /**
+               * The URL to send the traces to. Not used for console or memory exporters.
+               */
+              url?: string;
+              /**
+               * Headers to send to the exporter. Not used for console or memory exporters.
+               */
+              headers?: {
+                [k: string]: unknown;
+              };
+              /**
+               * The path to write the traces to. Only for file exporter.
+               */
+              path?: string;
+              [k: string]: unknown;
+            };
+            additionalProperties?: never;
+            [k: string]: unknown;
+          };
+    };
+    inspectorOptions?: {
+      host?: string;
+      port?: number;
+      breakFirstLine?: boolean;
+      watchDisabled?: boolean;
+      [k: string]: unknown;
+    };
+    applicationTimeout?: number | string;
+    messagingTimeout?: number | string;
+    env?: {
+      [k: string]: string;
+    };
+    sourceMaps?: boolean;
+    scheduler?: {
+      enabled?: boolean | string;
+      name: string;
+      cron: string;
+      callbackUrl: string;
+      method?: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+      headers?: {
+        [k: string]: string;
+      };
+      body?:
+        | string
+        | {
+            [k: string]: unknown;
+          };
+      maxRetries?: number;
+      [k: string]: unknown;
+    }[];
+  };
+  next?: {
+    trailingSlash?: boolean;
+  };
+  cache?: {
+    adapter: "redis" | "valkey";
+    url: string;
+    prefix?: string;
+    maxTTL?: number | string;
+  };
 }

package/index.js

@@ -1,261 +1,37 @@
-import {
-  BaseStackable,
-  transformConfig as basicTransformConfig,
-  ChildManager,
-  cleanBasePath,
-  createChildProcessListener,
-  createServerListener,
-  errors,
-  getServerUrl,
-  importFile,
-  resolvePackage,
-  schemaOptions
-} from '@platformatic/basic'
-import { ConfigManager } from '@platformatic/config'
-import { once } from 'node:events'
-import { readFile } from 'node:fs/promises'
-import { dirname, resolve as pathResolve } from 'node:path'
-import { pathToFileURL } from 'node:url'
-import { satisfies } from 'semver'
-import { packageJson, schema } from './lib/schema.js'
-
-const supportedVersions = '^14.0.0'
-
-export class NextStackable extends BaseStackable {
-  #basePath
-  #next
-  #manager
-  #child
-  #server
-
-  constructor (options, root, configManager) {
-    super('next', packageJson.version, options, root, configManager)
-  }
-
-  async init () {
-    this.#next = pathResolve(dirname(resolvePackage(this.root, 'next')), '../..')
-    const nextPackage = JSON.parse(await readFile(pathResolve(this.#next, 'package.json'), 'utf-8'))
-
-    /* c8 ignore next 3 */
-    if (!satisfies(nextPackage.version, supportedVersions)) {
-      throw new errors.UnsupportedVersion('next', nextPackage.version, supportedVersions)
-    }
-  }
-
-  async start ({ listen }) {
-    // Make this idempotent
-    if (this.url) {
-      return this.url
-    }
-
-    if (this.isProduction) {
-      await this.#startProduction(listen)
-    } else {
-      await this.#startDevelopment(listen)
-    }
-  }
-
-  async stop () {
-    if (this.subprocess) {
-      return this.stopCommand()
-    }
-
-    if (this.isProduction) {
-      return new Promise((resolve, reject) => {
-        this.#server.close(error => {
-          /* c8 ignore next 3 */
-          if (error) {
-            return reject(error)
-          }
-
-          resolve()
-        })
-      })
-    } else {
-      const exitPromise = once(this.#child, 'exit')
-      await this.#manager.close()
-      process.kill(this.#child.pid, 'SIGKILL')
-      await exitPromise
-    }
-  }
-
-  async build () {
-    const config = this.configManager.current
-    const loader = new URL('./lib/loader.js', import.meta.url)
-    this.#basePath = config.application?.basePath ? cleanBasePath(config.application?.basePath) : ''
-
-    let command = config.application.commands.build
-
-    if (!command) {
-      await this.init()
-      command = ['node', pathResolve(this.#next, './dist/bin/next'), 'build', this.root]
-    }
-
-    return this.buildWithCommand(command, this.#basePath, loader)
-  }
-
-  /* c8 ignore next 5 */
-  async getWatchConfig () {
-    return {
-      enabled: false
-    }
-  }
-
-  getMeta () {
-    const composer = { prefix: this.basePath ?? this.#basePath, wantsAbsoluteUrls: true, needsRootRedirect: false }
-
-    if (this.url) {
-      composer.tcp = true
-      composer.url = this.url
-    }
-
-    return { composer }
-  }
-
-  async #startDevelopment () {
-    const config = this.configManager.current
-    const loaderUrl = new URL('./lib/loader.js', import.meta.url)
-    const command = this.configManager.current.application.commands.development
-
-    this.#basePath = config.application?.basePath ? cleanBasePath(config.application?.basePath) : ''
-
-    if (command) {
-      return this.startWithCommand(command, loaderUrl)
-    }
-
-    const { hostname, port } = this.serverConfig ?? {}
-    const serverOptions = {
-      host: hostname || '127.0.0.1',
-      port: port || 0
-    }
-
-    this.#manager = new ChildManager({
-      loader: loaderUrl,
-      context: {
-        id: this.id,
-        // Always use URL to avoid serialization problem in Windows
-        root: pathToFileURL(this.root).toString(),
-        basePath: this.#basePath,
-        logLevel: this.logger.level,
-        port: false
-      }
-    })
-
-    const promise = once(this.#manager, 'url')
-    await this.#startDevelopmentNext(serverOptions)
-    this.url = (await promise)[0]
-  }
-
-  async #startDevelopmentNext (serverOptions) {
-    const { nextDev } = await importFile(pathResolve(this.#next, './dist/cli/next-dev.js'))
-
-    this.#manager.on('config', config => {
-      this.#basePath = config.basePath
-    })
-
-    try {
-      await this.#manager.inject()
-      const childPromise = createChildProcessListener()
-      await nextDev(serverOptions, 'default', this.root)
-      this.#child = await childPromise
-    } finally {
-      await this.#manager.eject()
-    }
-  }
-
-  async #startProduction (listen) {
-    const config = this.configManager.current
-    const loaderUrl = new URL('./lib/loader.js', import.meta.url)
-    const command = this.configManager.current.application.commands.production
-
-    this.#basePath = config.application?.basePath ? cleanBasePath(config.application?.basePath) : ''
-
-    if (command) {
-      return this.startWithCommand(command, loaderUrl)
-    }
-
-    this.#manager = new ChildManager({
-      loader: loaderUrl,
-      context: {
-        id: this.id,
-        // Always use URL to avoid serialization problem in Windows
-        root: pathToFileURL(this.root).toString(),
-        basePath: this.#basePath,
-        logLevel: this.logger.level
-      }
-    })
-
-    this.verifyOutputDirectory(pathResolve(this.root, '.next'))
-    await this.#startProductionNext()
-  }
-
-  async #startProductionNext () {
-    try {
-      await this.#manager.inject()
-      const { nextStart } = await importFile(pathResolve(this.#next, './dist/cli/next-start.js'))
-
-      const { hostname, port } = this.serverConfig ?? {}
-      const serverOptions = {
-        hostname: hostname || '127.0.0.1',
-        port: port || 0
-      }
-
-      // Since we are in the same process
-      process.once('plt:next:config', config => {
-        this.#basePath = config.basePath
-      })
-
-      this.#manager.register()
-      const serverPromise = createServerListener(
-        (this.isEntrypoint ? serverOptions?.port : undefined) ?? true,
-        (this.isEntrypoint ? serverOptions?.hostname : undefined) ?? true
-      )
-
-      await nextStart(serverOptions, this.root)
-
-      this.#server = await serverPromise
-      this.url = getServerUrl(this.#server)
-    } finally {
-      await this.#manager.eject()
-    }
-  }
-}
+import { transform as basicTransform, resolve, validationOptions } from '@platformatic/basic'
+import { kMetadata, loadConfiguration as utilsLoadConfiguration } from '@platformatic/foundation'
+import { NextCapability } from './lib/capability.js'
+import { schema } from './lib/schema.js'
 
 /* c8 ignore next 9 */
-function transformConfig () {
-  if (this.current.watch === undefined) {
-    this.current.watch = { enabled: false }
-  }
+export async function transform (config, schema, options) {
+  config = await basicTransform(config, schema, options)
+  config.watch = { enabled: false }
 
-  if (typeof this.current.watch !== 'object') {
-    this.current.watch = { enabled: this.current.watch || false }
+  if (config.cache?.adapter === 'redis') {
+    config.cache.adapter = 'valkey'
   }
 
-  basicTransformConfig.call(this)
+  return config
 }
 
-export async function buildStackable (opts) {
-  const root = opts.context.directory
+export async function loadConfiguration (configOrRoot, sourceOrConfig, context) {
+  const { root, source } = await resolve(configOrRoot, sourceOrConfig, 'application')
 
-  const configManager = new ConfigManager({
-    schema,
-    source: opts.config ?? {},
-    schemaOptions,
-    transformConfig,
-    dirname: root
+  return utilsLoadConfiguration(source, context?.schema ?? schema, {
+    validationOptions,
+    transform,
+    replaceEnv: true,
+    root,
+    ...context
   })
-  await configManager.parseAndValidate()
-
-  return new NextStackable(opts, root, configManager)
 }
 
-export default {
-  configType: 'next',
-  configManagerConfig: {
-    schemaOptions,
-    transformConfig
-  },
-  buildStackable,
-  schema,
-  version: packageJson.version
+export async function create (configOrRoot, sourceOrConfig, context) {
+  const config = await loadConfiguration(configOrRoot, sourceOrConfig, context)
+  return new NextCapability(config[kMetadata].root, config, context)
 }
+
+export * as cachingValkey from './lib/caching/valkey.js'
+export * from './lib/capability.js'
+export { packageJson, schema, schemaComponents, version } from './lib/schema.js'