@platformatic/remix 3.4.1 → 3.5.1

package/config.d.ts

@@ -5,7 +5,7 @@
  * and run json-schema-to-typescript to regenerate this file.
  */
 
-export interface PlatformaticRemixStackable {
+export interface PlatformaticRemixConfig {
   $schema?: string;
   logger?: {
     level: (
@@ -29,8 +29,6 @@ export interface PlatformaticRemixStackable {
               [k: string]: unknown;
             };
             level?: string;
-            additionalProperties?: never;
-            [k: string]: unknown;
           }[];
           options?: {
             [k: string]: unknown;
@@ -42,6 +40,21 @@ export interface PlatformaticRemixStackable {
         [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 PlatformaticRemixStackable {
     port?: number | string;
     http2?: boolean;
     https?: {
+      allowHTTP1?: boolean;
       key:
         | string
         | {
@@ -71,6 +85,8 @@ export interface PlatformaticRemixStackable {
                 path?: string;
               }
           )[];
+      requestCert?: boolean;
+      rejectUnauthorized?: boolean;
     };
   };
   watch?:
@@ -95,6 +111,326 @@ export interface PlatformaticRemixStackable {
       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;
+    }[];
+  };
   vite?: {
     configFile?: string | boolean;
     devServer?: {

package/index.js

@@ -1,248 +1,31 @@
-import {
-  cleanBasePath,
-  ensureTrailingSlash,
-  errors,
-  getServerUrl,
-  importFile,
-  resolvePackage,
-  schemaOptions
-} from '@platformatic/basic'
-import { ConfigManager } from '@platformatic/config'
-import { ViteStackable } from '@platformatic/vite'
-import { createRequestHandler } from '@remix-run/express'
-import express from 'express'
-import inject from 'light-my-request'
-import { readFile } from 'node:fs/promises'
-import { dirname, resolve } from 'node:path'
-import { pathToFileURL } from 'node:url'
-import { pinoHttp } from 'pino-http'
-import { satisfies } from 'semver'
-import { packageJson, schema } from './lib/schema.js'
-
-const supportedVersions = '^2.0.0'
-
-export class RemixStackable extends ViteStackable {
-  #app
-  #server
-  #dispatcher
-  #remix
-  #basePath
-
-  constructor (options, root, configManager) {
-    super(options, root, configManager)
-
-    this.type = 'remix'
-    this.version = packageJson.version
-  }
-
-  async init () {
-    await super.init()
-
-    this.#remix = resolve(dirname(resolvePackage(this.root, '@remix-run/dev')), '..')
-    const remixPackage = JSON.parse(await readFile(resolve(this.#remix, 'package.json'), 'utf-8'))
-
-    /* c8 ignore next 3 */
-    if (!satisfies(remixPackage.version, supportedVersions)) {
-      throw new errors.UnsupportedVersion('@remix-run/dev', remixPackage.version, supportedVersions)
-    }
-
-    const config = this.configManager.current
-    this.#basePath = config.application?.basePath
-      ? ensureTrailingSlash(cleanBasePath(config.application?.basePath))
-      : undefined
-
-    this.registerGlobals({
-      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.subprocessTerminationSignal = 'SIGKILL'
-  }
-
-  async start ({ listen }) {
-    // Make this idempotent
-    if (this.url) {
-      return this.url
-    }
-
-    const config = this.configManager.current
-    const command = config.application.commands[this.isProduction ? 'production' : 'development']
-
-    if (command) {
-      return this.startWithCommand(command)
-    }
-
-    if (this.isProduction) {
-      return this.#startProduction(listen)
-    }
-
-    const { preloadViteEsm } = await importFile(resolve(this.#remix, './dist/vite/import-vite-esm-sync.js'))
-    await preloadViteEsm()
-    await super.start({ listen })
-
-    /* c8 ignore next 3 */
-    if (!this._getVite().config.plugins.some(p => p.name === 'remix')) {
-      this.logger.warn('Could not find Remix plugin in your Vite configuration. Continuing as plain Vite application.')
-    }
-  }
-
-  async stop () {
-    if (this.subprocess) {
-      return this.stopCommand()
-    }
-
-    if (this.isProduction) {
-      return this.#stopProduction()
-    }
-
-    return super.stop()
-  }
-
-  async build () {
-    const config = this.configManager.current
-    const command = config.application.commands.build
-    const basePath = config.application?.basePath
-      ? ensureTrailingSlash(cleanBasePath(config.application?.basePath))
-      : undefined
-
-    if (command) {
-      return this.buildWithCommand(command, basePath)
-    }
-
-    await this.init()
-    const { viteBuild } = await importFile(resolve(this.#remix, 'dist/cli/commands.js'))
-
-    await viteBuild(this.root, {
-      emptyOutDir: true,
-      logLevel: this.logger.level,
-      mode: 'production',
-      profile: false
-    })
-  }
-
-  async inject (injectParams, onInject) {
-    if (!this.isProduction) {
-      return super.inject(injectParams, onInject)
-    }
-
-    const res = await inject(this.#app, injectParams, onInject)
-
-    /* c8 ignore next 3 */
-    if (onInject) {
-      return
-    }
-
-    // Since inject might be called from the main thread directly via ITC, let's clean it up
-    const { statusCode, headers, body, payload, rawPayload } = res
-
-    return { statusCode, headers, body, payload, rawPayload }
-  }
-
-  getMeta () {
-    if (!this.isProduction) {
-      return super.getMeta()
-    }
-
-    return {
-      composer: {
-        tcp: typeof this.url !== 'undefined',
-        url: this.url,
-        prefix: this.basePath ?? this.#basePath,
-        wantsAbsoluteUrls: true,
-        needsRootRedirect: true
-      }
-    }
-  }
-
-  async #startProduction (listen) {
-    // Listen if entrypoint
-    if (this.#app && listen) {
-      const serverOptions = this.serverConfig
-
-      this.#server = await new Promise((resolve, reject) => {
-        return this.#app
-          .listen({ host: serverOptions?.hostname || '127.0.0.1', port: serverOptions?.port || 0 }, function () {
-            resolve(this)
-          })
-          .on('error', reject)
-      })
-
-      this.url = getServerUrl(this.#server)
-
-      return this.url
-    }
-
-    const outputDirectory = this.configManager.current.remix.outputDirectory
-    this.verifyOutputDirectory(resolve(this.root, outputDirectory))
-
-    const build = await importFile(resolve(this.root, `${outputDirectory}/server/index.js`))
-    this.#basePath = ensureTrailingSlash(cleanBasePath(build.basename))
-
-    this.#app = express()
-    this.#app.use(pinoHttp({ logger: this.logger }))
-    this.#app.use(this.#basePath, express.static(resolve(this.root, `${outputDirectory}/client`)))
-    this.#app.all(`${ensureTrailingSlash(cleanBasePath(this.#basePath))}*`, createRequestHandler({ build }))
-
-    return this.url
-  }
-
-  async #stopProduction () {
-    /* c8 ignore next 3 */
-    if (!this.#server?.listening) {
-      return
-    }
-
-    return new Promise((resolve, reject) => {
-      this.#server.close(error => {
-        /* c8 ignore next 3 */
-        if (error) {
-          return reject(error)
-        }
-
-        resolve()
-      })
-    })
-  }
+import { transform as basicTransform, resolve, validationOptions } from '@platformatic/basic'
+import { kMetadata, loadConfiguration as utilsLoadConfiguration } from '@platformatic/foundation'
+import { RemixCapability } from './lib/capability.js'
+import { schema } from './lib/schema.js'
+
+/* c8 ignore next 5 */
+export async function transform (config, schema, options) {
+  config = await basicTransform(config, schema, options)
+  config.watch = { enabled: false }
+  return config
 }
 
-/* c8 ignore next 9 */
-function transformConfig () {
-  if (this.current.watch === undefined) {
-    this.current.watch = { enabled: false }
-  }
+export async function loadConfiguration (configOrRoot, sourceOrConfig, context) {
+  const { root, source } = await resolve(configOrRoot, sourceOrConfig, 'application')
 
-  if (typeof this.current.watch !== 'object') {
-    this.current.watch = { enabled: this.current.watch || false }
-  }
-}
-
-export async function buildStackable (opts) {
-  const root = opts.context.directory
-
-  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 RemixStackable(opts, root, configManager)
 }
 
-export { schema, schemaComponents } from './lib/schema.js'
-
-export default {
-  configType: 'remix',
-  configManagerConfig: {
-    schemaOptions,
-    transformConfig
-  },
-  buildStackable,
-  schema,
-  version: packageJson.version
+export async function create (configOrRoot, sourceOrConfig, context) {
+  const config = await loadConfiguration(configOrRoot, sourceOrConfig, context)
+  return new RemixCapability(config[kMetadata].root, config, context)
 }
+
+export * from './lib/capability.js'
+export { packageJson, schema, schemaComponents, version } from './lib/schema.js'