phecda-server 5.0.0-beta.31 → 5.0.0-beta.33

package/bin/cli.mjs

@@ -0,0 +1,189 @@
+#! /usr/bin/env node
+import { fork } from 'child_process'
+import fs from 'fs'
+import { createRequire } from 'module'
+import pc from 'picocolors'
+import cac from 'cac'
+import { log } from '../dist/index.mjs'
+const cli = cac('phecda')
+const require = createRequire(import.meta.url)
+let child
+
+let closePromise
+const nodeVersion = parseFloat(process.version.slice(1))
+
+if (nodeVersion < 18.19) {
+  log(
+    `Nodejs version less than 18.19(current is ${nodeVersion}) can't support hmr`,
+    'yellow',
+  )
+}
+
+function startChild(file, args) {
+  child = fork(file, {
+    env: { NODE_ENV: 'development', ...process.env },
+    stdio: 'inherit',
+    execArgv: [
+      nodeVersion < 18.19
+        ? '--loader=phecda-server/register/loader.mjs'
+        : '--import=phecda-server/register',
+      ...args,
+    ],
+  })
+
+  closePromise = new Promise((resolve) => {
+    child.once('exit', (code) => {
+      if (code === 4) {
+        log('only generate code')
+        process.exit(0)
+      }
+      if (code >= 2) {
+        // for relaunch
+        log('relaunch...')
+        startChild(file, args)
+      }
+      child = undefined
+
+      resolve()
+    })
+  })
+}
+
+function exit() {
+  log('process exit')
+
+  if (child) {
+    child.kill()
+    process.exit(0)
+  }
+  else {
+    process.exit(0)
+  }
+}
+process.on('SIGINT', () => {
+  process.exit()
+})
+
+cli.command('init', 'init config file').action(() => {
+  log('init tsconfig.json')
+
+  fs.writeFileSync(
+    'tsconfig.json',
+    `{
+    "compilerOptions": {
+      "target": "esnext",
+      "useDefineForClassFields": false,
+      "experimentalDecorators": true,
+      "emitDecoratorMetadata": true,
+      "module": "esnext",
+      "lib": ["esnext", "DOM"],
+      "strictPropertyInitialization": false,
+      "moduleResolution": "Node",
+      "strict": true,
+      "resolveJsonModule": true,
+      "isolatedModules": true,
+      "esModuleInterop": true,
+      "noEmit": true,
+      "noUnusedLocals": true,
+      "noUnusedParameters": true,
+      "noImplicitReturns": true,
+      "skipLibCheck": true
+    },
+    "include": ["src","./ps.d.ts"]
+  }
+  `,
+  )
+
+  log('init ps.json')
+
+  fs.writeFileSync(
+    'ps.json',
+   `{
+    "$schema": "node_modules/phecda-server/bin/schema.json",
+    "resolve": [
+      {
+        "source": "controller",
+        "importer": "http",
+        "path": "http.ts"
+      },
+      {
+        "source": "rpc",
+        "importer": "client",
+        "path": "rpc.ts"
+      }
+    ],
+    "unimport": {
+      "dirs": ["./src/*"],
+      "dirsScanOptions":{
+          "filePatterns":["*.{service,controller,module}.ts"]
+      },
+      "dtsPath": "./ps.d.ts"
+    },
+    "moduleFile": []
+  }
+  `,
+  )
+})
+
+cli
+  .command('[file]', 'run file')
+  .alias('run')
+  .option('-c, --config', 'config file', {
+    default: './ps.json',
+  })
+  .action((file, options) => {
+    process.env.PS_CONFIG_FILE = options.config
+
+    log('process start!')
+
+    startChild(file, options['--'])
+    console.log(`${pc.green('->')} press ${pc.green('e')} to exit`)
+    console.log(`${pc.green('->')} press ${pc.green('r')} to relaunch`)
+
+    process.stdin.on('data', async (data) => {
+      const input = data.toString().trim().toLocaleLowerCase()
+      if (input === 'r') {
+        if (child) {
+          await child.kill()
+          if (closePromise)
+            await closePromise
+          log('relaunch...')
+          startChild(file, options['--'])
+        }
+        else {
+          log('relaunch...')
+
+          startChild(file, options['--'])
+        }
+      }
+      if (input === 'e')
+        exit()
+    })
+  })
+
+cli
+  .command('generate [file]', 'generate code(mainly for ci)')
+  .option('-c, --config', 'config file', {
+    default: './ps.json',
+  })
+  .action((file, options) => {
+    process.env.PS_GENERATE = 'true'
+    process.env.PS_CONFIG_FILE = options.config
+    startChild(file, options['--'])
+  })
+// if (cmd[0] === 'init') {
+
+// }
+// else if (cmd[0] === 'code') {
+//   process.env.PS_GENERATE = 'true'
+//   cmd.splice(0, 1)
+//   startChild(file,options['--'])
+// }
+// else {
+
+// }
+
+cli.help()
+cli.version(require('../package.json').version)
+
+cli.parse()

