phecda-server 7.0.0-alpha.12 → 7.0.0-alpha.13

package/assets/schema.json

@@ -46,8 +46,17 @@
       "description": "Virtual module, just like in Vite."
     },
     "unimport": {
-      "type": "object",
-      "description": "Includes the arguments passed to unimport"
+      "oneOf": [
+        {
+          "type": "object",
+          "description": "Includes the arguments passed to unimport"
+        },
+        {
+          "type": "boolean",
+          "enum": [false],
+          "description": "Disable unimport"
+        }
+      ]
     }
   },
 

package/bin/cli.mjs

@@ -1,9 +1,6 @@
 #! /usr/bin/env node
 import { fork } from 'child_process'
 import { createRequire } from 'module'
-import { fileURLToPath } from 'url'
-
-import { dirname, resolve } from 'path'
 import pc from 'picocolors'
 import cac from 'cac'
 import fse from 'fs-extra'
@@ -20,8 +17,6 @@ const cli = cac('phecda').option('-c,--config <config>', 'config file', {
   default: 'ps.json',
 })
 
-const __dirname = dirname(fileURLToPath(import.meta.url))
-
 const require = createRequire(import.meta.url)
 let child
 
@@ -36,7 +31,7 @@ if (nodeVersion < 18.19) {
 }
 
 function startChild(file, args) {
-  child = fork(file, {
+  child = globalThis.PS_CREATE_CHILD?.() || fork(file, {
     env: { ...process.env },
     stdio: 'inherit',
     execArgv: [
@@ -87,22 +82,80 @@ cli
     if (root)
       process.chdir(root)
 
+    let hasUnimport
+
+    try {
+      await import('unimport')
+      hasUnimport = true
+    }
+
+    catch (e) {
+      hasUnimport = false
+    }
+
     const tsconfigPath = options.tsconfig
     const psconfigPath = process.env.PS_CONFIG_FILE || options.config
 
     if (!fse.existsSync(tsconfigPath)) {
       log(`create ${tsconfigPath}`)
 
-      await fse.copyFile(
-        resolve(__dirname, '../assets/tsconfig.json'),
+      await fse.outputJSON(
         tsconfigPath,
+        {
+          compilerOptions: {
+            target: 'esnext',
+            useDefineForClassFields: false,
+            experimentalDecorators: true,
+            emitDecoratorMetadata: true,
+            module: 'esnext',
+            lib: ['esnext', 'DOM'],
+            strictPropertyInitialization: false,
+            moduleResolution: 'bundler',
+            strict: true,
+            resolveJsonModule: true,
+            esModuleInterop: true,
+            noEmit: true,
+            noUnusedLocals: true,
+            noUnusedParameters: true,
+            noImplicitReturns: true,
+            skipLibCheck: true,
+          },
+          include: ['.', hasUnimport ? (process.env.PS_DTS_PATH || 'ps.d.ts') : undefined],
+        },
+
       )
     }
 
     if (!fse.existsSync(psconfigPath)) {
       log(`create ${psconfigPath}`)
 
-      await fse.copyFile(resolve(__dirname, '../assets/ps.json'), psconfigPath)
+      await fse.outputJSON(psconfigPath, {
+        $schema: './node_modules/phecda-server/assets/schema.json',
+        resolve: [
+          {
+            source: 'controller',
+            importer: 'http',
+            path: '.ps/http.js',
+          },
+          {
+            source: 'rpc',
+            importer: 'client',
+            path: '.ps/rpc.js',
+          },
+        ],
+        unimport: hasUnimport && {
+          dirs: [
+            '.',
+          ],
+          dirsScanOptions: {
+            filePatterns: [
+              '*.{service,controller,module,rpc,solo,guard,extension,pipe,filter,addon}.ts',
+            ],
+          },
+        },
+        virtualFile: {},
+        moduleFile: [],
+      })
     }
 
     log('init finish')

package/dist/rpc/electron/index.d.mts

@@ -0,0 +1,13 @@
+import Electron from 'electron';
+import { F as Factory } from '../../core-jUg1HvYT.mjs';
+import { R as RpcCtx, a as RpcServerOptions } from '../../types-6qaaUIKZ.mjs';
+import 'phecda-core';
+import '../../meta-xvg6V7pH.mjs';
+
+interface ElectronCtx extends RpcCtx {
+    type: 'electron';
+    event: Electron.IpcMainEvent | Electron.IpcMainInvokeEvent;
+}
+declare function bind(IPC: Electron.IpcMain, { moduleMap, meta }: Awaited<ReturnType<typeof Factory>>, opts?: RpcServerOptions): void;
+
+export { type ElectronCtx, bind };

package/dist/rpc/electron/index.d.ts

@@ -0,0 +1,13 @@
+import Electron from 'electron';
+import { F as Factory } from '../../core-CDzIy2g0.js';
+import { R as RpcCtx, a as RpcServerOptions } from '../../types-BtXOT5rI.js';
+import 'phecda-core';
+import '../../meta-xvg6V7pH.js';
+
+interface ElectronCtx extends RpcCtx {
+    type: 'electron';
+    event: Electron.IpcMainEvent | Electron.IpcMainInvokeEvent;
+}
+declare function bind(IPC: Electron.IpcMain, { moduleMap, meta }: Awaited<ReturnType<typeof Factory>>, opts?: RpcServerOptions): void;
+
+export { type ElectronCtx, bind };

package/dist/rpc/electron/index.js

@@ -0,0 +1,72 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+var _chunkIJFIY6QNjs = require('../../chunk-IJFIY6QN.js');
+
+
+var _chunk4LLLQOMFjs = require('../../chunk-4LLLQOMF.js');
+
+// src/rpc/electron/bind.ts
+var _debug = require('debug'); var _debug2 = _interopRequireDefault(_debug);
+var debug = _debug2.default.call(void 0, "phecda-server/electron");
+function bind(IPC, { moduleMap, meta }, opts = {}) {
+  const { globalGuards, globalFilter, globalPipe, globalAddons = [] } = opts;
+  const metaMap = _chunkIJFIY6QNjs.createControllerMetaMap.call(void 0, meta, (meta2) => {
+    const { controller, rpc, func, tag } = meta2.data;
+    if (controller === "rpc" && _optionalChain([rpc, 'optionalAccess', _ => _.queue]) !== void 0) {
+      debug(`register method "${func}" in module "${tag}"`);
+      return true;
+    }
+  });
+  _chunkIJFIY6QNjs.detectAopDep.call(void 0, meta, {
+    guards: globalGuards,
+    addons: globalAddons
+  }, "rpc");
+  IPC.handle("phecda-server:invoke", callback);
+  IPC.on("phecda-server:send", callback);
+  async function callback(event, data) {
+    const { func, id, tag, _ps, args } = data || {};
+    debug(`invoke method "${func}" in module "${tag}"`);
+    if (_ps !== 1) return;
+    const meta2 = metaMap.get(tag)[func];
+    const { data: { rpc: { isEvent } = {} } } = meta2;
+    const aop = _chunkIJFIY6QNjs.Context.getAop(meta2, {
+      globalFilter,
+      globalGuards,
+      globalPipe
+    });
+    const context = new (0, _chunkIJFIY6QNjs.Context)({
+      type: "electron",
+      category: "rpc",
+      moduleMap,
+      meta: meta2,
+      tag,
+      func,
+      args,
+      id,
+      isEvent,
+      queue: tag,
+      event
+    });
+    return await context.run(aop, (returnData) => {
+      if (!isEvent) return {
+        data: returnData,
+        id
+      };
+    }, (err) => {
+      if (!isEvent) {
+        return {
+          data: err,
+          error: true,
+          id
+        };
+      }
+    });
+  }
+  _chunk4LLLQOMFjs.__name.call(void 0, callback, "callback");
+}
+_chunk4LLLQOMFjs.__name.call(void 0, bind, "bind");
+
+
+exports.bind = bind;

package/dist/rpc/electron/index.mjs

@@ -0,0 +1,72 @@
+import {
+  Context,
+  createControllerMetaMap,
+  detectAopDep
+} from "../../chunk-VX4BZEL7.mjs";
+import {
+  __name
+} from "../../chunk-NQ55PA2X.mjs";
+
+// src/rpc/electron/bind.ts
+import Debug from "debug";
+var debug = Debug("phecda-server/electron");
+function bind(IPC, { moduleMap, meta }, opts = {}) {
+  const { globalGuards, globalFilter, globalPipe, globalAddons = [] } = opts;
+  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");
+  IPC.handle("phecda-server:invoke", callback);
+  IPC.on("phecda-server:send", callback);
+  async function callback(event, data) {
+    const { func, id, tag, _ps, args } = data || {};
+    debug(`invoke method "${func}" in module "${tag}"`);
+    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: "electron",
+      category: "rpc",
+      moduleMap,
+      meta: meta2,
+      tag,
+      func,
+      args,
+      id,
+      isEvent,
+      queue: tag,
+      event
+    });
+    return await context.run(aop, (returnData) => {
+      if (!isEvent) return {
+        data: returnData,
+        id
+      };
+    }, (err) => {
+      if (!isEvent) {
+        return {
+          data: err,
+          error: true,
+          id
+        };
+      }
+    });
+  }
+  __name(callback, "callback");
+}
+__name(bind, "bind");
+export {
+  bind
+};

package/dist/rpc/ws/index.d.mts

@@ -0,0 +1,14 @@
+import WS from 'ws';
+import { F as Factory } from '../../core-jUg1HvYT.mjs';
+import { R as RpcCtx, a as RpcServerOptions } from '../../types-6qaaUIKZ.mjs';
+import 'phecda-core';
+import '../../meta-xvg6V7pH.mjs';
+
+interface WsCtx extends RpcCtx {
+    type: 'ws';
+    ws: WS;
+    wss: WS.Server;
+}
+declare function bind(wss: WS.Server, data: Awaited<ReturnType<typeof Factory>>, opts?: RpcServerOptions): void;
+
+export { type WsCtx, bind };

package/dist/rpc/ws/index.d.ts

@@ -0,0 +1,14 @@
+import WS from 'ws';
+import { F as Factory } from '../../core-CDzIy2g0.js';
+import { R as RpcCtx, a as RpcServerOptions } from '../../types-BtXOT5rI.js';
+import 'phecda-core';
+import '../../meta-xvg6V7pH.js';
+
+interface WsCtx extends RpcCtx {
+    type: 'ws';
+    ws: WS;
+    wss: WS.Server;
+}
+declare function bind(wss: WS.Server, data: Awaited<ReturnType<typeof Factory>>, opts?: RpcServerOptions): void;
+
+export { type WsCtx, bind };

package/dist/rpc/ws/index.js

@@ -0,0 +1,73 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+var _chunkIJFIY6QNjs = require('../../chunk-IJFIY6QN.js');
+
+
+var _chunk4LLLQOMFjs = require('../../chunk-4LLLQOMF.js');
+
+// src/rpc/ws/bind.ts
+var _debug = require('debug'); var _debug2 = _interopRequireDefault(_debug);
+var debug = _debug2.default.call(void 0, "phecda-server/ws");
+function bind(wss, data, opts = {}) {
+  const { globalGuards, globalAddons, globalFilter, globalPipe } = opts;
+  const { moduleMap, meta } = data;
+  const metaMap = _chunkIJFIY6QNjs.createControllerMetaMap.call(void 0, meta, (meta2) => {
+    const { controller, rpc, func, tag } = meta2.data;
+    if (controller === "rpc" && _optionalChain([rpc, 'optionalAccess', _ => _.queue]) !== void 0) {
+      debug(`register method "${func}" in module "${tag}"`);
+      return true;
+    }
+  });
+  _chunkIJFIY6QNjs.detectAopDep.call(void 0, 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 = _chunkIJFIY6QNjs.Context.getAop(meta2, {
+          globalFilter,
+          globalGuards,
+          globalPipe
+        });
+        const context = new (0, _chunkIJFIY6QNjs.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) {
+      }
+    });
+  });
+}
+_chunk4LLLQOMFjs.__name.call(void 0, bind, "bind");
+
+
+exports.bind = bind;

package/dist/rpc/ws/index.mjs

@@ -0,0 +1,73 @@
+import {
+  Context,
+  createControllerMetaMap,
+  detectAopDep
+} from "../../chunk-VX4BZEL7.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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "phecda-server",
-  "version": "7.0.0-alpha.12",
+  "version": "7.0.0-alpha.13",
   "description": "server framework that provide IOC/type-reuse/http&rpc-adaptor",
   "author": "fgsreally",
   "license": "MIT",
@@ -74,6 +74,14 @@
       "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"
+    },
     "./register": "./register/index.mjs",
     "./*": "./*"
   },
