@akanjs/server 0.0.4

package/src/resolver.js

@@ -0,0 +1,142 @@
+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 __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_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 = (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);
+};
+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 = (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) => {
+    (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;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  resolverOf
+});

package/src/schema.d.ts

@@ -0,0 +1,33 @@
+import { Type } from "@akanjs/base";
+import { FilterQuery, PipelineStage, type ProjectionType, Schema } from "mongoose";
+import { type BaseMiddleware } from ".";
+export declare const getDefaultSchemaOptions: <TSchema, TDocument>() => {
+    toJSON: {
+        getters: boolean;
+        virtuals: boolean;
+    };
+    toObject: {
+        getters: boolean;
+        virtuals: boolean;
+    };
+    _id: boolean;
+    id: boolean;
+    timestamps: boolean;
+    methods: {
+        refresh: () => Promise<any>;
+    };
+    statics: {
+        pickOne: (query: FilterQuery<TSchema>, projection?: ProjectionType<TSchema>) => Promise<TDocument>;
+        pickById: (docId: string | undefined, projection?: ProjectionType<TSchema>) => Promise<TDocument>;
+        sample: (query: FilterQuery<TSchema>, size?: number, aggregations?: PipelineStage[]) => Promise<TDocument[]>;
+        sampleOne: (query: FilterQuery<TSchema>, aggregations?: PipelineStage[]) => Promise<TDocument | null>;
+        addSummary: (prefix?: string, num?: number) => Promise<void>;
+        moveSummary: (prev: string, next: string, num?: number) => Promise<void>;
+        subSummary: (prefix?: string, num?: number) => Promise<void>;
+    };
+};
+export declare const schemaOf: <Mdl, Doc, Middleware extends BaseMiddleware>(modelRef: Type<Mdl>, docRef: Type<Doc>, middleware: Type<Middleware>) => Schema<null, Mdl, Doc, undefined, null, Mdl>;
+export 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 declare const convertAggregateMatch: (query: any) => {
+    [k: string]: any;
+};

package/src/schema.js