package/bin/schema.json

@@ -0,0 +1,48 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "properties": {
+    "resolve": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "properties": {
+          "source": {
+            "type": "string",
+            "description": "The middle name of the imported file."
+          },
+          "importer": {
+            "type": "string",
+            "description": "The middle name of the importer file."
+          },
+          "path": {
+            "type": "string",
+
+            "description": "Redirect path"
+          },
+          "filename": {
+            "type": "string",
+            "optional": true,
+
+            "description": "generate split chunk,only work in vite"
+          }
+        },
+        "required": ["source", "path", "importer"]
+      },
+      "description": "Resolve and redirect modules path"
+    },
+    "moduleFile": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      },
+      "description": "Including the module's file middle name, such as controller mapping to xx.controller.ts"
+    },
+    "unimport": {
+      "type": "object",
+      "description": "Includes the arguments passed to unimport and 'dtsPath' that specifies the location for generating type files."
+    }
+  },
+
+  "required": ["resolve"]
+}

package/dist/{chunk-XCOZROAD.mjs → chunk-73I24DQB.mjs}

@@ -6,7 +6,7 @@ import {
   __name,
   __publicField,
   log
-} from "./chunk-77NDBQUP.mjs";
+} from "./chunk-ITTD2GBR.mjs";
 
 // src/exception/base.ts
 var Exception = class extends Error {
@@ -190,12 +190,12 @@ import Debug from "debug";
 var defaultFilter = /* @__PURE__ */ __name((e) => {
   if (!(e instanceof Exception)) {
     log(e.message, "error");
-    if (LOG_LEVEL <= 2)
+    if (LOG_LEVEL <= 0)
       console.error(e.stack);
     e = new UndefinedException(e.message || e);
   } else {
     log(`[${e.constructor.name}] ${e.message}`, "error");
-    if (LOG_LEVEL <= 2)
+    if (LOG_LEVEL <= 0)
       console.error(e.stack);
   }
   return e.data;
@@ -351,15 +351,19 @@ function addInterceptor(key, handler) {
   Context.interceptorRecord[key] = handler;
 }
 __name(addInterceptor, "addInterceptor");
-function detectAopDep(meta, { guards, interceptors, plugins } = {}, type = "http") {
+function detectAopDep(meta, { guards, interceptors, plugins } = {}, controller = "http") {
   const pluginSet = new Set(plugins);
   const guardSet = new Set(guards);
   const interceptorSet = new Set(interceptors);
   const pipeSet = /* @__PURE__ */ new Set();
   const filterSet = /* @__PURE__ */ new Set();
+  const warningSet = /* @__PURE__ */ new Set();
   meta.forEach(({ data }) => {
-    if (!data[type])
+    if (data.controller !== controller) {
+      if (data[controller])
+        warningSet.add(`Module "${data.tag === data.name ? data.name : `${data.name}(${data.tag})`}"  should use ${controller} controller to decorate class or remove ${controller} decorator on method "${data.func}"`);
       return;
+    }
     if (data.filter)
       filterSet.add(data.filter);
     data.interceptors.forEach((i) => interceptorSet.add(i));
@@ -395,6 +399,7 @@ function detectAopDep(meta, { guards, interceptors, plugins } = {}, type = "http
     log(`${pc.blue(`Pipe [${missPipes.join(",")}]`)} doesn't exist`, "warn");
   if (missFilters.length)
     log(`${pc.red(`Filter [${missFilters.join(",")}]`)} doesn't exist`, "warn");
+  warningSet.forEach((warn) => log(warn, "warn"));
   return {
     missPlugins,
     missGuards,

package/dist/{chunk-3BNP77AS.mjs → chunk-CMPQPS47.mjs}

@@ -1,6 +1,6 @@
 import {
   __name
-} from "./chunk-77NDBQUP.mjs";
+} from "./chunk-ITTD2GBR.mjs";
 
 // src/rpc/helper.ts
 import { hostname } from "os";

package/dist/chunk-F5YWXY5W.js

@@ -0,0 +1,252 @@
+"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 _chunkYR5Q5F2Kjs = require('./chunk-YR5Q5F2K.js');
+
+// src/meta.ts
+var Meta = class {
+  
+  
+  constructor(data, paramsType) {
+    this.data = data;
+    this.paramsType = paramsType;
+  }
+};
+_chunkYR5Q5F2Kjs.__name.call(void 0, Meta, "Meta");
+
+// src/core.ts
+require('reflect-metadata');
+var _events = require('events'); var _events2 = _interopRequireDefault(_events);
+var _phecdacore = require('phecda-core');
+var _debug = require('debug'); var _debug2 = _interopRequireDefault(_debug);
+var debug = _debug2.default.call(void 0, "phecda-server(Factory)");
+var emitter = new (0, _events2.default)();
+async function Factory(models, opts = {}) {
+  const moduleMap = /* @__PURE__ */ new Map();
+  const meta = [];
+  const constructorMap = /* @__PURE__ */ new Map();
+  const constructorSet = /* @__PURE__ */ new WeakSet();
+  const dependenceGraph = /* @__PURE__ */ new Map();
+  const { parseModule = /* @__PURE__ */ _chunkYR5Q5F2Kjs.__name.call(void 0, (module) => module, "parseModule"), parseMeta = /* @__PURE__ */ _chunkYR5Q5F2Kjs.__name.call(void 0, (meta2) => meta2, "parseMeta"), generators } = opts;
+  if (!_phecdacore.getInject.call(void 0, "watcher")) {
+    _phecdacore.setInject.call(void 0, "watcher", ({ eventName, instance, key, options }) => {
+      const fn = typeof instance[key] === "function" ? instance[key].bind(instance) : (v) => instance[key] = v;
+      if (_optionalChain([options, 'optionalAccess', _ => _.once]))
+        emitter.once(eventName, fn);
+      else
+        emitter.on(eventName, fn);
+      return () => {
+        emitter.off(eventName, fn);
+      };
+    });
+  }
+  async function del(tag) {
+    if (!moduleMap.has(tag))
+      return;
+    const instance = moduleMap.get(tag);
+    debug(`unmount module "${String(tag)}"`);
+    await _phecdacore.invokeHandler.call(void 0, "unmount", instance);
+    debug(`del module "${String(tag)}"`);
+    moduleMap.delete(tag);
+    constructorMap.delete(tag);
+    for (let i = meta.length - 1; i >= 0; i--) {
+      if (meta[i].data.tag === tag)
+        meta.splice(i, 1);
+    }
+    return instance;
+  }
+  _chunkYR5Q5F2Kjs.__name.call(void 0, del, "del");
+  async function destroy() {
+    debug("destroy all");
+    for (const [tag] of moduleMap)
+      await del(tag);
+  }
+  _chunkYR5Q5F2Kjs.__name.call(void 0, destroy, "destroy");
+  async function add(Model) {
+    const tag = _phecdacore.getTag.call(void 0, Model);
+    const oldInstance = await del(tag);
+    const { instance: newModule } = await buildDepModule(Model);
+    if (oldInstance && dependenceGraph.has(tag)) {
+      debug(`replace module "${String(tag)}"`);
+      [
+        ...dependenceGraph.get(tag)
+      ].forEach((tag2) => {
+        const module = moduleMap.get(tag2);
+        for (const key in module) {
+          if (module[key] === oldInstance)
+            module[key] = newModule;
+        }
+      });
+    }
+  }
+  _chunkYR5Q5F2Kjs.__name.call(void 0, add, "add");
+  async function buildDepModule(Model) {
+    const paramtypes = getParamTypes(Model);
+    let instance;
+    const tag = _phecdacore.getTag.call(void 0, Model);
+    if (moduleMap.has(tag)) {
+      instance = moduleMap.get(tag);
+      if (!instance)
+        throw new Error(`exist Circular-Dependency or Multiple modules with the same name/tag [tag] ${String(tag)}--[module] ${Model}`);
+      if (constructorMap.get(tag) !== Model && !constructorSet.has(Model)) {
+        constructorSet.add(Model);
+        _chunkYR5Q5F2Kjs.log.call(void 0, `Synonym module: Module taged "${String(tag)}" has been loaded before, so phecda-server won't load Module "${Model.name}"`, "warn");
+      }
+      return {
+        instance,
+        tag
+      };
+    }
+    moduleMap.set(tag, void 0);
+    debug(`instantiate module "${String(tag)}"`);
+    if (paramtypes) {
+      const paramtypesInstances = [];
+      for (const i in paramtypes) {
+        const { instance: sub, tag: subTag } = await buildDepModule(paramtypes[i]);
+        paramtypesInstances[i] = sub;
+        if (!dependenceGraph.has(subTag))
+          dependenceGraph.set(subTag, /* @__PURE__ */ new Set());
+        dependenceGraph.get(subTag).add(tag);
+      }
+      instance = parseModule(new Model(...paramtypesInstances));
+    } else {
+      instance = parseModule(new Model());
+    }
+    meta.push(...getMetaFromInstance(instance, tag, Model.name).map(parseMeta).filter((item) => !!item));
+    debug(`init module "${String(tag)}"`);
+    if (!_chunkYR5Q5F2Kjs.IS_ONLY_GENERATE)
+      await _phecdacore.invokeHandler.call(void 0, "init", instance);
+    debug(`add module "${String(tag)}"`);
+    moduleMap.set(tag, instance);
+    constructorMap.set(tag, Model);
+    return {
+      instance,
+      tag
+    };
+  }
+  _chunkYR5Q5F2Kjs.__name.call(void 0, buildDepModule, "buildDepModule");
+  for (const model of models)
+    await buildDepModule(model);
+  async function generateCode() {
+    if (generators) {
+      return Promise.all(generators.map((generator) => {
+        debug(`generate "${generator.name}" code to ${generator.path}`);
+        return generator.output(meta);
+      }));
+    }
+  }
+  _chunkYR5Q5F2Kjs.__name.call(void 0, generateCode, "generateCode");
+  generateCode().then(() => {
+    if (_chunkYR5Q5F2Kjs.IS_ONLY_GENERATE)
+      process.exit(4);
+  });
+  if (_chunkYR5Q5F2Kjs.IS_HMR) {
+    if (!globalThis.__PS_HMR__)
+      globalThis.__PS_HMR__ = [];
+    _optionalChain([globalThis, 'access', _2 => _2.__PS_HMR__, 'optionalAccess', _3 => _3.push, 'call', _4 => _4(async (files) => {
+      debug("reload files ");
+      for (const file of files) {
+        const models2 = await Promise.resolve().then(() => require(file));
+        for (const i in models2) {
+          if (_phecdacore.isPhecda.call(void 0, models2[i]))
+            await add(models2[i]);
+        }
+      }
+      generateCode();
+    })]);
+  }
+  return {
+    moduleMap,
+    constructorMap,
+    meta,
+    add,
+    del,
+    destroy
+  };
+}
+_chunkYR5Q5F2Kjs.__name.call(void 0, Factory, "Factory");
+function getMetaFromInstance(instance, tag, name) {
+  const vars = _phecdacore.getExposeKey.call(void 0, instance).filter((item) => typeof item === "string");
+  const baseState = _phecdacore.getState.call(void 0, instance);
+  initState(baseState);
+  const ctx = _phecdacore.get.call(void 0, instance, "context");
+  return vars.filter((i) => typeof instance[i] === "function").map((i) => {
+    const state = _phecdacore.getState.call(void 0, instance, i);
+    const meta = {
+      ...state,
+      name,
+      tag,
+      func: i
+    };
+    if (baseState.controller) {
+      if (typeof tag !== "string")
+        _chunkYR5Q5F2Kjs.log.call(void 0, `can't use Tag with ${typeof tag} on controller "${instance.constructor.name}",instead with "${tag = String(tag)}"`, "error");
+      initState(state);
+      meta.ctx = ctx;
+      meta.controller = baseState.controller;
+      meta[baseState.controller] = {
+        ...baseState[baseState.controller],
+        ...state[baseState.controller]
+      };
+      const params = [];
+      for (const i2 of state.params || []) {
+        if (!i2.pipe)
+          i2.pipe = state.pipe || baseState.pipe;
+        if (!i2.define)
+          i2.define = {};
+        params.unshift(i2);
+        if (i2.index === 0)
+          break;
+      }
+      meta.params = params;
+      meta.filter = state.filter || baseState.filter;
+      meta.define = {
+        ...baseState.define,
+        ...state.define
+      };
+      meta.plugins = [
+        .../* @__PURE__ */ new Set([
+          ...baseState.plugins,
+          ...state.plugins
+        ])
+      ];
+      meta.guards = [
+        .../* @__PURE__ */ new Set([
+          ...baseState.guards,
+          ...state.guards
+        ])
+      ];
+      meta.interceptors = [
+        .../* @__PURE__ */ new Set([
+          ...baseState.interceptors,
+          ...state.interceptors
+        ])
+      ];
+    }
+    return new Meta(meta, getParamTypes(instance, i) || []);
+  });
+}
+_chunkYR5Q5F2Kjs.__name.call(void 0, getMetaFromInstance, "getMetaFromInstance");
+function getParamTypes(Module, key) {
+  return Reflect.getMetadata("design:paramtypes", Module, key);
+}
+_chunkYR5Q5F2Kjs.__name.call(void 0, getParamTypes, "getParamTypes");
+function initState(state) {
+  if (!state.define)
+    state.define = {};
+  if (!state.plugins)
+    state.plugins = /* @__PURE__ */ new Set();
+  if (!state.guards)
+    state.guards = /* @__PURE__ */ new Set();
+  if (!state.interceptors)
+    state.interceptors = /* @__PURE__ */ new Set();
+}
+_chunkYR5Q5F2Kjs.__name.call(void 0, initState, "initState");
+
+
+
+
+
+exports.Meta = Meta; exports.emitter = emitter; exports.Factory = Factory;

package/dist/{chunk-76A2C5MK.js → chunk-INIUC4CX.js}

@@ -1,13 +1,13 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-var _chunkZD3QIREUjs = require('./chunk-ZD3QIREU.js');
+var _chunkYR5Q5F2Kjs = require('./chunk-YR5Q5F2K.js');
 
 // src/rpc/helper.ts
 var _os = require('os');
 function genClientQueue(key) {
   return `PS-${key ? `${key}-` : ""}${_os.hostname.call(void 0, )}-${process.pid}`;
 }
-_chunkZD3QIREUjs.__name.call(void 0, genClientQueue, "genClientQueue");
+_chunkYR5Q5F2Kjs.__name.call(void 0, genClientQueue, "genClientQueue");
 
 
 

package/dist/{chunk-77NDBQUP.mjs → chunk-ITTD2GBR.mjs}

@@ -10,10 +10,9 @@ var __publicField = (obj, key, value) => {
 var UNMOUNT_SYMBOL = "__PS_UNMOUNT__";
 var ERROR_SYMBOL = "__PS_ERROR__";
 var IS_HMR = process.env.NODE_ENV === "development";
-var IS_ONLY_CODE = !!process.env.PS_CODE;
+var IS_ONLY_GENERATE = !!process.env.PS_GENERATE;
 var IS_STRICT = !!process.env.PS_STRICT;
 var LOG_LEVEL = Number(process.env.PS_LOG_LEVEL || 0);
-var PS_FILE_RE = /[^.](?:\.controller|rpc|service|module|extension|ext|guard|interceptor|plugin|filter|pipe|edge)\.ts$/i;
 var PS_EXIT_CODE;
 (function(PS_EXIT_CODE2) {
   PS_EXIT_CODE2[PS_EXIT_CODE2["RELAUNCH"] = 2] = "RELAUNCH";
@@ -77,10 +76,9 @@ export {
   UNMOUNT_SYMBOL,
   ERROR_SYMBOL,
   IS_HMR,
-  IS_ONLY_CODE,
+  IS_ONLY_GENERATE,
   IS_STRICT,
   LOG_LEVEL,
-  PS_FILE_RE,
   PS_EXIT_CODE,
   log,
   getConfig,

package/dist/{chunk-D43Y5B7X.js → chunk-MAXJYJDI.js}

@@ -1,14 +1,14 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); 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 _chunkZD3QIREUjs = require('./chunk-ZD3QIREU.js');
+var _chunkYR5Q5F2Kjs = require('./chunk-YR5Q5F2K.js');
 
 // src/hmr.ts
 function HMR(cb) {
-  if (_chunkZD3QIREUjs.IS_HMR)
+  if (_chunkYR5Q5F2Kjs.IS_HMR)
     _optionalChain([globalThis, 'access', _ => _.__PS_HMR__, 'optionalAccess', _2 => _2.push, 'call', _3 => _3(cb)]);
 }
-_chunkZD3QIREUjs.__name.call(void 0, HMR, "HMR");
+_chunkYR5Q5F2Kjs.__name.call(void 0, HMR, "HMR");
 
 
 

package/dist/{chunk-DWVJG3GB.mjs → chunk-N3H5Q64U.mjs}

@@ -1,6 +1,6 @@
 import {
   __name
-} from "./chunk-77NDBQUP.mjs";
+} from "./chunk-ITTD2GBR.mjs";
 
 // src/server/helper.ts
 function resolveDep(ret, key) {