pick: tegg service worker

pnpm-workspace.yaml

@@ -209,6 +209,7 @@ catalog:
   type-is: ^2.0.0
   typebox: ^1.0.65
   typescript: ^5.9.3
+  undici: ^7.10.0
   unplugin-unused: ^0.5.4
   urijs: ^1.19.11
   urllib: ^4.8.2

tegg/core/standalone-decorator/src/event/EventHandler.ts

@@ -0,0 +1,27 @@
+import { type EggProtoImplClass, ImplDecorator, SingletonProtoParams } from '@eggjs/tegg-types';
+import { QualifierImplDecoratorUtil, SingletonProto } from '@eggjs/tegg';
+
+export abstract class AbstractEventHandler<E = any, R = any> {
+  abstract handleEvent(event: E): Promise<R>;
+}
+
+export const EVENT_HANDLER_ATTRIBUTE = Symbol('EVENT_HANDLER_ATTRIBUTE');
+
+export type EventType = Record<string, string>;
+
+export const EventHandler: ImplDecorator<AbstractEventHandler, EventType> =
+  QualifierImplDecoratorUtil.generatorDecorator(AbstractEventHandler, EVENT_HANDLER_ATTRIBUTE);
+
+export const EventHandlerProto = (type: EventType[keyof EventType], params?: SingletonProtoParams) => {
+  return (clazz: EggProtoImplClass<AbstractEventHandler>) => {
+    EventHandler(type)(clazz);
+    SingletonProto(params)(clazz);
+  };
+};
+
+export interface FetchEventLike {
+  type: string;
+  request: Request;
+  respondWith(response: Response | Promise<Response>): void;
+  waitUntil?(promise: Promise<unknown>): void;
+}

tegg/core/standalone-decorator/src/index.ts

@@ -1,3 +1,4 @@
 export * from './typing.ts';
 export * from './util/index.ts';
 export * from './decorator/index.ts';
+export * from './event/EventHandler.ts';

tegg/core/test-util/package.json

@@ -29,11 +29,13 @@
   "types": "./dist/index.d.ts",
   "exports": {
     ".": "./src/index.ts",
+    "./StandaloneTestUtil": "./src/StandaloneTestUtil.ts",
     "./package.json": "./package.json"
   },
   "publishConfig": {
     "exports": {
       ".": "./dist/index.js",
+      "./StandaloneTestUtil": "./dist/StandaloneTestUtil.js",
       "./package.json": "./package.json"
     }
   },
@@ -47,7 +49,9 @@
     "@eggjs/tegg-common-util": "workspace:*",
     "@eggjs/tegg-loader": "workspace:*",
     "@eggjs/tegg-runtime": "workspace:*",
