@akanjs/server 0.0.39 → 0.0.40

package/src/processor.js

@@ -0,0 +1,85 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var processor_exports = {};
+__export(processor_exports, {
+  processorOf: () => processorOf,
+  queueOf: () => queueOf
+});
+module.exports = __toCommonJS(processor_exports);
+var import_common = require("@akanjs/common");
+var import_service = require("@akanjs/service");
+var import_signal = require("@akanjs/signal");
+var import_bull = require("@nestjs/bull");
+var import_common2 = require("@nestjs/common");
+const convertProcessFunction = /* @__PURE__ */ __name((gqlMeta, argMetas, internalArgMetas, fn) => {
+  return async function(job, done) {
+    const args = [];
+    argMetas.forEach((argMeta) => {
+      if (argMeta.type === "Msg") args[argMeta.idx] = (0, import_signal.deserializeArg)(argMeta, job.data[argMeta.idx]);
+      else throw new Error(`Invalid ArgMeta Type ${argMeta.type}`);
+    });
+    internalArgMetas.forEach((internalArgMeta) => {
+      if (internalArgMeta.type === "Job") args[internalArgMeta.idx] = job;
+      else throw new Error(`Invalid InternalArgMeta Type ${internalArgMeta.type}`);
+    });
+    this.logger?.log(`Process-${gqlMeta.key} started`);
+    const result = await fn.apply(this, args);
+    this.logger?.log(`Process-${gqlMeta.key} finished`);
+    done(null, result);
+  };
+}, "convertProcessFunction");
+const processorOf = /* @__PURE__ */ __name((sigRef, allSrvs) => {
+  const sigMeta = (0, import_signal.getSigMeta)(sigRef);
+  const serverMode = process.env.SERVER_MODE ?? "federation";
+  const gqlMetas = (0, import_signal.getGqlMetas)(sigRef).filter((gqlMeta) => gqlMeta.type === "Process").filter((gqlMeta) => gqlMeta.signalOption.serverType === "all" || serverMode === "all" || gqlMeta.signalOption.serverType === serverMode);
+  let QueueProcessor = class QueueProcessor {
+    static {
+      __name(this, "QueueProcessor");
+    }
+  };
+  Object.keys(allSrvs).forEach((srv) => {
+    if (!(0, import_service.isServiceEnabled)(allSrvs[srv])) return;
+    (0, import_common2.Inject)(allSrvs[srv])(QueueProcessor.prototype, (0, import_common.lowerlize)(srv));
+  });
+  for (const gqlMeta of gqlMetas) {
+    const [argMetas, internalArgMetas] = (0, import_signal.getArgMetas)(sigRef, gqlMeta.key);
+    const descriptor = {
+      ...Object.getOwnPropertyDescriptor(sigRef.prototype, gqlMeta.key) ?? {}
+    };
+    descriptor.value = convertProcessFunction(gqlMeta, argMetas, internalArgMetas, descriptor.value);
+    Object.defineProperty(QueueProcessor.prototype, gqlMeta.key, descriptor);
+    (0, import_bull.Process)(gqlMeta.key)(QueueProcessor.prototype, gqlMeta.key, descriptor);
+  }
+  (0, import_bull.Processor)(sigMeta.refName)(QueueProcessor);
+  return QueueProcessor;
+}, "processorOf");
+const queueOf = /* @__PURE__ */ __name((sigRef, queue) => {
+  const sigMeta = (0, import_signal.getSigMeta)(sigRef);
+  const gqlMetas = (0, import_signal.getGqlMetas)(sigRef).filter((gqlMeta) => gqlMeta.type === "Process");
+  for (const gqlMeta of gqlMetas) {
+    if (queue[gqlMeta.key]) throw new Error(`Queue already has ${gqlMeta.key} in ${sigMeta.refName}`);
+    queue[gqlMeta.key] = (...args) => queue.add(gqlMeta.key, args);
+  }
+  return queue;
+}, "queueOf");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  processorOf,
+  queueOf
+});

package/src/resolver.d.ts

@@ -0,0 +1,9 @@
+import { T as Type } from '../types-H2HI4YUe.js';
+
+declare const resolverOf: (sigRef: Type, allSrvs: {
+    [key: string]: Type;
+}) => {
+    new (): {};
+};
+
+export { resolverOf };

