nmtjs 0.15.0-beta.2 → 0.15.0-beta.21

package/src/cli.ts

@@ -0,0 +1,144 @@
+#!/usr/bin/env node --enable-source-maps
+
+import { once } from 'node:events'
+import { relative, resolve } from 'node:path'
+import process from 'node:process'
+
+import type { ArgDef } from 'citty'
+import { defineCommand, runMain } from 'citty'
+import { config as dotenv } from 'dotenv'
+
+import type { NeemataConfig } from './config.ts'
+import type { ViteConfigOptions } from './vite/config.ts'
+import { resolver } from './resolver.ts'
+import { generateTypings } from './typings.ts'
+import { createBuilder } from './vite/builder.ts'
+import { baseViteConfigOptions } from './vite/config.ts'
+import { createMainServer } from './vite/servers/main.ts'
+
+// import { createMainRunner } from './vite/runner.ts'
+
+const commonArgs = {
+  config: {
+    type: 'string',
+    alias: 'c',
+    default: './neemata.config.ts',
+    description: 'Path to Neemata config file',
+    required: false,
+  },
+} satisfies Record<string, ArgDef>
+
+let config: NeemataConfig
+let viteConfigOptions: ViteConfigOptions
+let applicationImports: Record<
+  string,
+  { path: string; specifier: string; type: 'neemata' | 'custom' }
+>
+
+const mainCommand = defineCommand({
+  meta: { description: 'Neemata CLI' },
+  args: { ...commonArgs },
+  async setup(ctx) {
+    const configPath = resolve(ctx.args.config as string)
+    config = await import(configPath).then((m) => m.default)
+
+    for (const env of config.env) {
+      if (typeof env === 'string') {
+        const { error } = dotenv({ path: env })
+        if (error) console.warn(error)
+      } else if (typeof env === 'object') {
+        for (const key in env) {
+          process.env[key] = env[key]
+        }
+      }
+    }
+
+    // const applicationEntryPaths: Record<string, string> = {}
+    applicationImports = {}
+    const currentPkg = resolver.sync(process.cwd(), './package.json')
+
+    for (const [appName, { specifier: appSpecifier, type }] of Object.entries(
+      config.applications,
+    )) {
+      const resolution = resolver.sync(process.cwd(), appSpecifier)
+      if (resolution.error)
+        throw new Error(
+          `Failed to resolve application path for ${appName}: ${resolution.error}`,
+        )
+      if (!resolution.path)
+        throw new Error(
+          `Failed to resolve application path for ${appName}: no path found`,
+        )
+      const specifier =
+        resolution.packageJsonPath === currentPkg.path
+          ? relative(resolve('.neemata'), resolution.path)
+          : appSpecifier
+      applicationImports[appName] = { path: resolution.path, specifier, type }
+    }
+
+    viteConfigOptions = {
+      applicationImports,
+      serverEntryPath: resolve(config.serverPath),
+      ...baseViteConfigOptions,
+      configPath,
+    }
+  },
+  subCommands: {
+    prepare: defineCommand({
+      async run(ctx) {
+        await generateTypings(applicationImports)
+      },
+    }),
+    dev: defineCommand({
+      async run(ctx) {
+        const { runner } = await createMainServer(
+          viteConfigOptions,
+          'development',
+          config,
+        )
+        await runner.import(viteConfigOptions.entrypointMainPath)
+        await once(process, 'beforeExit')
+      },
+    }),
+    preview: defineCommand({
+      async run(ctx) {
+        const { runner } = await createMainServer(
+          viteConfigOptions,
+          'production',
+          config,
+        )
+        await runner.import(viteConfigOptions.entrypointMainPath)
+        await once(process, 'beforeExit')
+      },
+    }),
+    build: defineCommand({
+      async run(ctx) {
+        const builder = await createBuilder(viteConfigOptions, config)
+        await builder.build()
+      },
+    }),
+    // command: defineCommand({
+    //   async run(ctx) {
+    //     const runner = await createRunner(
+    //       viteConfigOptions,
+    //       'production',
+    //       config,
+    //     )
+    //     const workerModule = await runner.import<
+    //       typeof import('./entrypoints/worker.ts')
+    //     >(import.meta.resolve('./entrypoints/worker.js'))
+    //     const commandModule = await runner.import<
+    //       typeof import('./command.ts')
+    //     >(import.meta.resolve('./command.js'))
+    //     const worker = await workerModule.default({
+    //       applicationWorkerData: undefined,
+    //       type: ApplicationType.Command,
+    //       workerType: ApplicationWorkerType.Command,
+    //     })
+    //     await runMain(commandModule.default(worker), { rawArgs: ctx.rawArgs })
+    //   },
+    // }),
+  },
+})
+
+runMain(mainCommand)

