phecda-server 7.0.0-alpha.9 → 7.0.1

package/dist/rpc/ws/index.mjs

@@ -0,0 +1,73 @@
+import {
+  Context,
+  createControllerMetaMap,
+  detectAopDep
+} from "../../chunk-E7EAPAGM.mjs";
+import {
+  __name
+} from "../../chunk-NQ55PA2X.mjs";
+
+// src/rpc/ws/bind.ts
+import Debug from "debug";
+var debug = Debug("phecda-server/ws");
+function bind(wss, data, opts = {}) {
+  const { globalGuards, globalAddons, globalFilter, globalPipe } = opts;
+  const { moduleMap, meta } = data;
+  const metaMap = createControllerMetaMap(meta, (meta2) => {
+    const { controller, rpc, func, tag } = meta2.data;
+    if (controller === "rpc" && rpc?.queue !== void 0) {
+      debug(`register method "${func}" in module "${tag}"`);
+      return true;
+    }
+  });
+  detectAopDep(meta, {
+    guards: globalGuards,
+    addons: globalAddons
+  }, "rpc");
+  wss.on("connection", (ws) => {
+    ws.on("message", async (raw) => {
+      try {
+        const data2 = JSON.parse(raw.toString());
+        const { func, id, tag, _ps, args, queue } = data2;
+        if (_ps !== 1) return;
+        const meta2 = metaMap.get(tag)[func];
+        const { data: { rpc: { isEvent } = {} } } = meta2;
+        const aop = Context.getAop(meta2, {
+          globalFilter,
+          globalGuards,
+          globalPipe
+        });
+        const context = new Context({
+          type: "ws",
+          category: "rpc",
+          meta: meta2,
+          moduleMap,
+          tag,
+          func,
+          args,
+          id,
+          queue,
+          wss,
+          ws
+        });
+        return await context.run(aop, (returnData) => {
+          if (!isEvent) ws.send(JSON.stringify({
+            id,
+            data: returnData
+          }));
+        }, (err) => {
+          if (!isEvent) ws.send(JSON.stringify({
+            id,
+            data: err,
+            error: true
+          }));
+        });
+      } catch (e) {
+      }
+    });
+  });
+}
+__name(bind, "bind");
+export {
+  bind
+};

package/dist/test.d.mts

@@ -2,9 +2,13 @@ import * as supertest from 'supertest';
 import { Test } from 'supertest';
 import { Server } from 'node:http';
 import { Construct } from 'phecda-core';
-import { F as Factory } from './core-BDkhrEyf.mjs';
-import { P as PickFunc } from './meta-BX5jhe4Z.mjs';
+import { F as Factory } from './core-DbqWh47p.mjs';
+import { C as CustomResponse } from './meta-BoS1E-Nz.mjs';
 
+type PickFuncKeys<Type> = {
+    [Key in keyof Type]: Type[Key] extends (...args: any) => any ? (ReturnType<Type[Key]> extends CustomResponse<any> ? never : Key) : never;
+}[keyof Type];
+type PickFunc<Instance> = Pick<Instance, PickFuncKeys<Instance>>;
 declare function TestFactory<T extends Construct[]>(...Modules: T): Promise<{
     get<C extends T[number]>(Model: C): InstanceType<C>;
 }>;
@@ -15,4 +19,4 @@ declare function TestHttp(app: Server | any, { moduleMap, meta }: Awaited<Return
     module: <T extends Construct>(Module: T) => SuperTestRequest<PickFunc<InstanceType<T>>>;
 }>;
 
-export { type SuperTestRequest, TestFactory, TestHttp };
+export { type PickFunc, type SuperTestRequest, TestFactory, TestHttp };

package/dist/test.d.ts

@@ -2,9 +2,13 @@ import * as supertest from 'supertest';
 import { Test } from 'supertest';
 import { Server } from 'node:http';
 import { Construct } from 'phecda-core';
-import { F as Factory } from './core-D_cz0tKa.js';
-import { P as PickFunc } from './meta-BX5jhe4Z.js';
+import { F as Factory } from './core-Rq7BhPHE.js';
+import { C as CustomResponse } from './meta-BoS1E-Nz.js';
 
