nmtjs 0.16.0 → 0.17.0-beta.1

package/src/vite/config.ts

@@ -1,45 +0,0 @@
-import { fileURLToPath } from 'node:url'
-
-export type ViteConfigOptions = {
-  applicationImports: Record<
-    string,
-    { path: string; specifier: string; type: 'neemata' | 'custom' }
-  >
-  serverEntryPath: string
-  entrypointMainPath: string
-  entrypointWorkerPath: string
-  entrypointThreadPath: string
-  // entrypointCLIPath: string
-  configPath: string
-}
-
-const ext = new URL(import.meta.url).pathname.endsWith('.ts') ? '.ts' : '.js'
-
-export const baseViteConfigOptions = {
-  entrypointMainPath: fileURLToPath(
-    new URL(`../entrypoints/main${ext}`, import.meta.url),
-  ),
-  entrypointWorkerPath: fileURLToPath(
-    new URL(`../entrypoints/worker${ext}`, import.meta.url),
-  ),
-  entrypointThreadPath: fileURLToPath(
-    new URL(`../entrypoints/thread${ext}`, import.meta.url),
-  ),
-  // entrypointCLIPath: fileURLToPath(import.meta.resolve('../entrypoints/cli')),
-} satisfies Partial<ViteConfigOptions>
-
-export function createConfig(options: ViteConfigOptions) {
-  const alias = { '#server': options.serverEntryPath }
-  const entries = {
-    server: options.serverEntryPath,
-    main: options.entrypointMainPath,
-    thread: options.entrypointThreadPath,
-    worker: options.entrypointWorkerPath,
-  }
-
-  for (const [name, { path }] of Object.entries(options.applicationImports)) {
-    entries[`application.${name}`] = path
-  }
-
-  return { alias, entries }
-}

package/src/vite/plugins.ts

@@ -1,53 +0,0 @@
-import { existsSync } from 'node:fs'
-import { readFile } from 'node:fs/promises'
-import { basename, dirname, join } from 'node:path'
-
-import type { Plugin } from 'vite'
-
-export const plugins: Plugin[] = [
-  {
-    name: 'neemata:native-addon',
-    apply: 'build',
-    enforce: 'pre',
-
-    async load(id) {
-      if (id.endsWith('.node') && existsSync(id)) {
-        const refId = this.emitFile({
-          type: 'asset',
-          name: basename(id),
-          source: await readFile(id),
-        })
-        const runtimePath = `./${this.getFileName(refId)}`
-        return (
-          `const id = ${JSON.stringify(runtimePath)};` +
-          `export default require(id);`
-        )
-      }
-      return null
-    },
-  },
-  {
-    name: 'neemata:uws-native-addon',
-    apply: 'build',
-    enforce: 'post',
-    async load(id) {
-      if (id.includes('uWebSockets.js/uws.js')) {
-        const uwsNodeAddonPath = join(
-          dirname(id),
-          `uws_${process.platform}_${process.arch}_${process.versions.modules}.node`,
-        )
-        const refId = this.emitFile({
-          type: 'asset',
-          name: basename(uwsNodeAddonPath),
-          source: await readFile(uwsNodeAddonPath),
-        })
-        const runtimePath = `./${this.getFileName(refId)}`
-        return (
-          `const id = ${JSON.stringify(runtimePath)};` +
-          `export default require(id);`
-        )
-      }
-      return null
-    },
-  },
-]

package/src/vite/runners/worker.ts

@@ -1,55 +0,0 @@
-import type { MessagePort } from 'node:worker_threads'
-import wt, { isMainThread } from 'node:worker_threads'
-
-import type { ModuleRunnerTransport } from 'vite/module-runner'
-import { noopFn } from '@nmtjs/common'
-import {
-  createNodeImportMeta,
-  ESModulesEvaluator,
-  ModuleRunner,
-} from 'vite/module-runner'
-
-export function createModuleRunner(
-  vitePort: MessagePort | undefined,
-  mode: 'development' | 'production' = 'development',
-  timeoutMs = 5000,
-): ModuleRunner {
-  // TODO: bun does not support isInternalThread yet
-  if (isMainThread || wt.isInternalThread)
-    throw new Error('Module runner can only be created inside worker threads.')
-
-  if (!vitePort) {
-    throw new Error('Module runner requires a dedicated Vite message port.')
-  }
-
-  const transportTimeout =
-    Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : 5000
-
-  const transport: ModuleRunnerTransport = {
-    connect({ onMessage, onDisconnection }) {
-      vitePort.on('message', onMessage)
-      vitePort.on('close', onDisconnection)
-    },
-    send(data) {
-      vitePort.postMessage(data)
-    },
-    disconnect() {
-      vitePort.close()
-    },
-    timeout: transportTimeout,
-  }
-
-  const runner = new ModuleRunner(
-    {
-      transport,
-      createImportMeta: createNodeImportMeta,
-      hmr:
-        mode === 'development'
-          ? { logger: { debug: noopFn, error: console.error } }
-          : false,
-    },
-    new ESModulesEvaluator(),
-  )
-
-  return runner
-}

