nmtjs 0.15.0-beta.2 → 0.15.0-beta.20

package/src/typings.ts

@@ -0,0 +1,30 @@
+import { mkdir, writeFile } from 'node:fs/promises'
+import { resolve } from 'node:path'
+
+import dedent from 'dedent'
+
+export async function generateTypings(
+  applicationImports: Record<
+    string,
+    { path: string; specifier: string; type: 'neemata' | 'custom' }
+  >,
+) {
+  await mkdir('.neemata', { recursive: true }).catch(() => {})
+  await writeFile(
+    resolve('.neemata', 'types.d.ts'),
+    dedent`
+    /// <reference types="nmtjs/runtime/types" />
+
+    declare module 'nmtjs/runtime/types' {
+      interface Applications {
+        ${Object.entries(applicationImports)
+          .map(
+            ([appName, { specifier, type }]) =>
+              `'${appName}': { type: '${type}'; definition: typeof import('${specifier}').default }`,
+          )
+          .join('\n')}
+      }
+    }
+    `,
+  )
+}

package/src/vite/builder.ts

@@ -0,0 +1,122 @@
+import { isBuiltin } from 'node:module'
+import { resolve } from 'node:path'
+
+import { build as viteBuild } from 'vite'
+
+import type { NeemataConfig } from '../config.ts'
+import type { ViteConfigOptions } from './config.ts'
+// import pkgJson from '../../package.json' with { type: 'json' }
+import { createConfig } from './config.ts'
+import { buildPlugins } from './plugins.ts'
+
+export async function createBuilder(
+  configOptions: ViteConfigOptions,
+  neemataConfig: NeemataConfig,
+) {
+  const config = createConfig(configOptions)
+  async function build(): Promise<any> {
+    const packageJson = await import(resolve('./package.json'), {
+      with: { type: 'json' },
+    }).then((mod) => mod.default)
+
+    // techinically it's possible to do the same with rolldown directly,
+    // but vite handles a lot of things, like defines substitutions, etc.
+    // also, since during dev the code is processed via vite anyway,
+    // using vite for build as well ensures consistency between dev and prod
+    return await viteBuild({
+      appType: 'custom',
+      clearScreen: false,
+      resolve: { alias: config.alias },
+      ssr: { noExternal: true },
+      plugins: [...buildPlugins, ...neemataConfig.plugins],
+      build: {
+        lib: { entry: config.entries, formats: ['es'] },
+        ssr: true,
+        target: 'node20',
+        sourcemap: true,
+        outDir: resolve(neemataConfig.build.outDir),
+        minify: neemataConfig.build.minify,
+        emptyOutDir: true,
+        rolldownOptions: {
+          platform: 'node',
+          external: (id) => {
+            if (neemataConfig.externalDependencies === 'all') return true
+            if (
+              isBuiltin(id) ||
+              id.includes('vite/server') ||
+              id.endsWith('.node')
+            )
+              return true
+
+            if (neemataConfig.externalDependencies === 'prod') {
+              const prodDeps = Object.keys(packageJson.dependencies ?? {})
+              if (prodDeps.includes(id)) return true
+            }
+
+            if (Array.isArray(neemataConfig.externalDependencies)) {
+              for (const dep of neemataConfig.externalDependencies) {
+                if (typeof dep === 'string' && dep === id) return true
+                if (dep instanceof RegExp && dep.test(id)) return true
+              }
+            }
+
+            return false
+          },
+          transform: {
+            define: {
+              __VITE_CONFIG__: '""',
+              __APPLICATIONS_CONFIG__: JSON.stringify(
+                JSON.stringify(
+                  Object.fromEntries(
+                    Object.entries(configOptions.applicationImports).map(
+                      ([appName, { type }]) => [
+                        appName,
+                        { type, specifier: `./application.${appName}.js` },
+                      ],
+                    ),
+                  ),
+                ),
+              ),
+              __dirname: 'new URL(".", import.meta.url).pathname',
+              __filename: 'new URL(import.meta.url).pathname',
+            },
+          },
+          output: {
+            entryFileNames: '[name].js',
+            chunkFileNames: 'chunks/[name]-[hash].js',
+            advancedChunks: {
+              groups: [
+                {
+                  name: 'ioredis',
+                  test: /node_modules[\\/](@ioredis|ioredis|redis)/,
+                  priority: 4,
+                },
+                {
+                  name: 'bullmq',
+                  test: /node_modules[\\/]bullmq/,
+                  priority: 2,
+                },
+                { name: 'zod', test: /node_modules[\\/]zod/, priority: 2 },
+                { name: 'pino', test: /node_modules[\\/]pino/, priority: 2 },
+                {
+                  name: '@nmtjs-runtime',
+                  test: /node_modules[\\/](@nmtjs[\\/]runtime)/,
+                  priority: 2,
+                },
+                {
+                  name: '@nmtjs-common',
+                  test: /node_modules[\\/]@nmtjs[\\/](?=[^runtime|nmtjs])/,
+                  priority: 1,
+                },
+                { name: 'vendor', test: /node_modules/, priority: 0 },
+              ],
+            },
+            minify: neemataConfig.build.minify,
+          },
+        },
+        chunkSizeWarningLimit: 10_000,
+      },
+    })
+  }
+  return { build }
+}