-    "globby": "catalog:"
+    "@eggjs/tegg-types": "workspace:*",
+    "globby": "catalog:",
+    "undici": "catalog:"
   },
   "devDependencies": {
     "@types/node": "catalog:",

tegg/core/test-util/src/StandaloneTestUtil.ts

@@ -0,0 +1,81 @@
+import { createServer, IncomingMessage, OutgoingHttpHeaders, Server, ServerOptions, ServerResponse } from 'node:http';
+import { pipeline } from 'node:stream';
+import { Headers, BodyInit, Request, Response } from 'undici';
+import { FetchEvent } from '@eggjs/tegg-types/standalone';
+
+export type FetchEventListener = (event: FetchEvent) => Promise<Response>;
+
+export interface StartHTTPServerOptions extends ServerOptions {
+  listener: FetchEventListener;
+}
+
+export class StandaloneTestUtil {
+  static skipOnNode(minVersion = 18) {
+    const version = parseInt(process.versions.node.split('.')[0], 10);
+    return version < minVersion;
+  }
+
+  static #buildRequest(req: IncomingMessage): Request {
+    const origin = `http://${req.headers.host ?? 'localhost'}`;
+    const url = new URL(req.url ?? '', origin);
+
+    const body: BodyInit | null = req.method === 'GET' || req.method === 'HEAD' ? null : req;
+
+    req.headers.host = url.host;
+
+    const headers = new Headers();
+    for (const [ name, values ] of Object.entries(req.headers)) {
+      if (Array.isArray(values)) {
+        for (const value of values) {
+          headers.append(name, value);
+        }
+      } else if (values !== undefined) {
+        headers.append(name, values);
+      }
+    }
+
+    return new Request(url, {
+      method: req.method,
+      headers,
+      body,
+      duplex: body ? 'half' : undefined,
+    });
+  }
+
+  static #createHTTPServerListener(listener: FetchEventListener) {
+    return async (req: IncomingMessage, res: ServerResponse) => {
+      const request = StandaloneTestUtil.#buildRequest(req);
+      // TODO currently fake FetchEvent
+      const event: any = new Event('fetch');
+      event.request = request;
+      const response = await listener(event);
+
+      const headers: OutgoingHttpHeaders = {};
+      for (const [ key, value ] of response.headers) {
+        headers[key.toLowerCase()] = value;
+      }
+
+      res.writeHead(response.status, headers);
+
+      if (!response.body) {
+        res.end();
+        return;
+      }
+      pipeline(response.body, res, e => {
+        if (e) {
+          console.error(`pipeline writing response error for url ${response.url}`, e);
+          res.end();
+        }
+      });
+    };
+  }
+
+  static startHTTPServer(host: string, port: number, { listener, ...options }: StartHTTPServerOptions) {
+    const serverListener = StandaloneTestUtil.#createHTTPServerListener(listener);
+    const server = createServer(options ?? {}, serverListener);
+
+    return new Promise<Server>(resolve => {
+      server.listen(port, host, () => resolve(server));
+    });
+  }
+}

tegg/core/types/package.json

@@ -124,6 +124,9 @@
     "./runtime/model/EggObject": "./src/runtime/model/EggObject.ts",
     "./runtime/model/LoadUnitInstance": "./src/runtime/model/LoadUnitInstance.ts",
     "./schedule": "./src/schedule.ts",
+    "./standalone": "./standalone/index.ts",
+    "./standalone/fetch": "./standalone/fetch.ts",
+    "./standalone/ServiceWorkerContext": "./standalone/ServiceWorkerContext.ts",
     "./transaction": "./src/transaction.ts",
     "./package.json": "./package.json"
   },
@@ -227,6 +230,9 @@
       "./runtime/model/EggObject": "./dist/runtime/model/EggObject.js",
       "./runtime/model/LoadUnitInstance": "./dist/runtime/model/LoadUnitInstance.js",
       "./schedule": "./dist/schedule.js",
+      "./standalone": "./dist/standalone/index.js",
+      "./standalone/fetch": "./dist/standalone/fetch.js",
+      "./standalone/ServiceWorkerContext": "./dist/standalone/ServiceWorkerContext.js",
       "./transaction": "./dist/transaction.js",
       "./package.json": "./package.json"
     }

tegg/core/types/standalone/ServiceWorkerContext.ts

@@ -0,0 +1,16 @@
+import { FetchEvent } from './fetch.ts';
+
+export interface ServiceWorkerContextInit<T> {
+  event: T;
+}
+
+export interface ServiceWorkerContext<Event, Response> {
+  event: Event;
+  get response(): Response | undefined;
+  set response(response: Response);
+
+  get body(): any | undefined;
+  set body(body: any);
+}
+
+export type ServiceWorkerFetchContext = ServiceWorkerContext<FetchEvent, Response>;

tegg/core/types/standalone/fetch.ts

@@ -0,0 +1,5 @@
+export interface FetchEvent extends Event {
+  request: Request;
+  waitUntil(f: Promise<any>): void;
+  respondWith(r: Response | PromiseLike<Response>): void;
+}

tegg/core/types/standalone/index.ts

@@ -0,0 +1,2 @@
+export * from './fetch.ts';
+export * from './ServiceWorkerContext.ts';

