@platformatic/basic 3.4.1 → 3.5.1

package/config.d.ts

@@ -5,7 +5,327 @@
  * and run json-schema-to-typescript to regenerate this file.
  */
 
-export interface PlatformaticStackable {
+export interface PlatformaticBasicConfig {
   $schema?: 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;
+    }[];
+  };
   [k: string]: unknown;
 }

package/eslint.config.js

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

package/index.d.ts

@@ -0,0 +1,81 @@
+export interface StartOptions {
+  listen?: boolean
+}
+
+export type BaseContext = Partial<{
+  applicationId: string
+  isEntrypoint: boolean
+  isProduction: boolean
+  isStandalone: boolean
+  directory: string
+  telemetryConfig: object
+  metricsConfig: object
+  serverConfig: object
+  hasManagementApi: boolean
+}>
+
+export interface BaseOptions<Context = BaseContext> {
+  context: Context
+}
+
+export declare const schemaOptions: Partial<Record<string, unknown>>
+
+export class BaseCapability<Config = Record<string, any>, Options = BaseOptions> {
+  basePath: string
+  constructor (
+    type: string,
+    version: string,
+    root: string,
+    config: object,
+    standardStreams?: Record<string, NodeJS.WritableStream>
+  )
+
+  init (): Promise<void>
+  start (options: StartOptions): Promise<void>
+  stop (): Promise<void>
+  build (): Promise<void>
+  getUrl (): string
+  updateContext (context: Partial<BaseContext>): Promise<void>
+  getConfig (includeMeta?: boolean): Promise<object>
+  getInfo (): Promise<{ type: string; version: string }>
+  getDispatchFunc (): Promise<Function>
+  getDispatchTarget (): Promise<Function | string>
+  getOpenapiSchema (): Promise<object>
+  getGraphqlSchema (): Promise<string>
+  setConnectionStatus (status: string): Promise<void>
+  setOpenapiSchema (schema: object): Promise<void>
+  setGraphqlSchema (schema: string): Promise<void>
+  setCustomHealthCheck (
+    healthCheck: () =>
+      | boolean
+      | Promise<boolean>
+      | { status: boolean; statusCode?: number; body?: string }
+      | Promise<{ status: boolean; statusCode?: number; body?: string }>
+  ): Promise<void>
+  setCustomReadinessCheck (
+    readinessCheck: () =>
+      | boolean
+      | Promise<boolean>
+      | { status: boolean; statusCode?: number; body?: string }
+      | Promise<{ status: boolean; statusCode?: number; body?: string }>
+  ): Promise<void>
+  collectMetrics (): Promise<any>
+  getMetrics ({ format: string }): Promise<string | Array<object>>
+  getMeta (): Promise<object>
+  inject (injectParams: string | object): Promise<{
+    statusCode: number
+    statusMessage: string
+    headers: object
+    body: object
+  }>
+  log (options: { message: string; level: string }): Promise<void>
+  getWatchConfig (): Promise<{
+    enabled: boolean
+    path: string
+    allow?: string[]
+    ignore?: string[]
+  }>
+
+  _initializeLogger (options: object): Promise<void>
+  _collectMetrics (): Promise<void>
+}

package/index.js