@@ -160,8 +168,10 @@
     "@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",
@@ -178,7 +188,8 @@
     "supertest": "^6.3.3",
     "tsup": "^8.1.0",
     "typescript": "^5.7.2",
-    "unimport": "^3.7.1"
+    "unimport": "^3.7.1",
+    "ws": "^8.18.0"
   },
   "scripts": {
     "dev": "tsup --watch",

package/register/index.mjs

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

package/register/loader.mjs

@@ -7,7 +7,6 @@ import {
   relative,
   resolve as resolvePath,
 } from 'path'
-import { existsSync } from 'fs'
 import { createRequire } from 'module'
 import ts from 'typescript'
 import chokidar from 'chokidar'
@@ -32,7 +31,6 @@ let unimportRet
 const dtsPath = process.env.PS_DTS_PATH || 'ps.d.ts'
 
 // graph
-let entryUrl
 const watchFiles = new Set()
 const filesRecord = new Map()
 const moduleGraph = {}
@@ -137,9 +135,12 @@ 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) => {
@@ -151,45 +152,12 @@ export const resolve = async (specifier, context, nextResolve) => {
       shortCircuit: true,
     }
   }
-  // entrypoint
-  if (!context.parentURL) {
-    if (/^file:\/\/\//.test(specifier) && existsSync(fileURLToPath(specifier))) {
-      entryUrl = specifier
+  // if (isAbsolute(specifier))
+  //   specifier = pathToFileURL(specifier).href
 
-      return {
-        format: EXTENSIONS.some(ext => specifier.endsWith(ext))
-          ? 'ts'
-          : undefined,
-        url: specifier,
-        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
-  }
+  // entrypoint
+  if (!context.parentURL)
+    return nextResolve(specifier)
 
   // import/require from external library
   if (context.parentURL.includes('/node_modules/'))
@@ -261,6 +229,7 @@ export const load = async (url, context, nextLoad) => {
   }
 
   url = url.split('?')[0]
+
   if (
     !url.includes('/node_modules/')
     && url.startsWith('file://')

package/register/utils.mjs

@@ -24,28 +24,28 @@ export async function compile(sourcecode, filename) {
 
       jsc: {
         parser: {
-          syntax: "typescript",
+          syntax: 'typescript',
           importAttributes: true,
           decorators: true,
           tsx: false,
           dynamicImport: true,
-          strictPropertyInitialization: false
+          strictPropertyInitialization: false,
         },
         experimental: {
-          keepImportAssertions: true
+          keepImportAssertions: true,
         },
         transform: {
           legacyDecorator: true,
-          decoratorMetadata: true
-        }
+          decoratorMetadata: true,
+        },
         // parser: {
         //   importAttributes: true
         // },
         // experimental: {
         //   keepImportAssertions: true
         // }
-      }
-    }
+      },
+    },
   })
 
   return injectInlineSourceMap({ code, map })