package/src/vite/server.ts

@@ -1,55 +0,0 @@
-import type { DevEnvironmentOptions, UserConfig } from 'vite'
-import { createServer as createViteServer } from 'vite'
-
-import type { ViteConfigOptions } from './config.ts'
-
-// Packages that must NOT be externalized to prevent module duplication.
-// When externalized, Vite's ModuleRunner uses native Node import() which has
-// a separate module cache from Vite's cache, causing the same module to be
-// loaded twice with different object references.
-const noExternalPackages = ['nmtjs', /^@nmtjs\/(?!prom-client$)/]
-
-export function createServer(
-  options: ViteConfigOptions,
-  config: UserConfig,
-  dev: DevEnvironmentOptions = {},
-) {
-  const usePolling = !!process.env.CI
-
-  return createViteServer({
-    ...config,
-    server: {
-      middlewareMode: true,
-      ws: false,
-      watch: usePolling ? { usePolling: true } : undefined,
-    },
-    resolve: { tsconfigPaths: true, ...config.resolve },
-    environments: {
-      neemata: {
-        consumer: 'server',
-        dev,
-        resolve: {
-          // Ensure nmtjs packages are not externalized in this environment
-          noExternal: noExternalPackages,
-        },
-        define: {
-          __VITE_CONFIG__: JSON.stringify(
-            JSON.stringify({ options, mode: config.mode }),
-          ),
-          __APPLICATIONS_CONFIG__: JSON.stringify(
-            JSON.stringify(
-              Object.fromEntries(
-                Object.entries(options.applicationImports).map(
-                  ([appName, { path, type }]) => [
-                    appName,
-                    { specifier: path, type },
-                  ],
-                ),
-              ),
-            ),
-          ),
-        },
-      },
-    },
-  })
-}

package/src/vite/servers/main.ts

@@ -1,41 +0,0 @@
-import type { UserConfig, ViteDevServer } from 'vite'
-import type { ModuleRunner } from 'vite/module-runner'
-import { noopFn } from '@nmtjs/common'
-import { createServerModuleRunner, mergeConfig } from 'vite'
-
-import type { NeemataConfig } from '../../config.ts'
-import type { ViteConfigOptions } from '../config.ts'
-import { createConfig } from '../config.ts'
-import { plugins } from '../plugins.ts'
-import { createServer } from '../server.ts'
-
-export async function createMainServer(
-  options: ViteConfigOptions,
-  mode: 'development' | 'production',
-  { vite }: NeemataConfig,
-): Promise<{ server: ViteDevServer; runner: ModuleRunner }> {
-  const config = createConfig(options)
-  const server = await createServer(
-    options,
-    mergeConfig(
-      {
-        appType: 'custom',
-        clearScreen: false,
-        resolve: { alias: config.alias, external: ['@nmtjs/proxy'] },
-        mode,
-        plugins: [...plugins],
-        optimizeDeps: { noDiscovery: true },
-      } satisfies UserConfig,
-      vite,
-    ),
-  )
-  const environment = server.environments.neemata
-
-  const runner = createServerModuleRunner(environment, {
-    hmr:
-      mode === 'development'
-        ? { logger: { debug: noopFn, error: console.error } }
-        : false,
-  })
-  return { server, runner }
-}

package/src/vite/servers/worker.ts