package/src/vite/config.ts

@@ -0,0 +1,45 @@
+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(
+    import.meta.resolve(`../entrypoints/main${ext}`),
+  ),
+  entrypointWorkerPath: fileURLToPath(
+    import.meta.resolve(`../entrypoints/worker${ext}`),
+  ),
+  entrypointThreadPath: fileURLToPath(
+    import.meta.resolve(`../entrypoints/thread${ext}`),
+  ),
+  // 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

@@ -0,0 +1,26 @@
+import { dirname, join } from 'node:path'
+
+import type { Plugin } from 'vite'
+import type { Target } from 'vite-plugin-static-copy'
+import { viteStaticCopy } from 'vite-plugin-static-copy'
+
+import { resolver } from '../resolver.ts'
+
+const targets: Target[] = []
+
+try {
+  const { path } = resolver.sync(process.cwd(), '@nmtjs/proxy')
+  if (path) {
+    targets.push({
+      src: join(
+        dirname(path),
+        `neemata-proxy.${process.platform}-${process.arch}*.node`,
+      ),
+      dest: './chunks/',
+    })
+  }
+} catch {}
+
+export const buildPlugins: Plugin[] = [
+  ...(targets.length ? viteStaticCopy({ targets }) : []),
+]

package/src/vite/runners/worker.ts