package/assets/ps.json

@@ -1,24 +0,0 @@
-{
-  "$schema": "https://unpkg.com/phecda-server/assets/schema.json",
-  "resolve": [
-    {
-      "source": "controller",
-      "importer": "http",
-      "path": ".ps/http.js"
-    },
-    {
-      "source": "rpc",
-      "importer": "client",
-      "path": ".ps/rpc.js"
-    }
-  ],
-  "unimport": {
-    "dirs": ["."],
-    "dirsScanOptions": {
-      "filePatterns": ["*.{service,controller,module,rpc,solo,guard,extension,pipe,filter,addon}.ts"]
-    }
-  },
-  "virtualFile": {},
-  "moduleFile": []
-
-}

package/assets/tsconfig.json

@@ -1,21 +0,0 @@
-{
-    "compilerOptions": {
-      "target": "esnext",
-      "useDefineForClassFields": false,
-      "experimentalDecorators": true,
-      "emitDecoratorMetadata": true,
-      "module": "esnext",
-      "lib": ["esnext", "DOM"],
-      "strictPropertyInitialization": false,
-      "moduleResolution": "Node",
-      "strict": true,
-      "resolveJsonModule": true,
-      "esModuleInterop": true,
-      "noEmit": true,
-      "noUnusedLocals": true,
-      "noUnusedParameters": true,
-      "noImplicitReturns": true,
-      "skipLibCheck": true
-    },
-    "include": [".","./ps.d.ts"]
-  }