package/src/config.ts

@@ -0,0 +1,64 @@
+import type { Plugin as VitePlugin } from 'vite'
+
+export type ExtrernalDependency = string | RegExp
+
+type DeepPartial<T> = {
+  [P in keyof T]?: T[P] extends Record<any, unknown> ? DeepPartial<T[P]> : T[P]
+}
+
+export interface NeemataConfig {
+  /**
+   * Path to application entry point
+   */
+  applications: {
+    /**
+     * Application name
+     */
+    [appName: string]: { type: 'neemata' | 'custom'; specifier: string }
+  }
+  /**
+   * Path to server entry point
+   */
+  serverPath: string
+  /**
+   * External dependencies to exclude from application bundle
+   *
+   * 'prod' - exclude production dependencies from package.json
+   *
+   * 'all' - exclude all dependencies from package.json
+   *
+   * ExtrernalDependency[] - array of package names or regular expressions to match package names
+   */
+  externalDependencies: 'prod' | 'all' | ExtrernalDependency[]
+  /**
+   * Timeout in milliseconds for graceful shutdown of application workers
+   */
+  timeout: number
+
+  /**
+   * Environment variables to set for application workers
+   *
+   * Strings are paths to .env files
+   * Records are key-value pairs to set directly
+   */
+  env: (Record<string, string> | string)[]
+
+  build: { outDir: string; minify: boolean }
+  plugins: VitePlugin[]
+}
+
+export function defineConfig(
+  config: DeepPartial<NeemataConfig> = {},
+): NeemataConfig {
+  return {
+    serverPath: './src/server.ts',
+    externalDependencies: 'prod',
+    timeout: 10000,
+    env: [],
+    plugins: [],
+    ...config,
+    // @ts-expect-error
+    applications: config.applications || {},
+    build: { outDir: './dist', minify: true, ...config.build },
+  }
+}

package/src/entrypoints/cli.ts

@@ -0,0 +1,13 @@
+// // import { ApplicationType, ApplicationWorkerType } from '@nmtjs/application'
+// import { runMain } from 'citty'
+
+// import command from '../command.ts'
+// import createWorker from './worker.ts'
+
+// const worker = await createWorker({
+//   applicationWorkerData: undefined,
+//   // type: ApplicationType.Command,
+//   // workerType: ApplicationWorkerType.Command,
+// })
+
+// runMain(command(worker))

package/src/entrypoints/main.ts