@@ -0,0 +1,57 @@
+import {
+  BroadcastChannel,
+  isInternalThread,
+  isMainThread,
+  parentPort,
+  threadId,
+} from 'node:worker_threads'
+
+import type { HotPayload } from 'vite'
+import type { ModuleRunnerTransport } from 'vite/module-runner'
+import { noopFn } from '@nmtjs/common'
+import {
+  createNodeImportMeta,
+  ESModulesEvaluator,
+  ModuleRunner,
+} from 'vite/module-runner'
+
+export function createBroadcastChannel(threadId: number): BroadcastChannel {
+  return new BroadcastChannel(`nmtjs:vite:${threadId}`)
+}
+
+export function createModuleRunner(
+  mode: 'development' | 'production' = 'development',
+): ModuleRunner {
+  if (isMainThread || isInternalThread)
+    throw new Error('Module runner can only be created inside worker threads.')
+
+  const channel = createBroadcastChannel(threadId)
+
+  const transport: ModuleRunnerTransport = {
+    connect({ onMessage, onDisconnection }) {
+      // @ts-expect-error
+      channel.onmessage = (event: MessageEvent<HotPayload>) => {
+        onMessage(event.data)
+      }
+      parentPort!.on('close', onDisconnection)
+    },
+    send(data) {
+      channel.postMessage(data)
+    },
+    timeout: 5000,
+  }
+
+  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

@@ -0,0 +1,39 @@
+import type { DevEnvironmentOptions, UserConfig } from 'vite'
+import { createServer as createViteServer } from 'vite'
+
+import type { ViteConfigOptions } from './config.ts'
+
+export function createServer(
+  options: ViteConfigOptions,
+  config: UserConfig,
+  dev: DevEnvironmentOptions = {},
+) {
+  return createViteServer({
+    ...config,
+    server: { middlewareMode: true, ws: false },
+    resolve: { tsconfigPaths: true, ...config.resolve },
+    environments: {
+      neemata: {
+        consumer: 'server',
+        dev,
+        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

@@ -0,0 +1,34 @@
+import type { ViteDevServer } from 'vite'
+import type { ModuleRunner } from 'vite/module-runner'
+import { noopFn } from '@nmtjs/common'
+import { createServerModuleRunner } from 'vite'
+
+import type { NeemataConfig } from '../../config.ts'
+import type { ViteConfigOptions } from '../config.ts'
+import { createConfig } from '../config.ts'
+import { buildPlugins } from '../plugins.ts'
+import { createServer } from '../server.ts'
+
+export async function createMainServer(
+  options: ViteConfigOptions,
+  mode: 'development' | 'production',
+  neemataConfig: NeemataConfig,
+): Promise<{ server: ViteDevServer; runner: ModuleRunner }> {
+  const config = createConfig(options)
+  const server = await createServer(options, {
+    appType: 'custom',
+    clearScreen: false,
+    resolve: { alias: config.alias },
+    mode,
+    plugins: [...buildPlugins, ...neemataConfig.plugins],
+  })
+  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

@@ -0,0 +1,143 @@
+import type EventEmitter from 'node:events'
+import type { BroadcastChannel, Worker } from 'node:worker_threads'
+
+import type {
+  HotChannel,
+  HotChannelClient,
+  HotChannelListener,
+  HotPayload,
+  ViteDevServer,
+} from 'vite'
+import { DevEnvironment } from 'vite'
+
+import type { NeemataConfig } from '../../config.ts'
+import type { ViteConfigOptions } from '../config.ts'
+import { createConfig } from '../config.ts'
+import { buildPlugins } from '../plugins.ts'
+import { createBroadcastChannel } from '../runners/worker.ts'
+import { createServer } from '../server.ts'
+
+export type WorkerServerEventMap = {
+  worker: [Worker]
+  'worker-error': [unknown]
+  'worker-ready': [unknown]
+}
+
+export async function createWorkerServer(
+  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(globalThis._hotAccept) }`
+
+  const server = await createServer(
+    options,
+    {
+      appType: 'custom',
+      clearScreen: false,
+      resolve: { alias: config.alias },
+      mode,
+      plugins: [
+        ...buildPlugins,
+        ...neemataConfig.plugins,
+        mode === 'development'
+          ? [
+              {
+                name: 'neemata-worker-application-hmr',
+                transform(code, id, options) {
+                  if (applicationEntries.includes(id)) {
+                    return code + _injectHmr
+                  }
+                },
+              },
+            ]
+          : [],
+      ],
+    },
+    {
+      createEnvironment: async (name, config, context) => {
+        const channels = new Map<number, BroadcastChannel>()
+        const clients = new Map<BroadcastChannel, HotChannelClient>()
+        const handlers = new Map<string, HotChannelListener>()
+
+        events.on('worker', (worker) => {
+          const channel = createBroadcastChannel(worker.threadId)
+          channel.onmessage = (event) => {
+            const value = event.data
+            const handler = handlers.get(value.event)
+            if (handler) handler(value.data, client)
+          }
+          channels.set(worker.threadId, channel)
+          const client = {
+            send: (payload: HotPayload) => {
+              channel.postMessage(payload)
+            },
+          }
+          clients.set(channel, client)
+          worker.on('exit', () => {
+            const handler = handlers.get('vite:client:disconnect')
+            if (handler) handler(undefined, client)
+          })
+        })
+
+        const transport: HotChannel = {
+          send(data) {
+            for (const channel of channels.values()) {
+              channel.postMessage(data)
+            }
+          },
+          on(event, handler) {
+            handlers.set(event, handler)
+          },
+          off(event) {
+            handlers.delete(event)
+          },
+        }
+
+        let lastError: any
+
+        events.on('worker-error', (payload: any) => {
+          lastError = payload?.error ?? payload
+          const error =
+            lastError instanceof Error
+              ? lastError
+              : new Error(String(lastError))
+          const message = {
+            type: 'error',
+            err: {
+              message: error.message,
+              stack: error.stack ?? '',
+              plugin: 'neemata:worker',
+            },
+          } satisfies HotPayload
+          for (const client of clients.values()) {
+            client.send(message)
+          }
+        })
+
+        events.on('worker-ready', () => {
+          if (!lastError) return
+          lastError = undefined
+          const message: HotPayload = { type: 'full-reload' }
+          for (const client of clients.values()) {
+            client.send(message)
+          }
+        })
+
+        const environment = new DevEnvironment(name, config, {
+          hot: mode === 'development',
+          transport,
+        })
+
+        return environment
+      },
+    },
+  )
+  return server
+}

package/dist/_exports/application.js

@@ -1 +0,0 @@
-export * from '@nmtjs/runtime/application';

package/dist/_exports/common.js

@@ -1 +0,0 @@
-export * from '@nmtjs/common';

package/dist/_exports/contract.js

@@ -1,2 +0,0 @@
-export * from '@nmtjs/contract';
-export { default } from '@nmtjs/contract';

package/dist/_exports/core.js

@@ -1 +0,0 @@
-export * from '@nmtjs/core';

package/dist/_exports/gateway.js

@@ -1 +0,0 @@
-export * from '@nmtjs/gateway';

package/dist/_exports/http-transport/bun.js

@@ -1 +0,0 @@
-export * from '@nmtjs/http-transport/bun';

package/dist/_exports/http-transport/deno.js

@@ -1 +0,0 @@
-export * from '@nmtjs/http-transport/deno';

package/dist/_exports/http-transport/node.js

@@ -1 +0,0 @@
-export * from '@nmtjs/http-transport/node';

package/dist/_exports/http-transport.js

@@ -1 +0,0 @@
-export * from '@nmtjs/http-transport';

package/dist/_exports/json-format.js

@@ -1 +0,0 @@
-export * from '@nmtjs/json-format/server';

package/dist/_exports/protocol/client.js

@@ -1 +0,0 @@
-export * from '@nmtjs/protocol/client';

package/dist/_exports/protocol/server.js

@@ -1 +0,0 @@
-export * from '@nmtjs/protocol/server';

package/dist/_exports/protocol.js

@@ -1 +0,0 @@
-export * from '@nmtjs/protocol';

package/dist/_exports/runtime/types.js

@@ -1 +0,0 @@
-export * from '@nmtjs/runtime/types';

package/dist/_exports/runtime.js

@@ -1 +0,0 @@
-export * from '@nmtjs/runtime';

package/dist/_exports/type.js

@@ -1,2 +0,0 @@
-export * from '@nmtjs/type';
-export { default } from '@nmtjs/type';

package/dist/_exports/ws-transport/bun.js

@@ -1 +0,0 @@
-export * from '@nmtjs/ws-transport/bun';

package/dist/_exports/ws-transport/deno.js

@@ -1 +0,0 @@
-export * from '@nmtjs/ws-transport/deno';

package/dist/_exports/ws-transport/node.js

@@ -1 +0,0 @@
-export * from '@nmtjs/ws-transport/node';

package/dist/_exports/ws-transport.js

@@ -1 +0,0 @@
-export * from '@nmtjs/ws-transport';

package/dist/command.js

@@ -1,30 +0,0 @@
-// import type { ApplicationWorker } from '@nmtjs/runtime/worker'
-// import { typeToString } from '@nmtjs/type'
-// import { defineCommand } from 'citty'
-export {};
-// export default (worker: ApplicationWorker) =>
-//   defineCommand({
-//     meta: { description: 'Application CLI' },
-//     subCommands: {
-//       list: defineCommand({
-//         async run(ctx) {
-//           worker.app.initializeCore()
-//           const commands = Array.from(worker.app.registry.commands).map(
-//             ([name, command]) => ({
-//               command: name,
-//               args: typeToString(command.args),
-//               kwargs: typeToString(command.kwargs),
-//             }),
-//           )
-//           console.table(commands, ['command', 'args', 'kwargs'])
-//         },
-//       }),
-//       execute: defineCommand({
-//         async run(ctx) {
-//           const { _: positionals, ...kwargs } = ctx.args
-//           const [commandName, ...args] = positionals
-//           await worker.runCommand(commandName, args, kwargs)
-//         },
-//       }),
-//     },
-//   })