@@ -1,177 +0,0 @@
-import type EventEmitter from 'node:events'
-import type { MessagePort, Worker } from 'node:worker_threads'
-
-import type {
-  HotChannel,
-  HotChannelClient,
-  HotChannelListener,
-  HotPayload,
-  Plugin,
-  UserConfig,
-  ViteDevServer,
-} from 'vite'
-import { DevEnvironment, mergeConfig } from 'vite'
-
-import type { NeemataConfig } from '../../config.ts'
-import type { WorkerRegistration } from '../../runtime/server/types.ts'
-import type { ViteConfigOptions } from '../config.ts'
-import { createConfig } from '../config.ts'
-import { plugins } from '../plugins.ts'
-import { createServer } from '../server.ts'
-
-export type WorkerServerEventMap = {
-  worker: [WorkerRegistration]
-  /** Emitted when an HMR update occurs for an application file (useful for restarting dead workers) */
-  'hmr-update': [{ file: string }]
-}
-
-export async function createViteServer(
-  options: ViteConfigOptions,
-  mode: 'development' | 'production',
-  neemataConfig: NeemataConfig,
-  events: EventEmitter<WorkerServerEventMap>,
-): Promise<ViteDevServer> {
-  const config = createConfig(options)
-  const applicationEntries = Object.values(options.applicationImports).map(
-    (v) => v.path,
-  )
-
-  const _injectHmr = `\n\nif(import.meta.hot) { import.meta.hot.accept((module) => globalThis._hotAccept?.(module)) }`
-
-  const server = await createServer(
-    options,
-    mergeConfig(neemataConfig.vite, {
-      appType: 'custom',
-      clearScreen: false,
-      resolve: { alias: config.alias, external: ['@nmtjs/proxy'] },
-      mode,
-      optimizeDeps: { noDiscovery: true },
-      plugins: [
-        ...plugins,
-        ...(mode === 'development'
-          ? [
-              {
-                name: 'neemata-worker-application-hmr',
-                transform(code, id, _options) {
-                  if (applicationEntries.includes(id)) {
-                    return code + _injectHmr
-                  }
-                },
-                handleHotUpdate(ctx) {
-                  // Emit event when application entry files change
-                  // This allows restarting failed workers after code fixes
-                  if (ctx.file && applicationEntries.includes(ctx.file)) {
-                    events.emit('hmr-update', { file: ctx.file })
-                  }
-                },
-              } satisfies Plugin,
-            ]
-          : []),
-      ],
-    } satisfies UserConfig),
-    {
-      createEnvironment: async (name, config, context) => {
-        const connections = new Map<
-          number,
-          { worker: Worker; port: MessagePort; client: HotChannelClient }
-        >()
-        const clients = new Map<number, HotChannelClient>()
-        const handlers = new Map<string, Set<Function>>()
-
-        const emit = (
-          event: string,
-          data: unknown,
-          client: HotChannelClient,
-        ) => {
-          const listeners = handlers.get(event)
-          if (!listeners?.size) return
-          for (const listener of listeners) {
-            ;(listener as HotChannelListener)(data, client)
-          }
-        }
-
-        events.on('worker', ({ worker, vitePort }) => {
-          if (!vitePort) return
-
-          const client: HotChannelClient = {
-            send: (payload: HotPayload) => {
-              vitePort.postMessage(payload)
-            },
-          }
-
-          const handleMessage = (value: HotPayload) => {
-            if (value.type === 'custom') {
-              emit(value.event, value.data, client)
-            }
-          }
-
-          let disconnected = false
-          const disconnect = (closePort: boolean) => {
-            if (disconnected) return
-            disconnected = true
-
-            emit('vite:client:disconnect', undefined, client)
-
-            vitePort.off('message', handleMessage)
-            worker.off('exit', handleWorkerExit)
-            vitePort.off('close', handlePortClose)
-
-            if (closePort) {
-              vitePort.close()
-            }
-
-            connections.delete(worker.threadId)
-            clients.delete(worker.threadId)
-          }
-
-          const handleWorkerExit = () => disconnect(true)
-          const handlePortClose = () => disconnect(false)
-
-          vitePort.on('message', handleMessage)
-          worker.once('exit', handleWorkerExit)
-          vitePort.once('close', handlePortClose)
-
-          connections.set(worker.threadId, { worker, port: vitePort, client })
-          clients.set(worker.threadId, client)
-
-          emit('vite:client:connect', undefined, client)
-        })
-
-        const transport: HotChannel = {
-          send(data) {
-            for (const connection of connections.values()) {
-              connection.port.postMessage(data)
-            }
-          },
-          on(event, handler) {
-            let listeners = handlers.get(event)
-            if (!listeners) {
-              listeners = new Set()
-              handlers.set(event, listeners)
-            }
-            listeners.add(handler)
-          },
-          off(event, handler) {
-            if (!handler) {
-              handlers.delete(event)
-              return
-            }
-
-            const listeners = handlers.get(event)
-            if (!listeners) return
-            listeners.delete(handler)
-            if (!listeners.size) {
-              handlers.delete(event)
-            }
-          },
-        }
-
-        return new DevEnvironment(name, config, {
-          hot: mode === 'development',
-          transport,
-        })
-      },
-    },
-  )
-  return server
-}