@@ -0,0 +1,200 @@
+import type { Worker } from 'node:worker_threads'
+import EventEmitter from 'node:events'
+import { fileURLToPath } from 'node:url'
+
+import type {
+  ApplicationWorkerErrorEvent,
+  ApplicationWorkerReadyEvent,
+  ServerConfig,
+} from 'nmtjs/runtime'
+import type { ViteDevServer } from 'vite'
+import { ApplicationServer, isServerConfig } from 'nmtjs/runtime'
+
+import type { WorkerServerEventMap as BaseWorkerServerEventMap } from '../vite/servers/worker.ts'
+
+declare global {
+  const __VITE_CONFIG__: string
+  const __APPLICATIONS_CONFIG__: string
+}
+
+class InvalidServerConfigError extends Error {
+  constructor() {
+    super(
+      `Server config file does not have a default export, or it is not a valid server config. Please, make sure the server config is defined using defineServer().`,
+    )
+    this.name = 'InvalidServerConfigError'
+  }
+}
+
+const _ext = new URL(import.meta.url).pathname.endsWith('.ts') ? '.ts' : '.js'
+const _vite = __VITE_CONFIG__ ? JSON.parse(__VITE_CONFIG__) : undefined
+const applicationsConfig: Record<
+  string,
+  { type: 'neemata' | 'custom'; specifier: string }
+> = __APPLICATIONS_CONFIG__ ? JSON.parse(__APPLICATIONS_CONFIG__) : {}
+
+type WorkerEventMap = BaseWorkerServerEventMap & {
+  'worker-error': [ApplicationWorkerErrorEvent]
+  'worker-ready': [ApplicationWorkerReadyEvent]
+}
+
+let _viteServerEvents: EventEmitter<WorkerEventMap> | undefined
+let _viteWorkerServer: ViteDevServer | undefined
+
+let server: ApplicationServer | undefined
+let hasActiveWorkerError = false
+const isDev = _vite?.mode === 'development'
+
+if (import.meta.env.DEV && import.meta.hot) {
+  import.meta.hot.accept('#server', async (module) => {
+    await shutdownServer()
+    await bootWithHandling(module?.default)
+  })
+}
+
+if (_vite) {
+  const { createWorkerServer } = await import('../vite/servers/worker.ts')
+  const neemataConfig = await import(
+    /* @vite-ignore */
+    _vite.options.configPath
+  ).then((m) => m.default as import('../config.ts').NeemataConfig)
+  _viteServerEvents = new EventEmitter<WorkerEventMap>()
+  _viteServerEvents.on('worker-error', handleWorkerError)
+  _viteServerEvents.on('worker-ready', handleWorkerReady)
+  _viteWorkerServer = await createWorkerServer(
+    _vite.options,
+    _vite.mode,
+    neemataConfig,
+    _viteServerEvents,
+  )
+}
+
+async function bootServer(configValue: ServerConfig | undefined) {
+  if (!isServerConfig(configValue)) throw new InvalidServerConfigError()
+  const workerConfig = {
+    path: fileURLToPath(import.meta.resolve(`./thread${_ext}`)),
+    workerData: { vite: _vite?.mode },
+    worker: _viteServerEvents
+      ? (worker: Worker) => {
+          _viteServerEvents.emit('worker', worker)
+        }
+      : undefined,
+    events: _viteServerEvents,
+  }
+  const appServer = new ApplicationServer(
+    configValue,
+    applicationsConfig,
+    workerConfig,
+  )
+
+  try {
+    await appServer.start()
+    server = appServer
+    clearWorkerErrorOverlay()
+  } catch (error) {
+    await appServer.stop().catch(() => {})
+    throw error
+  }
+}
+
+async function bootWithHandling(configValue: ServerConfig | undefined) {
+  try {
+    await bootServer(configValue)
+  } catch (error) {
+    handleStartupError(error)
+    if (!isDev) throw error
+  }
+}
+
+let isTerminating = false
+
+async function handleTermination() {
+  if (isTerminating) return
+  isTerminating = true
+  await shutdownServer()
+  _viteWorkerServer?.close()
+  process.exit(0)
+}
+
+function handleUnexpectedError(error: Error) {
+  console.error(new Error('Unexpected Error:', { cause: error }))
+}
+
+async function shutdownServer() {
+  if (!server) return
+  try {
+    await server.stop()
+  } catch (error) {
+    console.error(
+      new Error('Failed to stop application server', { cause: error as Error }),
+    )
+  } finally {
+    server = undefined
+  }
+}
+
+function handleWorkerError(event: ApplicationWorkerErrorEvent) {
+  hasActiveWorkerError = true
+  console.error(
+    new Error(`Worker ${event.application} thread ${event.threadId} error`, {
+      cause: event.error,
+    }),
+  )
+}
+
+function handleWorkerReady(_: ApplicationWorkerReadyEvent) {
+  clearWorkerErrorOverlay()
+}
+
+function handleStartupError(error: unknown) {
+  const normalized = error instanceof Error ? error : new Error(String(error))
+  if (_viteServerEvents) {
+    _viteServerEvents.emit('worker-error', {
+      application: 'server',
+      threadId: -1,
+      error: normalized,
+    } as ApplicationWorkerErrorEvent)
+  } else {
+    hasActiveWorkerError = true
+    console.error(
+      new Error('Failed to start application server', { cause: normalized }),
+    )
+  }
+}
+
+function clearWorkerErrorOverlay() {
+  if (!hasActiveWorkerError) return
+  hasActiveWorkerError = false
+}
+
+process.once('SIGTERM', handleTermination)
+process.once('SIGINT', handleTermination)
+process.on('uncaughtException', handleUnexpectedError)
+process.on('unhandledRejection', handleUnexpectedError)
+
+await bootWithHandling(
+  await import(
+    // @ts-expect-error
+    '#server'
+  ).then((m) => m.default),
+).catch(() => {
+  if (!isDev) process.exit(1)
+})
+
+const { format } = Intl.NumberFormat('en', {
+  notation: 'compact',
+  maximumFractionDigits: 2,
+  unit: 'byte',
+})
+
+const printMem = () => {
+  globalThis.gc?.()
+  // print memory usage every 10 seconds
+  const memoryUsage = process.memoryUsage()
+  console.log(
+    `Memory Usage: RSS=${format(memoryUsage.rss)}, HeapTotal=${format(memoryUsage.heapTotal)}, HeapUsed=${format(memoryUsage.heapUsed)}, External=${format(memoryUsage.external)}, ArrayBuffers=${format(memoryUsage.arrayBuffers)}`,
+  )
+}
+void printMem
+// printMem()
+// setInterval(printMem, 5000)

