phecda-server 6.0.2 → 7.0.0-alpha.0

package/bin/cli.mjs

@@ -1,158 +1,161 @@
 #! /usr/bin/env node
-import { fork } from 'child_process'
-import { createRequire } from 'module'
-import { fileURLToPath } from 'url'
-
-import { dirname, join, resolve } from 'path'
-import pc from 'picocolors'
-import cac from 'cac'
-import fse from 'fs-extra'
-import { log } from '../dist/index.mjs'
-
-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
-
-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 [root]', 'init config file')
-  .allowUnknownOptions()
-  .option('-t,--tsconfig <tsconfig>', 'init tsconfig file', {
-    default: 'tsconfig.json',
-  })
-  .action(async (root, options) => {
-    if (!root)
-      root = ''
-
-    const tsconfigPath = join(root, options.tsconfig)
-    const psconfigPath = join(root, options.config)
-
-    if (!fse.existsSync(tsconfigPath)) {
-      log(`create ${tsconfigPath}`)
-
-      await fse.copyFile(
-        resolve(__dirname, '../assets/tsconfig.json'),
-        tsconfigPath,
-      )
-    }
-
-    if (!fse.existsSync(psconfigPath)) {
-      log(`create ${psconfigPath}`)
-
-      await fse.copyFile(resolve(__dirname, '../assets/ps.json'), psconfigPath)
-    }
-
-    log('init finish')
-  })
-
-cli
-  .command('<file> [root]', 'run file')
-  .alias('run')
-  .allowUnknownOptions()
-  .alias('run')
-  .action((file, root, options) => {
-    if (root)
-      process.env.PS_WORKDIR = root
-    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> [root]', 'generate code(mainly for ci)')
-  .allowUnknownOptions()
-  .action((file, root, options) => {
-    if (root)
-      process.env.PS_WORKDIR = root
-    process.env.PS_GENERATE = 'true'
-    process.env.PS_CONFIG_FILE = options.config
-    startChild(file, options['--'])
-  })
-
-cli.help()
-cli.version(require('../package.json').version)
-
-cli.parse()
+import { fork } from 'child_process'
+import { createRequire } from 'module'
+import { fileURLToPath } from 'url'
+
+import { dirname, join, resolve } from 'path'
+import pc from 'picocolors'
+import cac from 'cac'
+import fse from 'fs-extra'
+import { log } from '../dist/index.mjs'
+
+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
+
+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 [root]', 'init config file')
+  .allowUnknownOptions()
+  .option('-t,--tsconfig <tsconfig>', 'init tsconfig file', {
+    default: 'tsconfig.json',
+  })
+  .action(async (root, options) => {
+    if (!root)
+      root = ''
+
+    const tsconfigPath = join(root, options.tsconfig)
+    const psconfigPath = join(root, options.config)
+
+    if (!fse.existsSync(tsconfigPath)) {
+      log(`create ${tsconfigPath}`)
+
+      await fse.copyFile(
+        resolve(__dirname, '../assets/tsconfig.json'),
+        tsconfigPath,
+      )
+    }
+
+    if (!fse.existsSync(psconfigPath)) {
+      log(`create ${psconfigPath}`)
+
+      await fse.copyFile(resolve(__dirname, '../assets/ps.json'), psconfigPath)
+    }
+
+    log('init finish')
+  })
+
+cli
+  .command('<file> [root]', 'run file')
+  .alias('run')
+  .allowUnknownOptions()
+  .alias('run')
+  .action((file, root, options) => {
+    if (root)
+      process.env.PS_WORKDIR = root
+    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()
+
+      if (input === 'c')
+        console.clear()
+    })
+  })
+
+cli
+  .command('generate <file> [root]', 'generate code(mainly for ci)')
+  .allowUnknownOptions()
+  .action((file, root, options) => {
+    if (root)
+      process.env.PS_WORKDIR = root
+    process.env.PS_GENERATE = 'true'
+    process.env.PS_CONFIG_FILE = options.config
+    startChild(file, options['--'])
+  })
+
+cli.help()
+cli.version(require('../package.json').version)
+
+cli.parse()

