phecda-server 6.0.2 → 6.1.0

package/dist/{chunk-WXFZZZRY.mjs → chunk-2CFYUXPM.mjs}

@@ -5,7 +5,7 @@ import {
   LOG_LEVEL,
   __name,
   log
-} from "./chunk-UXD62LGG.mjs";
+} from "./chunk-G7TD2VB7.mjs";
 
 // src/helper.ts
 import pc from "picocolors";

package/dist/{chunk-HDQAT2IM.mjs → chunk-3H3T54IC.mjs}

@@ -3,7 +3,7 @@ import {
   IS_ONLY_GENERATE,
   __name,
   log
-} from "./chunk-UXD62LGG.mjs";
+} from "./chunk-G7TD2VB7.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);
@@ -223,15 +254,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
 };