package/src/entrypoints/thread.ts

@@ -0,0 +1,184 @@
+import type { MessagePort } from 'node:worker_threads'
+import { fileURLToPath } from 'node:url'
+import { workerData as _workerData } from 'node:worker_threads'
+
+import type {
+  ThreadErrorMessage,
+  ThreadPortMessage,
+  WorkerThreadErrorOrigin,
+} from 'nmtjs/runtime'
+import type { ModuleRunner } from 'vite/module-runner'
+
+export type RunWorkerOptions = {
+  port: MessagePort
+  runtime:
+    | { type: 'application'; name: string; path: string; transportsData: any }
+    | { type: 'jobs'; jobWorkerPool: string }
+  vite?: 'development' | 'production'
+}
+
+const workerData = _workerData as RunWorkerOptions
+
+const ext = new URL(import.meta.url).pathname.endsWith('.ts') ? '.ts' : '.js'
+const workerPath = fileURLToPath(import.meta.resolve(`./worker${ext}`))
+
+type WorkerModule = typeof import('./worker.ts')
+type WorkerRuntime = Awaited<ReturnType<WorkerModule['run']>>
+
+const kReportedError = Symbol.for('nmtjs.worker.reported-error')
+
+let runner: ModuleRunner | undefined
+let workerModule: WorkerModule
+let runtime: WorkerRuntime | undefined
+let runtimeStarted = false
+
+process.on('uncaughtException', (error) => {
+  reportError(error, 'runtime', { fatal: true })
+})
+
+process.on('unhandledRejection', (error) => {
+  reportError(error, 'runtime', { fatal: true })
+})
+
+process.on('exit', () => {
+  void cleanup()
+})
+
+async function cleanup() {
+  await stopRuntime()
+  await closeRunner()
+}
+
+async function closeRunner() {
+  if (!runner) return
+  try {
+    await runner.close()
+  } catch (error) {
+    reportError(error, 'runtime', { fatal: false })
+  } finally {
+    runner = undefined
+  }
+}
+
+async function stopRuntime() {
+  if (!runtime) return
+  try {
+    if (runtimeStarted) {
+      await runtime.stop()
+    }
+  } catch (error) {
+    reportError(error, 'runtime', { fatal: false })
+  } finally {
+    runtimeStarted = false
+  }
+}
+
+function normalizeError(value: unknown): Error {
+  if (value instanceof Error) return value
+  if (typeof value === 'string') return new Error(value)
+  if (value && typeof value === 'object') {
+    try {
+      return new Error(JSON.stringify(value))
+    } catch {}
+  }
+  return new Error(String(value))
+}
+
+function serializeError(
+  error: Error,
+  origin: WorkerThreadErrorOrigin,
+  fatal: boolean,
+): ThreadErrorMessage {
+  return {
+    message: error.message,
+    name: error.name,
+    stack: error.stack,
+    origin,
+    fatal,
+  }
+}
+
+function reportError(
+  value: unknown,
+  origin: WorkerThreadErrorOrigin,
+  options: { fatal?: boolean } = {},
+): Error {
+  const fatal = options.fatal ?? origin !== 'runtime'
+  const error = normalizeError(value)
+  if (!(error as any)[kReportedError]) {
+    try {
+      workerData.port.postMessage({
+        type: 'error',
+        data: serializeError(error, origin, fatal),
+      } satisfies ThreadPortMessage)
+    } catch {}
+    console.error(new Error(`Worker thread ${origin} error`, { cause: error }))
+    ;(error as any)[kReportedError] = true
+  }
+  return error
+}
+
+async function loadWorkerModule() {
+  try {
+    if (workerData.vite) {
+      const { createModuleRunner } = (await import(
+        '../vite/runners/worker.ts'
+      )) as typeof import('../vite/runners/worker.ts')
+
+      runner = createModuleRunner(workerData.vite)
+      workerModule = await runner.import(workerPath)
+    } else {
+      runner = undefined
+      workerModule = await import(
+        /* @vite-ignore */
+        workerPath
+      )
+    }
+  } catch (error) {
+    throw reportError(error, 'bootstrap')
+  }
+}
+
+async function initializeRuntime() {
+  try {
+    runtime = await workerModule.run(workerData.runtime)
+  } catch (error) {
+    throw reportError(error, 'bootstrap')
+  }
+
+  workerData.port.on('message', async (msg) => {
+    if (msg.type === 'stop') {
+      await cleanup()
+      process.exit(0)
+    }
+  })
+}
+
+async function startRuntime() {
+  if (!runtime) return
+  try {
+    const hosts = (await runtime.start()) || undefined
+    runtimeStarted = true
+    workerData.port.postMessage({
+      type: 'ready',
+      data: { hosts },
+    } satisfies ThreadPortMessage)
+  } catch (error) {
+    throw reportError(error, 'start')
+  }
+}
+
+async function main() {
+  await loadWorkerModule()
+  await initializeRuntime()
+  await startRuntime()
+}
+
+main().catch(async (error) => {
+  const normalized = error instanceof Error ? error : normalizeError(error)
+  if (!(normalized as any)[kReportedError]) {
+    reportError(normalized, 'bootstrap')
+  }
+  await cleanup()
+  process.exit(1)
+})