+type PickFuncKeys<Type> = {
+    [Key in keyof Type]: Type[Key] extends (...args: any) => any ? (ReturnType<Type[Key]> extends CustomResponse<any> ? never : Key) : never;
+}[keyof Type];
+type PickFunc<Instance> = Pick<Instance, PickFuncKeys<Instance>>;
 declare function TestFactory<T extends Construct[]>(...Modules: T): Promise<{
     get<C extends T[number]>(Model: C): InstanceType<C>;
 }>;
@@ -15,4 +19,4 @@ declare function TestHttp(app: Server | any, { moduleMap, meta }: Awaited<Return
     module: <T extends Construct>(Module: T) => SuperTestRequest<PickFunc<InstanceType<T>>>;
 }>;
 
-export { type SuperTestRequest, TestFactory, TestHttp };
+export { type PickFunc, type SuperTestRequest, TestFactory, TestHttp };

package/dist/test.js

@@ -1,14 +1,14 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } }
 
-var _chunkKJUD2BKEjs = require('./chunk-KJUD2BKE.js');
+var _chunkZWPOWMZPjs = require('./chunk-ZWPOWMZP.js');
 
 
-var _chunk5RBTN33Ajs = require('./chunk-5RBTN33A.js');
+var _chunk4LLLQOMFjs = require('./chunk-4LLLQOMF.js');
 
 // src/test.ts
 var _phecdacore = require('phecda-core');
 async function TestFactory(...Modules) {
-  const { moduleMap, modelMap } = await _chunkKJUD2BKEjs.Factory.call(void 0, Modules);
+  const { moduleMap, modelMap } = await _chunkZWPOWMZPjs.Factory.call(void 0, Modules);
   return {
     get(Model) {
       const tag = _phecdacore.getTag.call(void 0, Model);
@@ -19,7 +19,7 @@ async function TestFactory(...Modules) {
     }
   };
 }
-_chunk5RBTN33Ajs.__name.call(void 0, TestFactory, "TestFactory");
+_chunk4LLLQOMFjs.__name.call(void 0, TestFactory, "TestFactory");
 async function TestHttp(app, { moduleMap, meta }, isAgent = true) {
   const { default: request, agent } = await Promise.resolve().then(() => _interopRequireWildcard(require("supertest")));
   const Agent = agent(app);
@@ -59,11 +59,11 @@ async function TestHttp(app, { moduleMap, meta }, isAgent = true) {
       }
     });
   }
-  _chunk5RBTN33Ajs.__name.call(void 0, module, "module");
+  _chunk4LLLQOMFjs.__name.call(void 0, module, "module");
   Agent.module = module;
   return Agent;
 }
-_chunk5RBTN33Ajs.__name.call(void 0, TestHttp, "TestHttp");
+_chunk4LLLQOMFjs.__name.call(void 0, TestHttp, "TestHttp");
 
 
 

package/dist/test.mjs

@@ -1,9 +1,9 @@
 import {
   Factory
-} from "./chunk-7ZGYJ5OW.mjs";
+} from "./chunk-AIAO6SV6.mjs";
 import {
   __name
-} from "./chunk-FXTJ3BJ6.mjs";
+} from "./chunk-NQ55PA2X.mjs";
 
 // src/test.ts
 import { getTag } from "phecda-core";

package/dist/types-CInz3bD0.d.ts

@@ -0,0 +1,14 @@
+import { B as BaseCtx, D as DefaultOptions } from './meta-BoS1E-Nz.js';
+
+interface RpcServerOptions extends DefaultOptions {
+    defaultQueue?: string;
+}
+interface RpcCtx extends BaseCtx {
+    args: any[];
+    id: string;
+    queue: string;
+    isEvent?: boolean;
+    category: 'rpc';
+}
+
+export type { RpcCtx as R, RpcServerOptions as a };

package/dist/types-E-rqlg3-.d.mts

@@ -0,0 +1,14 @@
+import { B as BaseCtx, D as DefaultOptions } from './meta-BoS1E-Nz.mjs';
+
+interface RpcServerOptions extends DefaultOptions {
+    defaultQueue?: string;
+}
+interface RpcCtx extends BaseCtx {
+    args: any[];
+    id: string;
+    queue: string;
+    isEvent?: boolean;
+    category: 'rpc';
+}
+
+export type { RpcCtx as R, RpcServerOptions as a };