tegg/standalone/service-worker/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "@eggjs/tegg-service-worker",
+  "version": "4.0.0-beta.29",
+  "private": true,
+  "description": "tegg service worker",
+  "keywords": [
+    "egg",
+    "typescript",
+    "tegg",
+    "standalone",
+    "service worker"
+  ],
+  "homepage": "https://github.com/eggjs/egg/tree/next/tegg/standalone/service-worker",
+  "bugs": {
+    "url": "https://github.com/eggjs/egg/issues"
+  },
+  "license": "MIT",
+  "author": "killagu <killa123@126.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/eggjs/egg.git",
+    "directory": "tegg/standalone/service-worker"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": "./src/index.ts",
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "exports": {
+      ".": "./dist/index.js",
+      "./package.json": "./package.json"
+    }
+  },
+  "scripts": {
+    "typecheck": "tsgo --noEmit"
+  },
+  "dependencies": {
+    "@eggjs/router": "workspace:*",
+    "@eggjs/ajv-plugin": "workspace:*",
+    "@eggjs/tegg-aop-runtime": "workspace:*",
+    "@eggjs/tegg-dal-plugin": "workspace:*",
+    "@eggjs/tegg-dynamic-inject-runtime": "workspace:*",
+    "@eggjs/tegg-lifecycle": "workspace:*",
+    "@eggjs/tegg-metadata": "workspace:*",
+    "@eggjs/tegg-standalone": "workspace:*",
+    "@eggjs/tegg-types": "workspace:*",
+    "@modelcontextprotocol/sdk": "1.24.3",
+    "egg-errors": "catalog:",
+    "path-to-regexp": "catalog:path-to-regexp1",
+    "type-is": "catalog:",
+    "urllib": "catalog:"
+  },
+  "peerDependencies": {
+    "@eggjs/tegg": "workspace:*"
+  },
+  "devDependencies": {
+    "@eggjs/module-test-util": "workspace:*",
+    "@eggjs/tegg": "workspace:*",
+    "@types/node": "catalog:",
+    "@types/type-is": "catalog:",
+    "typescript": "catalog:",
+    "undici": "catalog:"
+  },
+  "engines": {
+    "node": ">=22.18.0"
+  }
+}

tegg/standalone/service-worker/src/ServiceWorkerApp.ts