@@ -1,159 +1,8 @@
-import { existsSync } from 'node:fs'
-import { readFile } from 'node:fs/promises'
-import { createRequire } from 'node:module'
-import { relative, resolve } from 'node:path'
-import { workerData } from 'node:worker_threads'
-import pino from 'pino'
-import { packageJson, schema } from './lib/schema.js'
-import { importFile } from './lib/utils.js'
-
-const importStackablePackageMarker = '__pltImportStackablePackage.js'
-
-export const configCandidates = [
-  'platformatic.application.json',
-  'platformatic.json',
-  'watt.json',
-  'platformatic.application.yaml',
-  'platformatic.yaml',
-  'watt.yaml',
-  'platformatic.application.yml',
-  'platformatic.yml',
-  'watt.yml',
-  'platformatic.application.toml',
-  'platformatic.toml',
-  'watt.toml',
-  'platformatic.application.tml',
-  'platformatic.tml',
-  'watt.tml'
-]
-
-function isImportFailedError (error, pkg) {
-  if (error.code !== 'ERR_MODULE_NOT_FOUND' && error.code !== 'MODULE_NOT_FOUND') {
-    return false
-  }
-
-  const match = error.message.match(/Cannot find package '(.+)' imported from (.+)/)
-
-  return match?.[1] === pkg || error.requireStack?.[0].endsWith(importStackablePackageMarker)
-}
-
-async function importStackablePackage (opts, pkg, autodetectDescription) {
-  try {
-    try {
-      // Try regular import
-      return await import(pkg)
-    } catch (e) {
-      if (!isImportFailedError(e, pkg)) {
-        throw e
-      }
-
-      // Scope to the service
-      const require = createRequire(resolve(opts.context.directory, importStackablePackageMarker))
-      const imported = require.resolve(pkg)
-      return await importFile(imported)
-    }
-  } catch (e) {
-    if (!isImportFailedError(e, pkg)) {
-      throw e
-    }
-
-    const serviceDirectory = relative(workerData.dirname, opts.context.directory)
-    throw new Error(
-      `Unable to import package '${pkg}'. Please add it as a dependency  in the package.json file in the folder ${serviceDirectory}.`
-    )
-  }
-}
-
-async function buildStackable (opts) {
-  const root = opts.context.directory
-  let toImport = '@platformatic/node'
-  let autodetectDescription = 'is using a generic Node.js application'
-
-  let rootPackageJson
-  try {
-    rootPackageJson = JSON.parse(await readFile(resolve(root, 'package.json'), 'utf-8'))
-  } catch {
-    rootPackageJson = {}
-  }
-
-  const hadConfig = opts.config
-
-  if (!hadConfig) {
-    for (const candidate of configCandidates) {
-      const candidatePath = resolve(root, candidate)
-
-      if (existsSync(candidatePath)) {
-        opts.config = candidatePath
-        break
-      }
-    }
-  }
-
-  const { dependencies, devDependencies } = rootPackageJson
-
-  if (dependencies?.next || devDependencies?.next) {
-    autodetectDescription = 'is using Next.js'
-    toImport = '@platformatic/next'
-  } else if (dependencies?.['@remix-run/dev'] || devDependencies?.['@remix-run/dev']) {
-    autodetectDescription = 'is using Remix'
-    toImport = '@platformatic/remix'
-  } else if (dependencies?.vite || devDependencies?.vite) {
-    autodetectDescription = 'is using Vite'
-    toImport = '@platformatic/vite'
-  } else if (dependencies?.astro || devDependencies?.astro) {
-    autodetectDescription = 'is using Astro'
-    toImport = '@platformatic/astro'
-  }
-
-  const imported = await importStackablePackage(opts, toImport, autodetectDescription)
-
-  const serviceRoot = relative(process.cwd(), opts.context.directory)
-  if (
-    !hadConfig &&
-    !existsSync(resolve(serviceRoot, 'platformatic.json') || existsSync(resolve(serviceRoot, 'watt.json')))
-  ) {
-    const logger = pino({
-      level: opts.context.serverConfig?.logger?.level ?? 'warn',
-      name: opts.context.serviceId
-    })
-
-    logger.warn(
-      [
-        `Platformatic has auto-detected that service ${opts.context.serviceId} ${autodetectDescription}.\n`,
-        `We suggest you create a platformatic.json or watt.json file in the folder ${serviceRoot} with the "$schema" `,
-        `property set to "https://schemas.platformatic.dev/${toImport}/${packageJson.version}.json".`
-      ].join('')
-    )
-  }
-
-  return imported.buildStackable(opts)
-}
-
-/* c8 ignore next 3 */
-export function transformConfig () {
-  // This is currently empty but it left as a placeholder for the future
-}
-
-export const schemaOptions = {
-  useDefaults: true,
-  coerceTypes: true,
-  allErrors: true,
-  strict: false
-}
-
-export default {
-  configType: 'nodejs',
-  configManagerConfig: {
-    schemaOptions,
-    transformConfig
-  },
-  buildStackable,
-  schema,
-  version: packageJson.version
-}
-
-export * from './lib/base.js'
+export * from './lib/capability.js'
+export * from './lib/config.js'
+export * from './lib/creation.js'
 export * as errors from './lib/errors.js'
+export * from './lib/modules.js'
 export { schema, schemaComponents } from './lib/schema.js'
 export * from './lib/utils.js'
 export * from './lib/worker/child-manager.js'