package/dist/{types-DKVhyZk_.d.mts → types-SCJZFCYt.d.mts}

@@ -1,5 +1,5 @@
 import { IncomingHttpHeaders, IncomingMessage, ServerResponse } from 'node:http';
-import { D as DefaultOptions, B as BaseCtx } from './meta-BX5jhe4Z.mjs';
+import { B as BaseCtx, D as DefaultOptions } from './meta-BoS1E-Nz.mjs';
 
 interface HttpOptions extends DefaultOptions {
     /**

package/dist/{types-CMeuFoyd.d.ts → types-xruyYmyu.d.ts}

@@ -1,5 +1,5 @@
 import { IncomingHttpHeaders, IncomingMessage, ServerResponse } from 'node:http';
-import { D as DefaultOptions, B as BaseCtx } from './meta-BX5jhe4Z.js';
+import { B as BaseCtx, D as DefaultOptions } from './meta-BoS1E-Nz.js';
 
 interface HttpOptions extends DefaultOptions {
     /**

package/package.json

@@ -1,21 +1,21 @@
 {
   "name": "phecda-server",
-  "version": "7.0.0-alpha.9",
+  "version": "7.0.1",
   "description": "server framework that provide IOC/type-reuse/http&rpc-adaptor",
   "author": "fgsreally",
   "license": "MIT",
   "repository": "https://github.com/fgsreally/phecda/tree/main/packages/server",
   "keywords": [
     "server",
+    "http",
     "IOC",
     "rpc",
-    "types-share"
+    "types-safe"
   ],
   "exports": {
     ".": {
       "require": "./dist/index.js",
-      "import": "./dist/index.mjs",
-      "node": "./dist/index.js"
+      "import": "./dist/index.mjs"
     },
     "./helper": {
       "require": "./dist/helper.js",
@@ -73,6 +73,18 @@
       "require": "./dist/rpc/nats/index.js",
       "import": "./dist/rpc/nats/index.mjs"
     },
+    "./electron": {
+      "require": "./dist/rpc/electron/index.js",
+      "import": "./dist/rpc/electron/index.mjs"
+    },
+    "./ws": {
+      "require": "./dist/rpc/ws/index.js",
+      "import": "./dist/rpc/ws/index.mjs"
+    },
+    "./web-ext": {
+      "require": "./dist/rpc/web-ext/index.js",
+      "import": "./dist/rpc/web-ext/index.mjs"
+    },
     "./register": "./register/index.mjs",
     "./*": "./*"
   },
@@ -144,27 +156,30 @@
     "chokidar": "^3.5.3",
     "debug": "^4.3.4",
     "fs-extra": "^11.2.0",
-    "h3": "^1.12.0",
     "picocolors": "^1.0.0",
     "reflect-metadata": "^0.1.13",
     "ts-mixer": "^6.0.4",
-    "phecda-core": "4.1.0-alpha.0"
+    "phecda-core": "4.2.0"
   },
   "devDependencies": {
     "@koa/router": "^12.0.1",
     "@nucleoidjs/kafkajs-mock": "^0.0.1",
     "@types/amqplib": "^0.10.1",
+    "@types/chrome": "^0.0.309",
     "@types/debug": "^4.1.12",
     "@types/express": "^4.17.17",
     "@types/fs-extra": "^11.0.4",
     "@types/koa": "^2.13.12",
     "@types/koa__router": "^12.0.4",
     "@types/supertest": "^2.0.12",
+    "@types/ws": "^8.5.13",
     "amqplib": "^0.10.3",
     "bullmq": "^5.7.1",
+    "electron": "^33.2.1",
     "elysia": "^1.0.17",
     "express": "^4.18.2",
     "fastify": "^4.25.1",
+    "h3": "^1.12.0",
     "hono": "^4.3.4",
     "hyper-express": "^6.15.2",
     "ioredis": "^5.3.2",
@@ -176,8 +191,9 @@
     "nats": "^2.22.0",
     "supertest": "^6.3.3",
     "tsup": "^8.1.0",
-    "typescript": "^5.4.5",
-    "unimport": "^3.7.1"
+    "typescript": "^5.8.3",
+    "unimport": "^3.7.1",
+    "ws": "^8.18.0"
   },
   "scripts": {
     "dev": "tsup --watch",

package/register/export.mjs

@@ -0,0 +1,30 @@
+export default ['Addon', 'Arg', 'Assign', 'BadGatewayException', 'BadRequestException',
+  'Base', 'Body', 'Clear',
+  'ConflictException', 'Controller',
+  'Ctx', 'CustomResponse',
+  'Delete',
+  'Define',
+  'ERROR_SYMBOL',
+  'Effect', 'Empty', 'Err', 'Exception', 'Expose', 'Factory', 'Filter', 'ForbiddenException',
+  'FrameworkException',
+  'Generator', 'Get', 'Global', 'Guard', 'HTTPGenerator', 'Head', 'Header', 'HttpBase',
+  'If', 'Init', 'Inject', 'Injectable',
+  'InvalidInputException', 'Isolate',
+  'Mixin',
+  'NotFoundException', 'PAddon', 'PExtension', 'PFilter', 'PGuard',
+  'PPipe', 'Param', 'Patch', 'PayloadLargeException', 'Pipe', 'Pipeline', 'Post',
+  'Provide', 'Put', 'Query', 'Queue', 'RPCGenerator', 'Route',
+  'Rpc', 'RpcBase', 'Search', 'ServerBase', 'ServerPhecda', 'ServiceUnavailableException', 'Storage',
+  'Tag', 'TimeoutException', 'TimerException', 'UnauthorizedException', 'UndefinedException',
+  'Unique', 'Unmount', 'UnsupportedMediaTypeException', 'ValidateException',
+  'Watcher', 'WorkerException',
+  'addAddon', 'addDecoToClass',
+  'addFilter', 'addGuard', 'addPipe', 'emitter',
+  'getMergedMeta',
+  'getMeta', 'getMetaKey', 'getMetaParams', 'getOwnMeta', 'getOwnMetaKey', 'getOwnMetaParams',
+  'getTag',
+  'isPhecda', 'log', 'phecdaNamespace', 'runMiddleware',
+  'setInject',
+  'setLogger',
+  'setMeta',
+  'useS', 'wait', 'OneFile', 'ManyFiles']

package/register/index.mjs

@@ -16,9 +16,8 @@ const fileModelMap = new Map()
 
 port1.on('message', async (data) => {
   const { type, files } = JSON.parse(data)
-
-  if (!isRunning || type === 'relaunch')
-    return RELAUNCH()// file change -> relaunch
+  if ((!isRunning && type !== 'init') || type === 'relaunch')
+    return RELAUNCH()
 
   if (type === 'change' || type === 'init') {
     if (!files.length)

package/register/loader.mjs

@@ -3,31 +3,45 @@ import { writeFile } from 'fs/promises'
 import {
   basename,
   dirname,
-  extname,
   isAbsolute,
   relative,
   resolve as resolvePath,
 } from 'path'
 import { createRequire } from 'module'
-import { existsSync } from 'fs'
 import ts from 'typescript'
 import chokidar from 'chokidar'
-import { IS_DEV, log } from '../dist/index.mjs'
+import Debug from 'debug'
 import { compile, genUnImportRet, handleClassTypes, slash } from './utils.mjs'
 
+const require = createRequire(import.meta.url)
+const debug = Debug('phecda-server/loader')
+
+const isLowVersion = parseFloat(process.version.slice(1)) < 18.19
+const IS_DEV = process.env.NODE_ENV === 'development'
 let port
+let config
+const workdir = process.cwd()
+const configPath = resolvePath(
+  workdir,
+  process.env.PS_CONFIG_FILE || 'ps.json',
+)
+
+// unimport
+let unimportRet, customLoad, customResolve
+const dtsPath = process.env.PS_DTS_PATH || 'ps.d.ts'
+
+// graph
+const watchFiles = new Set()
+const filesRecord = new Map()
+const moduleGraph = {}
+// ts
 let tsconfig = {
   module: ts.ModuleKind.ESNext,
   moduleResolution: ts.ModuleResolutionKind.NodeNext,
 }
-
-const isLowVersion = parseFloat(process.version.slice(1)) < 18.19
-// this part is important or not?
 const EXTENSIONS = [ts.Extension.Ts, ts.Extension.Tsx, ts.Extension.Mts]
-
 const tsconfigPath = resolvePath(process.cwd(), 'tsconfig.json')
 const tsRet = ts.readConfigFile(tsconfigPath, ts.sys.readFile)
-
 if (!tsRet.error) {
   const { error, options } = ts.parseJsonConfigFileContent(
     tsRet.config,
@@ -48,33 +62,31 @@ const host = {
   readFile: ts.sys.readFile,
 }
 
-let unimportRet
-const dtsPath = 'ps.d.ts'
-
 if (isLowVersion)
   await initialize()
 
-let config
-
-const workdir = process.cwd()
-
-const configPath = resolvePath(
-  workdir,
-  process.env.PS_CONFIG_FILE || 'ps.json',
-)
-
-const require = createRequire(import.meta.url)
 export async function initialize(data) {
   if (data)
     port = data.port
-  log('read config...')
+
+  debug('read config...')
 
   config = require(configPath)
-  if (!config.virtualFile)
-    config.virtualFile = {}
+
   if (!config.paths)
     config.paths = {}
 
+  const loaderPath = process.env.PS_LOADER_PATH
+
+  if (loaderPath) {
+    const loader = await import(loaderPath.startsWith('.') ? resolvePath(workdir, loaderPath) : loaderPath)
+
+    if (typeof loader.load === 'function')
+      customLoad = loader.load
+
+    if (typeof loader.resolve === 'function')
+      customResolve = loader.resolve
+  }
   if (IS_DEV) {
     chokidar.watch(configPath, { persistent: true }).on('change', () => {
       port.postMessage(
@@ -87,19 +99,21 @@ export async function initialize(data) {
 
   if (!config.unimport)
     return
+
   unimportRet = await genUnImportRet(config.unimport)
   if (unimportRet) {
-    log('auto import...')
+    debug('auto import...')
     await unimportRet.init()
 
+    const unimportDtsPath = resolvePath(workdir, dtsPath)
     writeFile(
-      resolvePath(workdir, config.unimport.dtsPath || dtsPath),
+      unimportDtsPath,
       handleClassTypes(
         await unimportRet.generateTypeDeclarations({
           resolvePath: (i) => {
             if (i.from.startsWith('.') || isAbsolute(i.from)) {
               const related = slash(
-                relative(workdir, i.from).replace(/\.ts(x)?$/, ''),
+                relative(dirname(unimportDtsPath), i.from).replace(/\.ts(x)?$/, ''),
               )
 
               return !related.startsWith('.') ? `./${related}` : related
@@ -112,12 +126,6 @@ export async function initialize(data) {
   }
 }
 
-const watchFiles = new Set()
-const filesRecord = new Map()
-const moduleGraph = {}
-
-let entryUrl
-
 function addUrlToGraph(url, parent) {
   if (!(url in moduleGraph))
     moduleGraph[url] = new Set()
@@ -129,63 +137,34 @@ function addUrlToGraph(url, parent) {
 function getFileMid(file) {
   const filename = basename(file)
   const ret = filename.split('.')
-  if (ret.length === 3)
-    return ret[1]
-  else return ''
+  if (!['js', 'mjs', 'cjs', 'ts', 'tsx', 'mts', 'cts'].includes(ret.pop()))
+    return ''
+  if (!ret[0])// .dockerfile
+    return ''
+
+  return ret[1]
 }
 
 export const resolve = async (specifier, context, nextResolve) => {
-  // virtual file
-  if (config.virtualFile[specifier]) {
-    return {
-      format: 'ts',
-      url: specifier,
-      shortCircuit: true,
-    }
-  }
-  // entrypoint
-  if (!context.parentURL) {
-    if (/^file:\/\/\//.test(specifier) && existsSync(fileURLToPath(specifier))) {
-      entryUrl = specifier
-
+  if (customResolve) {
+    const url = await customResolve(specifier, context)
+    if (url) {
       return {
-        format: EXTENSIONS.some(ext => specifier.endsWith(ext))
-          ? 'ts'
-          : undefined,
-        url: specifier,
+        format: 'ts',
+        url,
         shortCircuit: true,
       }
     }
-    else {
-      // won't resolve virtual file as entry in vite
-      return nextResolve(specifier)
-    }
-  }
-  // url import
-  // it seems useless
-  if (/^file:\/\/\//.test(specifier) && extname(specifier) === '.ts') {
-    const url = addUrlToGraph(specifier, context.parentURL.split('?')[0])
-    return {
-      format: 'ts',
-      url,
-      shortCircuit: true,
-    }
-  }
-
-  // hmr import
-  if (
-    context.parentURL.includes('/node_modules/phecda-server')
-    && isAbsolute(specifier)
-  ) {
-    specifier = relative(fileURLToPath(entryUrl), specifier)
-      .replace(/\.ts$/, '')
-      .slice(1)
-    context.parentURL = entryUrl
   }
 
-  // import/require from external library
-  if (context.parentURL.includes('/node_modules/'))
+  // entrypoint
+  if (!context.parentURL)
     return nextResolve(specifier)
+
+  // @todo skip resolve to improve performance
+  // if (context.parentURL.includes('/node_modules/') && specifier.includes('/node_modules/'))
+  //   return nextResolve(specifier)
+
   const { resolvedModule } = ts.resolveModuleName(
     specifier,
     fileURLToPath(context.parentURL),
@@ -194,7 +173,7 @@ export const resolve = async (specifier, context, nextResolve) => {
     moduleResolutionCache,
   )
 
-  // import between loacl projects
+  // import among files in local project
   if (
     resolvedModule
     && !resolvedModule.resolvedFileName.includes('/node_modules/')
@@ -230,23 +209,24 @@ export const resolve = async (specifier, context, nextResolve) => {
   const resolveRet = await nextResolve(specifier)
 
   // ts resolve fail in some cases
-  if (resolveRet.url && isAbsolute(resolveRet.url))
-    resolveRet.url = pathToFileURL(resolveRet.url).href
+  if (resolveRet.url && isAbsolute(resolveRet.url)) {
+    const [path, query] = resolveRet.url.split('?')
+    resolveRet.url = pathToFileURL(path).href + (query ? `?${query}` : '')
+  }
 
   return resolveRet
 }
 // @todo the first params may be url or path, need to distinguish
 
 export const load = async (url, context, nextLoad) => {
-  if (config.virtualFile[url]) {
-    return {
-      format: 'module',
-      source: config.virtualFile[url],
-      shortCircuit: true,
-    }
+  let mode
+  if (context.importAttributes.ps) {
+    mode = context.importAttributes.ps
+    delete context.importAttributes.ps
   }
 
   url = url.split('?')[0]
+
   if (
     !url.includes('/node_modules/')
     && url.startsWith('file://')
@@ -255,7 +235,7 @@ export const load = async (url, context, nextLoad) => {
   ) {
     watchFiles.add(url)
 
-    if (IS_DEV) {
+    if (IS_DEV && mode !== 'not-hmr') {
       if (isModuleFileUrl(url)) {
         port.postMessage(
           JSON.stringify({
@@ -289,6 +269,17 @@ export const load = async (url, context, nextLoad) => {
       )
     }
   }
+  // after hmr
+  if (customLoad) {
+    const source = await customLoad(url, context)
+    if (source) {
+      return {
+        format: 'module',
+        source,
+        shortCircuit: true,
+      }
+    }
+  }
   // resolveModuleName failed
   // I don't know why it failed
   if (!context.format && url.endsWith('.ts'))
@@ -299,10 +290,12 @@ export const load = async (url, context, nextLoad) => {
 
     const code
       = typeof source === 'string' ? source : Buffer.from(source).toString()
+
     const compiled = (await compile(code, url)).replace(/_ts_metadata\(\"design:paramtypes\"\,/g, '_ts_metadata("design:paramtypes",()=>')// handle cycle
 
     if (unimportRet) {
       const { injectImports } = unimportRet
+
       return {
         format: 'module',
         source: (