package/src/resolver.js

@@ -0,0 +1,161 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var resolver_exports = {};
+__export(resolver_exports, {
+  resolverOf: () => resolverOf
+});
+module.exports = __toCommonJS(resolver_exports);
+var import_base = require("@akanjs/base");
+var import_common = require("@akanjs/common");
+var import_constant = require("@akanjs/constant");
+var import_nest = require("@akanjs/nest");
+var import_service = require("@akanjs/service");
+var import_signal = require("@akanjs/signal");
+var import_common2 = require("@nestjs/common");
+var Nest = __toESM(require("@nestjs/graphql"));
+var import_graphql_type_json = __toESM(require("graphql-type-json"));
+var import_graphql_upload = require("graphql-upload");
+var import_gql = require("./gql");
+const scalarNestReturnMap = /* @__PURE__ */ new Map([
+  [
+    import_base.Upload,
+    import_graphql_upload.GraphQLUpload
+  ],
+  [
+    import_base.ID,
+    Nest.ID
+  ],
+  [
+    import_base.Int,
+    Nest.Int
+  ],
+  [
+    import_base.Float,
+    Nest.Float
+  ],
+  [
+    import_base.JSON,
+    import_graphql_type_json.default
+  ],
+  [
+    Boolean,
+    Boolean
+  ],
+  [
+    Date,
+    Date
+  ],
+  [
+    String,
+    String
+  ],
+  [
+    Map,
+    import_graphql_type_json.default
+  ]
+]);
+const getNestReturn = /* @__PURE__ */ __name((returns, type = "object") => {
+  const [model, arrDepth] = (0, import_base.getNonArrayModel)(returns());
+  const modelRef = scalarNestReturnMap.get(model) ?? (type === "object" ? (0, import_gql.generateGql)(model) : (0, import_gql.generateGqlInput)(model));
+  return () => (0, import_base.arraiedModel)(modelRef, arrDepth);
+}, "getNestReturn");
+const internalArgMap = {
+  Parent: Nest.Parent,
+  Account: import_nest.Account,
+  UserIp: import_nest.UserIp,
+  Access: import_nest.Access,
+  Self: import_nest.Self,
+  Me: import_nest.Me,
+  Req: import_nest.Req,
+  Res: import_nest.Res
+};
+const resolverOf = /* @__PURE__ */ __name((sigRef, allSrvs) => {
+  const Rsv = (0, import_signal.copySignal)(sigRef);
+  const sigMeta = (0, import_signal.getSigMeta)(Rsv);
+  const gqlMetas = (0, import_signal.getGqlMetas)(Rsv);
+  Object.keys(allSrvs).forEach((srv) => {
+    if (!(0, import_service.isServiceEnabled)(allSrvs[srv])) return;
+    (0, import_common2.Inject)(allSrvs[srv])(Rsv.prototype, (0, import_common.lowerlize)(srv));
+  });
+  for (const gqlMeta of gqlMetas) {
+    if (gqlMeta.guards.some((guard) => guard === "None") || gqlMeta.signalOption.onlyFor === "restapi" || ![
+      "Query",
+      "Mutation"
+    ].includes(gqlMeta.type)) continue;
+    else if (gqlMeta.signalOption.sso) continue;
+    const [argMetas, internalArgMetas] = (0, import_signal.getArgMetas)(Rsv, gqlMeta.key);
+    const descriptor = Object.getOwnPropertyDescriptor(Rsv.prototype, gqlMeta.key) ?? {};
+    for (const argMeta of argMetas) {
+      Nest.Args({
+        name: argMeta.name,
+        type: getNestReturn(argMeta.returns, "input"),
+        ...argMeta.argsOption
+      })(Rsv.prototype, gqlMeta.key, argMeta.idx);
+    }
+    for (const internalArgMeta of internalArgMetas) {
+      const decorate = internalArgMap[internalArgMeta.type];
+      decorate(internalArgMeta.option ?? {})(Rsv.prototype, gqlMeta.key, internalArgMeta.idx);
+    }
+    (0, import_common2.UseGuards)(...gqlMeta.guards.map((guard) => import_nest.guards[guard]))(Rsv.prototype, gqlMeta.key, descriptor);
+    if (gqlMeta.type === "Query") Nest.Query(getNestReturn(gqlMeta.returns), gqlMeta.signalOption)(Rsv.prototype, gqlMeta.key, descriptor);
+    else if (gqlMeta.type === "Mutation") Nest.Mutation(getNestReturn(gqlMeta.returns), gqlMeta.signalOption)(Rsv.prototype, gqlMeta.key, descriptor);
+  }
+  const resolveFieldMetas = (0, import_signal.getResolveFieldMetas)(Rsv);
+  if (sigMeta.returns) {
+    const modelRef = sigMeta.returns();
+    const fieldMetas = (0, import_constant.getFieldMetas)(modelRef);
+    fieldMetas.filter((fieldMeta) => fieldMeta.isClass && !fieldMeta.isScalar).forEach((fieldMeta) => {
+      const classMeta = (0, import_constant.getClassMeta)(fieldMeta.modelRef);
+      const modelName = (0, import_common.lowerlize)(classMeta.type === "light" ? classMeta.refName.slice(5) : classMeta.refName);
+      const className = (0, import_common.capitalize)(modelName);
+      const serviceName = `${modelName}Service`;
+      Rsv.prototype[fieldMeta.key] = async function(parent) {
+        const service = this[serviceName];
+        return fieldMeta.arrDepth ? await service[`load${className}Many`](parent[fieldMeta.key]) : await service[`load${className}`](parent[fieldMeta.key]);
+      };
+      Nest.Parent()(Rsv.prototype, fieldMeta.key, 0);
+      Nest.ResolveField(getNestReturn(() => (0, import_base.arraiedModel)(fieldMeta.modelRef, fieldMeta.arrDepth)))(Rsv.prototype, fieldMeta.key, Object.getOwnPropertyDescriptor(Rsv.prototype, fieldMeta.key) ?? {});
+    });
+  }
+  for (const resolveFieldMeta of resolveFieldMetas) {
+    const [, internalArgMetas] = (0, import_signal.getArgMetas)(Rsv, resolveFieldMeta.key);
+    for (const internalArgMeta of internalArgMetas) {
+      const decorate = internalArgMap[internalArgMeta.type];
+      decorate(internalArgMeta.option ?? {})(Rsv.prototype, resolveFieldMeta.key, internalArgMeta.idx);
+    }
+    Nest.ResolveField(getNestReturn(resolveFieldMeta.returns))(Rsv.prototype, resolveFieldMeta.key, Object.getOwnPropertyDescriptor(Rsv.prototype, resolveFieldMeta.key) ?? {});
+  }
+  if (sigMeta.returns) Nest.Resolver(getNestReturn(sigMeta.returns))(Rsv);
+  else Nest.Resolver()(Rsv);
+  return Rsv;
+}, "resolverOf");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  resolverOf
+});