package/src/entrypoints/worker.ts

@@ -0,0 +1,48 @@
+import { workerData } from 'node:worker_threads'
+
+import type { ServerConfig } from 'nmtjs/runtime'
+import {
+  ApplicationWorkerRuntime,
+  isApplicationConfig,
+  JobWorkerRuntime,
+} from 'nmtjs/runtime'
+
+import type { RunWorkerOptions } from './thread.ts'
+
+export async function run(options: RunWorkerOptions['runtime']) {
+  const serverConfig: ServerConfig = await import(
+    // @ts-expect-error
+    '#server'
+  ).then((m) => m.default)
+  if (options.type === 'application') {
+    globalThis._hotAccept = (module: any) => {
+      if (module) {
+        if (!isApplicationConfig(module.default))
+          throw new Error('Invalid application config')
+        runtime.reload(module.default)
+      }
+    }
+
+    const { name, path, transportsData } = options
+    const appConfig = await import(
+      /* @vite-ignore */
+      path
+    ).then((m) => m.default)
+
+    const runtime = new ApplicationWorkerRuntime(
+      serverConfig,
+      { name, path, transports: transportsData },
+      appConfig,
+    )
+    return runtime
+  } else if (options.type === 'jobs') {
+    const { jobWorkerPool } = options
+    const runtime = new JobWorkerRuntime(serverConfig, {
+      poolName: jobWorkerPool,
+      port: workerData.port,
+    })
+    return runtime
+  } else {
+    throw new Error(`Unknown runtime type: ${(workerData.runtime as any).type}`)
+  }
+}