@@ -0,0 +1,343 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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,
+  convertAggregateMatch: () => convertAggregateMatch,
+  getDefaultSchemaOptions: () => getDefaultSchemaOptions,
+  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_signal = require("@akanjs/signal");
+var import_mongoose = require("mongoose");
+var import__ = require(".");
+class ScalarSchemaStorage {
+}
+class SchemaStorage {
+}
+const getDefaultSchemaOptions = () => ({
+  toJSON: { getters: false, virtuals: true },
+  toObject: { getters: false, virtuals: true },
+  _id: true,
+  id: true,
+  timestamps: true,
+  methods: {
+    refresh: async function() {
+      Object.assign(this, await this.constructor.findById(this._id));
+      return this;
+    }
+  },
+  statics: {
+    pickOne: async function(query, projection) {
+      const doc = await this.findOne(query, projection);
+      if (!doc)
+        throw new Error("No Document");
+      return doc;
+    },
+    pickById: async function(docId, projection) {
+      if (!docId)
+        throw new Error("No Document ID");
+      const doc = await this.findById(docId, projection);
+      if (!doc)
+        throw new Error("No Document");
+      return doc;
+    },
+    sample: async function(query, size = 1, aggregations = []) {
+      const objs = await this.aggregate([
+        { $match: convertAggregateMatch(query) },
+        { $sample: { size } },
+        ...aggregations
+      ]);
+      return objs.map((obj) => new this(obj));
+    },
+    sampleOne: async function(query, aggregations = []) {
+      const obj = await this.aggregate([
+        { $match: convertAggregateMatch(query) },
+        { $sample: { size: 1 } },
+        ...aggregations
+      ]);
+      return obj.length ? new this(obj[0]) : null;
+    },
+    addSummary: async function(prefix = "total", num = 1) {
+      const update = Array.isArray(prefix) ? {
+        $inc: {
+          ...prefix.reduce((acc, cur) => ({ ...acc, [`${cur}${this.modelName}`]: num }), {})
+        }
+      } : { $inc: { [`${prefix}${this.modelName}`]: num } };
+      await this.db.collection("summaries").updateOne({ status: "active" }, update);
+    },
+    moveSummary: async function(prev, next, num = 1) {
+      await this.db.collection("summaries").updateOne(
+        { status: "active" },
+        {
+          $inc: {
+            [`${prev}${this.modelName}`]: -num,
+            [`${next}${this.modelName}`]: num
+          }
+        }
+      );
+    },
+    subSummary: async function(prefix = "total", num = 1) {
+      const update = Array.isArray(prefix) ? {
+        $inc: {
+          ...prefix.reduce((acc, cur) => ({ ...acc, [`${cur}${this.modelName}`]: -num }), {})
+        }
+      } : { $inc: { [`${prefix}${this.modelName}`]: -num } };
+      await this.db.collection("summaries").updateOne({ status: "active" }, update);
+    }
+  }
+});
+const scalarMongoTypeMap = /* @__PURE__ */ new Map([
+  [import_base.ID, import__.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 = (schemaProps, fieldMeta) => {
+  if (["id", "createdAt", "updatedAt"].includes(fieldMeta.key) || fieldMeta.fieldType === "resolve")
+    return;
+  const type = fieldMeta.isClass ? fieldMeta.isScalar ? createSchema(fieldMeta.modelRef) : import__.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;
+};
+const createSchema = (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;
+};
+const schemaOf = (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: (date) => date ? (0, import_base.dayjs)(date) : date,
+      set: (day) => day ? (0, import_base.dayjs)(day).toDate() : day
+    },
+    updatedAt: {
+      type: Date,
+      get: (date) => date ? (0, import_base.dayjs)(date) : date,
+      set: (day) => day ? (0, import_base.dayjs)(day).toDate() : day
+    }
+  };
+  fieldMetas.forEach((fieldMeta) => {
+    applyMongoProp(schemaProps, fieldMeta);
+  });
+  const schema = new import_mongoose.Schema(schemaProps, 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;
+};
+const addSchema = (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: (date) => date ? (0, import_base.dayjs)(date) : date,
+      set: (day) => day ? (0, import_base.dayjs)(day).toDate() : day
+    },
+    updatedAt: {
+      type: Date,
+      get: (date) => date ? (0, import_base.dayjs)(date) : date,
+      set: (day) => day ? (0, import_base.dayjs)(day).toDate() : day
+    }
+  };
+  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, 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;
+};
+const convertOperatorValue = (value) => {
+  if (Array.isArray(value))
+    return value.map((v) => convertOperatorValue(v));
+  else if (!value)
+    return value;
+  else if ((0, import_mongoose.isValidObjectId)(value))
+    return new import_mongoose.Types.ObjectId(value);
+  else if ((0, import_common.isValidDate)(value))
+    return (0, import_base.dayjs)(value).toDate();
+  else if (value.constructor !== Object)
+    return value;
+  else if (typeof value !== "object")
+    return value;
+  else
+    return Object.fromEntries(
+      Object.entries(value).map(([key, value2]) => [key, convertOperatorValue(value2)])
+    );
+};
+const convertAggregateMatch = (query) => {
+  return Object.fromEntries(
+    Object.entries(query).map(([key, value]) => {
+      return [key, convertOperatorValue(value)];
+    })
+  );
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addSchema,
+  convertAggregateMatch,
+  getDefaultSchemaOptions,
+  schemaOf
+});

package/src/searchDaemon.d.ts

@@ -0,0 +1,7 @@
+import type { Type } from "@akanjs/base";
+import { type TextDoc } from "@akanjs/constant";
+export declare const makeTextFilter: (modelRef: Type) => (data: Record<string, any>, assignObj?: {
+    [key: string]: string;
+}) => TextDoc;
+export declare class SearchDaemonModule {
+}