package/src/schema.d.ts

@@ -0,0 +1,12 @@
+import { T as Type } from '../types-H2HI4YUe.js';
+import { B as BaseMiddleware } from '../dbDecorators-z3rJpvxp.js';
+import { Schema } from 'mongoose';
+import '../types-CUkhtrLV.js';
+import 'dayjs';
+import 'fs';
+import 'stream';
+
+declare const schemaOf: <Mdl, Doc, Middleware extends BaseMiddleware>(modelRef: Type<Mdl>, docRef: Type<Doc>, middleware: Type<Middleware>) => Schema<null, Mdl, Doc, undefined, null, Mdl>;
+declare const addSchema: <Mdl, Doc, Input, Middleware extends BaseMiddleware>(modelRef: Type<Mdl>, docRef: Type<Doc>, inputRef: Type<Input>, middleware: Type<Middleware>) => Schema<null, Mdl, Doc, undefined, null, Mdl>;
+
+export { addSchema, schemaOf };

package/src/schema.js

@@ -0,0 +1,275 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var schema_exports = {};
+__export(schema_exports, {
+  addSchema: () => addSchema,
+  schemaOf: () => schemaOf
+});
+module.exports = __toCommonJS(schema_exports);
+var import_base = require("@akanjs/base");
+var import_common = require("@akanjs/common");
+var import_constant = require("@akanjs/constant");
+var import_document = require("@akanjs/document");
+var import_signal = require("@akanjs/signal");
+var import_mongoose = require("mongoose");
+var import__ = require(".");
+let ScalarSchemaStorage = class ScalarSchemaStorage2 {
+  static {
+    __name(this, "ScalarSchemaStorage");
+  }
+};
+let SchemaStorage = class SchemaStorage2 {
+  static {
+    __name(this, "SchemaStorage");
+  }
+};
+const scalarMongoTypeMap = /* @__PURE__ */ new Map([
+  [
+    import_base.ID,
+    import_document.ObjectId
+  ],
+  [
+    import_base.Int,
+    Number
+  ],
+  [
+    import_base.Float,
+    Number
+  ],
+  [
+    import_base.JSON,
+    import_mongoose.Schema.Types.Mixed
+  ],
+  [
+    Map,
+    Map
+  ],
+  [
+    String,
+    String
+  ],
+  [
+    Boolean,
+    Boolean
+  ],
+  [
+    Date,
+    Date
+  ]
+]);
+const applyMongoProp = /* @__PURE__ */ __name((schemaProps, fieldMeta) => {
+  if ([
+    "id",
+    "createdAt",
+    "updatedAt"
+  ].includes(fieldMeta.key) || fieldMeta.fieldType === "resolve") return;
+  const type = fieldMeta.isClass ? fieldMeta.isScalar ? createSchema(fieldMeta.modelRef) : import_document.ObjectId : scalarMongoTypeMap.get(fieldMeta.modelRef) ?? fieldMeta.modelRef;
+  let prop = {};
+  if (fieldMeta.optArrDepth) {
+    prop.type = type;
+    prop.required = true;
+    if (fieldMeta.isClass && !fieldMeta.refPath) prop.ref = (0, import_constant.getClassMeta)(fieldMeta.modelRef).refName;
+    if (fieldMeta.refPath) prop.refPath = fieldMeta.refPath;
+    if (typeof fieldMeta.min === "number") prop.min = fieldMeta.min;
+    if (typeof fieldMeta.max === "number") prop.max = fieldMeta.max;
+    if (fieldMeta.enum) prop.enum = [
+      ...fieldMeta.enum.values,
+      ...fieldMeta.nullable ? [
+        null
+      ] : []
+    ];
+    if (typeof fieldMeta.minlength === "number") prop.minlength = fieldMeta.minlength;
+    if (typeof fieldMeta.maxlength === "number") prop.maxlength = fieldMeta.maxlength;
+    if (fieldMeta.validate) {
+      prop.validate = function(value) {
+        return fieldMeta.validate?.(fieldMeta.name === "Date" && !!value ? (0, import_base.dayjs)() : value, this) ?? true;
+      };
+    }
+    prop = {
+      type: (0, import_base.arraiedModel)(prop, fieldMeta.optArrDepth),
+      default: [],
+      required: true
+    };
+    if (fieldMeta.modelRef.prototype === Date.prototype) {
+      prop.get = (dates) => dates.map((date) => (0, import_base.dayjs)(date));
+      prop.set = (days) => days.map((day) => day.toDate());
+    }
+    if (fieldMeta.isClass && !fieldMeta.isScalar || fieldMeta.modelRef.prototype === import_base.ID.prototype) {
+      prop.get = (ids) => ids.map((id) => id.toString());
+      prop.set = (ids) => ids.map((id) => new import_mongoose.Types.ObjectId(id));
+    }
+  } else {
+    prop.type = (0, import_base.arraiedModel)(type, fieldMeta.arrDepth);
+    prop.required = !fieldMeta.nullable;
+    if (fieldMeta.isMap) {
+      prop.of = scalarMongoTypeMap.get(fieldMeta.of) ?? createSchema(fieldMeta.of);
+      if (!fieldMeta.default) prop.default = /* @__PURE__ */ new Map();
+    }
+    if (fieldMeta.default !== null) {
+      if (typeof fieldMeta.default === "function") prop.default = function() {
+        const def = fieldMeta.default(this);
+        return (0, import_common.isDayjs)(def) ? def.toDate() : def;
+      };
+      else prop.default = (0, import_common.isDayjs)(fieldMeta.default) ? fieldMeta.default.toDate() : fieldMeta.default instanceof import_base.Enum ? [
+        ...fieldMeta.default.values
+      ] : fieldMeta.default;
+    }
+    if (typeof fieldMeta.immutable !== "undefined") prop.immutable = fieldMeta.immutable;
+    if (fieldMeta.isClass && !fieldMeta.refPath) prop.ref = (0, import_constant.getClassMeta)(fieldMeta.modelRef).refName;
+    if (fieldMeta.refPath) prop.refPath = fieldMeta.refPath;
+    if (typeof fieldMeta.min === "number") prop.min = fieldMeta.min;
+    if (typeof fieldMeta.max === "number") prop.max = fieldMeta.max;
+    if (fieldMeta.enum) prop.enum = [
+      ...fieldMeta.enum.values,
+      ...fieldMeta.nullable ? [
+        null
+      ] : []
+    ];
+    if (typeof fieldMeta.select === "boolean") prop.select = fieldMeta.select;
+    if (typeof fieldMeta.minlength === "number") prop.minlength = fieldMeta.minlength;
+    if (typeof fieldMeta.maxlength === "number") prop.maxlength = fieldMeta.maxlength;
+    if (fieldMeta.nullable) {
+      prop.get = (v) => v === void 0 ? void 0 : v;
+      prop.set = (v) => v === null ? void 0 : v;
+    }
+    if (fieldMeta.modelRef.prototype === Date.prototype) {
+      prop.get = (date) => date ? (0, import_base.dayjs)(date) : void 0;
+      prop.set = (day) => day ? (0, import_base.dayjs)(day).toDate() : void 0;
+    }
+    if (fieldMeta.isClass && !fieldMeta.isScalar || fieldMeta.modelRef.prototype === import_base.ID.prototype) {
+      prop.get = (id) => id ? id.toString() : void 0;
+      prop.set = (id) => id ? new import_mongoose.Types.ObjectId(id) : void 0;
+    }
+    if (fieldMeta.isClass && fieldMeta.isScalar && fieldMeta.default === null && !fieldMeta.nullable) {
+      prop.default = (0, import_signal.makeDefault)(fieldMeta.modelRef);
+    }
+    if (fieldMeta.validate) {
+      prop.validate = function(value) {
+        return fieldMeta.validate?.(fieldMeta.name === "Date" && !!value ? (0, import_base.dayjs)() : value, this) ?? true;
+      };
+    }
+  }
+  schemaProps[fieldMeta.key] = prop;
+}, "applyMongoProp");
+const createSchema = /* @__PURE__ */ __name((modelRef) => {
+  const classMeta = (0, import_constant.getClassMeta)(modelRef);
+  const schemaMeta = Reflect.getMetadata(classMeta.refName, ScalarSchemaStorage.prototype);
+  if (schemaMeta) return schemaMeta;
+  const fieldMetas = (0, import_constant.getFieldMetas)(modelRef);
+  const schemaProps = {};
+  fieldMetas.forEach((fieldMeta) => {
+    applyMongoProp(schemaProps, fieldMeta);
+  });
+  const schema = new import_mongoose.Schema(schemaProps);
+  Reflect.defineMetadata(classMeta.refName, schema, ScalarSchemaStorage.prototype);
+  return schema;
+}, "createSchema");
+const schemaOf = /* @__PURE__ */ __name((modelRef, docRef, middleware) => {
+  const classMeta = (0, import_constant.getClassMeta)(docRef);
+  const schemaMeta = Reflect.getMetadata(classMeta.refName, SchemaStorage.prototype);
+  if (schemaMeta) return schemaMeta;
+  const fieldMetas = (0, import_constant.getFieldMetas)(docRef);
+  const schemaProps = {
+    createdAt: {
+      type: Date,
+      get: /* @__PURE__ */ __name((date) => date ? (0, import_base.dayjs)(date) : date, "get"),
+      set: /* @__PURE__ */ __name((day) => day ? (0, import_base.dayjs)(day).toDate() : day, "set")
+    },
+    updatedAt: {
+      type: Date,
+      get: /* @__PURE__ */ __name((date) => date ? (0, import_base.dayjs)(date) : date, "get"),
+      set: /* @__PURE__ */ __name((day) => day ? (0, import_base.dayjs)(day).toDate() : day, "set")
+    }
+  };
+  fieldMetas.forEach((fieldMeta) => {
+    applyMongoProp(schemaProps, fieldMeta);
+  });
+  const schema = new import_mongoose.Schema(schemaProps, (0, import_document.getDefaultSchemaOptions)());
+  schema.methods.refresh = async function() {
+    Object.assign(this, await this.constructor.findById(this._id));
+    return this;
+  };
+  Object.getOwnPropertyNames(docRef.prototype).forEach((name) => {
+    if (name === "constructor") return;
+    schema.methods[name] = Object.getOwnPropertyDescriptor(docRef.prototype, name)?.value;
+  });
+  schema.pre("save", async function(next) {
+    const model = this.constructor;
+    if (this.isNew) model.addSummary([
+      "total",
+      this.status
+    ]);
+    else if (!!this.removedAt && this.isModified("removedAt")) model.subSummary([
+      "total",
+      this.status
+    ]);
+    next();
+  });
+  const onSchema = Object.getOwnPropertyDescriptor(middleware.prototype, "onSchema")?.value;
+  onSchema?.(schema);
+  schema.index({
+    removedAt: -1
+  });
+  Reflect.defineMetadata(classMeta.refName, schema, SchemaStorage.prototype);
+  return schema;
+}, "schemaOf");
+const addSchema = /* @__PURE__ */ __name((modelRef, docRef, inputRef, middleware) => {
+  const originDocClassMeta = (0, import_constant.getClassMeta)(docRef);
+  const originInputClassMeta = (0, import_constant.getClassMeta)(inputRef);
+  const originDoc = (0, import_constant.getFullModelRef)(originDocClassMeta.refName);
+  const originInput = (0, import_constant.getInputModelRef)(originInputClassMeta.refName);
+  const classMeta = (0, import_constant.getClassMeta)(docRef);
+  const modelSchema = Reflect.getMetadata(classMeta.refName, SchemaStorage.prototype);
+  if (!modelSchema) throw new Error(`Schema of ${classMeta.refName} not found`);
+  const fieldMetas = (0, import_constant.getFieldMetas)(docRef);
+  const schemaProps = {
+    createdAt: {
+      type: Date,
+      get: /* @__PURE__ */ __name((date) => date ? (0, import_base.dayjs)(date) : date, "get"),
+      set: /* @__PURE__ */ __name((day) => day ? (0, import_base.dayjs)(day).toDate() : day, "set")
+    },
+    updatedAt: {
+      type: Date,
+      get: /* @__PURE__ */ __name((date) => date ? (0, import_base.dayjs)(date) : date, "get"),
+      set: /* @__PURE__ */ __name((day) => day ? (0, import_base.dayjs)(day).toDate() : day, "set")
+    }
+  };
+  fieldMetas.forEach((fieldMeta) => {
+    applyMongoProp(schemaProps, fieldMeta);
+    (0, import__.applyNestField)(originDoc, fieldMeta);
+  });
+  const inputFieldMetas = (0, import_constant.getFieldMetas)(inputRef);
+  inputFieldMetas.forEach((fieldMeta) => {
+    (0, import__.applyNestField)(originInput, fieldMeta, "input");
+  });
+  const schema = new import_mongoose.Schema(schemaProps, (0, import_document.getDefaultSchemaOptions)());
+  modelSchema.add(schema);
+  Object.getOwnPropertyNames(docRef.prototype).forEach((name) => {
+    if (name === "constructor") return;
+    modelSchema.methods[name] = Object.getOwnPropertyDescriptor(docRef.prototype, name)?.value;
+  });
+  const onSchema = Object.getOwnPropertyDescriptor(middleware.prototype, "onSchema")?.value;
+  onSchema?.(modelSchema);
+  return modelSchema;
+}, "addSchema");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addSchema,
+  schemaOf
+});

package/src/searchDaemon.d.ts

@@ -0,0 +1,13 @@
+import { T as Type } from '../types-H2HI4YUe.js';
+import { T as TextDoc } from '../types-CUkhtrLV.js';
+import 'dayjs';
+import 'fs';
+import 'stream';
+
+declare const makeTextFilter: (modelRef: Type) => (data: Record<string, any>, assignObj?: {
+    [key: string]: string;
+}) => TextDoc;
+declare class SearchDaemonModule {
+}
+
+export { SearchDaemonModule, makeTextFilter };