@@ -0,0 +1,116 @@
+import path from 'node:path';
+import {
+  EggPrototypeLifecycleUtil,
+  LoadUnitLifecycleUtil,
+} from '@eggjs/tegg-metadata';
+import { Runner, RunnerOptions, StandaloneContext } from '@eggjs/tegg-standalone';
+import type { Logger } from '@eggjs/tegg-types';
+import { getDefaultHttpClient } from 'urllib';
+import { ContextProtoProperty } from './constants.ts';
+import { FetchRouter } from './http/FetchRouter.ts';
+import { RootProtoManager } from './controller/RootProtoManager.ts';
+import { ControllerMetadataManager } from './controller/ControllerMetadataManager.ts';
+import { ControllerRegisterFactory } from './controller/ControllerRegisterFactory.ts';
+import { ContextProtoLoadUnitHook } from './hook/ContextProtoLoadUnitHook.ts';
+import { ControllerPrototypeHook } from './hook/ControllerPrototypeHook.ts';
+import { ControllerLoadUnitHook } from './hook/ControllerLoadUnitHook.ts';
+import { HTTPControllerRegister } from './http/HTTPControllerRegister.ts';
+import { MCPControllerRegister } from './mcp/MCPControllerRegister.ts';
+import { LoadUnitInnerClassHook } from './hook/LoadUnitInnerClassHook.ts';
+import { ServiceWorkerRunner } from './ServiceWorkerRunner.ts';
+import { StandaloneEggObjectFactory } from './StandaloneEggObjectFactory.ts';
+import { FetchEventHandler } from './http/FetchEventHandler.ts';
+
+export interface ServiceWorkerAppOptions {
+  innerObjectHandlers?: RunnerOptions['innerObjectHandlers'];
+  logger?: Logger;
+}
+
+export class ServiceWorkerApp {
+  private readonly runner: Runner;
+  private readonly contextProtoLoadUnitHook: ContextProtoLoadUnitHook;
+  private readonly controllerPrototypeHook: ControllerPrototypeHook;
+  private readonly controllerLoadUnitHook: ControllerLoadUnitHook;
+  private readonly fetchRouter: FetchRouter;
+  private readonly rootProtoManager: RootProtoManager;
+  private readonly controllerMetadataManager: ControllerMetadataManager;
+  private readonly controllerRegisterFactory: ControllerRegisterFactory;
+  private readonly loadUnitInnerClassHook: LoadUnitInnerClassHook;
+
+  constructor(cwd: string, options?: ServiceWorkerAppOptions & RunnerOptions) {
+    // Create shared objects
+    this.fetchRouter = new FetchRouter();
+    this.rootProtoManager = new RootProtoManager();
+    this.controllerMetadataManager = new ControllerMetadataManager();
+    this.controllerRegisterFactory = new ControllerRegisterFactory();
+
+    // Create lifecycle hooks
+    this.contextProtoLoadUnitHook = new ContextProtoLoadUnitHook('serviceWorker');
+    this.controllerPrototypeHook = new ControllerPrototypeHook();
+    this.controllerLoadUnitHook = new ControllerLoadUnitHook(
+      this.controllerRegisterFactory,
+      this.rootProtoManager,
+      this.controllerMetadataManager,
+      this.fetchRouter,
+    );
+
+    // Register lifecycle hooks
+    LoadUnitLifecycleUtil.registerLifecycle(this.contextProtoLoadUnitHook);
+    LoadUnitLifecycleUtil.registerLifecycle(this.controllerLoadUnitHook);
+    EggPrototypeLifecycleUtil.registerLifecycle(this.controllerPrototypeHook);
+
+    // Build dependencies list - include this package as a framework dependency
+    const frameworkDep = { baseDir: path.join(__dirname, '..'), extraFilePattern: [ '!**/test' ] };
+    const deps = [ ...(options?.dependencies || []), frameworkDep ];
+
+    // Register FetchRouter and RootProtoManager as inner objects so they can be @Inject()-ed
+    const innerObjectHandlers: RunnerOptions['innerObjectHandlers'] = {
+      ...options?.innerObjectHandlers,
+      fetchRouter: [{ obj: this.fetchRouter }],
+      rootProtoManager: [{ obj: this.rootProtoManager }],
+    };
+
+    // Provide default logger (fallback to console) and httpclient (urllib singleton)
+    if (!innerObjectHandlers.logger) {
+      innerObjectHandlers.logger = [{ obj: options?.logger || console }];
+    }
+    if (!innerObjectHandlers.httpclient) {
+      innerObjectHandlers.httpclient = [{ obj: getDefaultHttpClient() }];
+    }
+
+    this.loadUnitInnerClassHook = new LoadUnitInnerClassHook([ StandaloneEggObjectFactory, ServiceWorkerRunner, FetchEventHandler ]);
+
+    LoadUnitLifecycleUtil.registerLifecycle(this.loadUnitInnerClassHook);
+
+    this.runner = new Runner(cwd, {
+      ...options,
+      dependencies: deps,
+      innerObjectHandlers,
+    });
+  }
+
+  async init() {
+    await this.runner.init();
+  }
+
+  async handleEvent<T = unknown>(event: Event) {
+    const context = new StandaloneContext();
+    context.set(ContextProtoProperty.Event.contextKey, event);
+
+    return await this.runner.run<T>(context);
+  }
+
+  async destroy() {
+    // Clean up static singletons
+    HTTPControllerRegister.clean();
+    MCPControllerRegister.clean();
+
+    // Unregister lifecycle hooks
+    LoadUnitLifecycleUtil.deleteLifecycle(this.contextProtoLoadUnitHook);
+    LoadUnitLifecycleUtil.deleteLifecycle(this.controllerLoadUnitHook);
+    LoadUnitLifecycleUtil.deleteLifecycle(this.loadUnitInnerClassHook);
+    EggPrototypeLifecycleUtil.deleteLifecycle(this.controllerPrototypeHook);
+
+    await this.runner.destroy();
+  }
+}