package/dist/{chunk-HDQAT2IM.mjs → chunk-5622RBNB.mjs}

@@ -3,7 +3,7 @@ import {
   IS_ONLY_GENERATE,
   __name,
   log
-} from "./chunk-UXD62LGG.mjs";
+} from "./chunk-WHJ5FALK.mjs";
 
 // src/meta.ts
 var Meta = class {
@@ -25,13 +25,7 @@ import { getInject, getMergedMeta, getMetaKey, getMetaParams, getTag, invokeInit
 import Debug from "debug";
 var debug = Debug("phecda-server(createPhecda)");
 var emitter = new EventEmitter();
-async function createPhecda(models, opts = {}) {
-  const moduleMap = /* @__PURE__ */ new Map();
-  const meta = [];
-  const modelMap = /* @__PURE__ */ new WeakMap();
-  const modelSet = /* @__PURE__ */ new WeakSet();
-  const dependenceGraph = /* @__PURE__ */ new Map();
-  const { parseModule = /* @__PURE__ */ __name((module) => module, "parseModule"), parseMeta = /* @__PURE__ */ __name((meta2) => meta2, "parseMeta"), generators } = opts;
+function defaultServerInject() {
   if (!getInject("watcher")) {
     setInject("watcher", ({ eventName, instance, property, options }) => {
       const fn = typeof instance[property] === "function" ? instance[property].bind(instance) : (v) => instance[property] = v;
@@ -42,51 +36,98 @@ async function createPhecda(models, opts = {}) {
       };
     });
   }
-  async function del(tag) {
-    if (!moduleMap.has(tag)) return;
-    const module = moduleMap.get(tag);
-    debug(`unmount module "${String(tag)}"`);
-    await invokeUnmount(module);
-    debug(`del module "${String(tag)}"`);
-    moduleMap.delete(tag);
-    modelMap.delete(module);
-    for (let i = meta.length - 1; i >= 0; i--) {
-      if (meta[i].data.tag === tag) meta.splice(i, 1);
-    }
-    return module;
+}
+__name(defaultServerInject, "defaultServerInject");
+var phecdaNamespace = /* @__PURE__ */ new Map();
+var ServerPhecda = class {
+  static {
+    __name(this, "ServerPhecda");
   }
-  __name(del, "del");
-  async function destroy() {
-    debug("destroy all");
-    for (const [tag] of moduleMap) await del(tag);
+  moduleMap = /* @__PURE__ */ new Map();
+  meta = [];
+  modelMap = /* @__PURE__ */ new WeakMap();
+  modelSet = /* @__PURE__ */ new WeakSet();
+  dependenceGraph = /* @__PURE__ */ new Map();
+  parseModule;
+  parseMeta;
+  generators;
+  constructor(options) {
+    defaultServerInject();
+    const { namespace = "default", parseModule = /* @__PURE__ */ __name((module) => module, "parseModule"), parseMeta = /* @__PURE__ */ __name((meta) => meta, "parseMeta"), generators = [] } = options;
+    phecdaNamespace.set(namespace, this);
+    this.parseMeta = parseMeta;
+    this.parseModule = parseModule;
+    this.generators = generators;
   }
-  __name(destroy, "destroy");
-  async function add(Model) {
+  async start(models) {
+    for (const model of models) await this.buildDepModule(model);
+    const generateCode = /* @__PURE__ */ __name(async () => {
+      if (IS_HMR) {
+        return Promise.all(this.generators.map((generator) => {
+          debug(`generate "${generator.name}" code to ${generator.path}`);
+          return generator.output(this.meta);
+        }));
+      }
+    }, "generateCode");
+    generateCode().then(() => {
+      if (IS_ONLY_GENERATE) process.exit(4);
+    });
+    if (IS_HMR) {
+      if (!globalThis.__PS_HMR__) globalThis.__PS_HMR__ = [];
+      globalThis.__PS_HMR__?.push(async (files) => {
+        debug("reload files ");
+        for (const file of files) {
+          const models2 = await import(file);
+          for (const i in models2) {
+            if (isPhecda(models2[i])) await this.add(models2[i]);
+          }
+        }
+        generateCode();
+      });
+    }
+  }
+  async add(Model) {
     const tag = getTag(Model);
-    const oldInstance = await del(tag);
-    const { module: newModule } = await buildDepModule(Model);
-    if (oldInstance && dependenceGraph.has(tag)) {
+    const oldInstance = await this.del(tag);
+    const { module: newModule } = await this.buildDepModule(Model);
+    if (oldInstance && this.dependenceGraph.has(tag)) {
       debug(`replace module "${String(tag)}"`);
       [
-        ...dependenceGraph.get(tag)
+        ...this.dependenceGraph.get(tag)
       ].forEach((tag2) => {
-        const module = moduleMap.get(tag2);
+        const module = this.moduleMap.get(tag2);
         for (const key in module) {
           if (module[key] === oldInstance) module[key] = newModule;
         }
       });
     }
   }
-  __name(add, "add");
-  async function buildDepModule(Model) {
+  async del(tag) {
+    if (!this.moduleMap.has(tag)) return;
+    const module = this.moduleMap.get(tag);
+    debug(`unmount module "${String(tag)}"`);
+    await invokeUnmount(module);
+    debug(`del module "${String(tag)}"`);
+    this.moduleMap.delete(tag);
+    this.modelMap.delete(module);
+    for (let i = this.meta.length - 1; i >= 0; i--) {
+      if (this.meta[i].data.tag === tag) this.meta.splice(i, 1);
+    }
+    return module;
+  }
+  async destroy() {
+    debug("destroy all");
+    for (const [tag] of this.moduleMap) await this.del(tag);
+  }
+  async buildDepModule(Model) {
     const paramtypes = getParamTypes(Model);
     let module;
     const tag = getTag(Model);
-    if (moduleMap.has(tag)) {
-      module = moduleMap.get(tag);
+    if (this.moduleMap.has(tag)) {
+      module = this.moduleMap.get(tag);
       if (!module) throw new Error(`exist Circular-Dependency or Multiple modules with the same name/tag [tag] ${String(tag)}--[module] ${Model}`);
-      if (modelMap.get(module) !== Model && !modelSet.has(Model)) {
-        modelSet.add(Model);
+      if (this.modelMap.get(module) !== Model && !this.modelSet.has(Model)) {
+        this.modelSet.add(Model);
         if (module instanceof Model) log(`Module taged ${String(tag)} has been overridden`);
         else log(`Synonym module: Module taged "${String(tag)}" has been loaded before, so phecda-server won't load Module "${Model.name}"`, "warn");
       }
@@ -95,69 +136,59 @@ async function createPhecda(models, opts = {}) {
         tag
       };
     }
-    moduleMap.set(tag, void 0);
+    this.moduleMap.set(tag, void 0);
     debug(`instantiate module "${String(tag)}"`);
     if (paramtypes) {
       const paramtypesInstances = [];
       for (const i in paramtypes) {
-        const { module: sub, tag: subTag } = await buildDepModule(paramtypes[i]);
+        const { module: sub, tag: subTag } = await this.buildDepModule(paramtypes[i]);
         paramtypesInstances[i] = sub;
-        if (!dependenceGraph.has(subTag)) dependenceGraph.set(subTag, /* @__PURE__ */ new Set());
-        dependenceGraph.get(subTag).add(tag);
+        if (!this.dependenceGraph.has(subTag)) this.dependenceGraph.set(subTag, /* @__PURE__ */ new Set());
+        this.dependenceGraph.get(subTag).add(tag);
       }
-      module = parseModule(new Model(...paramtypesInstances));
+      module = this.parseModule(new Model(...paramtypesInstances));
     } else {
-      module = parseModule(new Model());
+      module = this.parseModule(new Model());
     }
-    meta.push(...getMetaFromInstance(module, tag, Model.name).map(parseMeta).filter((item) => !!item));
+    this.meta.push(...getMetaFromInstance(module, tag, Model.name).map(this.parseMeta).filter((item) => !!item));
     debug(`init module "${String(tag)}"`);
     if (!IS_ONLY_GENERATE) await invokeInit(module);
     debug(`add module "${String(tag)}"`);
-    moduleMap.set(tag, module);
-    modelMap.set(module, Model);
+    this.moduleMap.set(tag, module);
+    this.modelMap.set(module, Model);
     return {
       module,
       tag
     };
   }
-  __name(buildDepModule, "buildDepModule");
-  for (const model of models) await buildDepModule(model);
-  async function generateCode() {
-    if (generators && IS_HMR) {
-      return Promise.all(generators.map((generator) => {
-        debug(`generate "${generator.name}" code to ${generator.path}`);
-        return generator.output(meta);
-      }));
-    }
+  has(modelOrTag) {
+    return this.moduleMap.has(typeof modelOrTag === "function" ? getTag(modelOrTag) : modelOrTag);
   }
-  __name(generateCode, "generateCode");
-  generateCode().then(() => {
-    if (IS_ONLY_GENERATE) process.exit(4);
-  });
-  if (IS_HMR) {
-    if (!globalThis.__PS_HMR__) globalThis.__PS_HMR__ = [];
-    globalThis.__PS_HMR__?.push(async (files) => {
-      debug("reload files ");
-      for (const file of files) {
-        const models2 = await import(file);
-        for (const i in models2) {
-          if (isPhecda(models2[i])) await add(models2[i]);
-        }
-      }
-      generateCode();
-    });
+  get(modelOrTag) {
+    const tag = typeof modelOrTag === "function" ? getTag(modelOrTag) : modelOrTag;
+    if (!this.has(tag)) throw new Error(`module "${tag.toString()}" doesn't exist`);
+    return this.moduleMap.get(tag);
   }
-  return {
-    moduleMap,
-    modelMap,
-    meta,
-    add,
-    del,
-    destroy
-  };
+};
+async function Factory(models, opts = {}) {
+  const phecda = new ServerPhecda(opts);
+  await phecda.start(models);
+  return phecda;
 }
-__name(createPhecda, "createPhecda");
-var Factory = createPhecda;
+__name(Factory, "Factory");
+function useS(nsOrModel, namespace) {
+  if (!nsOrModel) {
+    namespace = "default";
+  } else {
+    if (typeof nsOrModel === "string") namespace = nsOrModel;
+    else if (!namespace) namespace = "default";
+  }
+  if (!phecdaNamespace.has(namespace)) throw new Error(`namespace "${namespace}" doesn't exist`);
+  const serverPhecda = phecdaNamespace.get(namespace);
+  if (nsOrModel && typeof nsOrModel !== "string") return serverPhecda.get(nsOrModel);
+  else return serverPhecda;
+}
+__name(useS, "useS");
 function getMetaFromInstance(instance, tag, name) {
   const propertyKeys = getMetaKey(instance).filter((item) => typeof item === "string");
   const baseMeta = getMergedMeta(instance, void 0);
@@ -191,9 +222,8 @@ function getMetaFromInstance(instance, tag, name) {
         ...meta.define
       };
       for (const item of [
-        "plugins",
-        "guards",
-        "interceptors"
+        "addons",
+        "guards"
       ]) {
         const set = new Set(baseMeta[item]);
         if (meta[item]) {
@@ -223,15 +253,13 @@ function getParamTypes(Model, key) {
   return Reflect.getMetadata("design:paramtypes", Model, key);
 }
 __name(getParamTypes, "getParamTypes");
-function isObject(o) {
-  return Object.prototype.toString.call(o) === "[object Object]";
-}
-__name(isObject, "isObject");
 
 export {
   Meta,
   emitter,
-  createPhecda,
+  defaultServerInject,
+  phecdaNamespace,
+  ServerPhecda,
   Factory,
-  isObject
+  useS
 };