@akanjs/server 0.0.53 → 0.0.55

package/src/processor.mjs

@@ -0,0 +1,73 @@
+import { lowerlize } from "@akanjs/common";
+import { isServiceEnabled } from "@akanjs/service";
+import {
+  deserializeArg,
+  getArgMetas,
+  getGqlMetas,
+  getSigMeta
+} from "@akanjs/signal";
+import { Process, Processor } from "@nestjs/bull";
+import { Inject } from "@nestjs/common";
+const convertProcessFunction = (gqlMeta, argMetas, internalArgMetas, fn) => {
+  return async function(job, done) {
+    const args = [];
+    argMetas.forEach((argMeta) => {
+      if (argMeta.type === "Msg")
+        args[argMeta.idx] = 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);
+  };
+};
+const processorOf = (sigRef, allSrvs) => {
+  const sigMeta = getSigMeta(sigRef);
+  const serverMode = process.env.SERVER_MODE ?? "federation";
+  const gqlMetas = getGqlMetas(sigRef).filter((gqlMeta) => gqlMeta.type === "Process").filter(
+    (gqlMeta) => gqlMeta.signalOption.serverType === "all" || serverMode === "all" || gqlMeta.signalOption.serverType === serverMode
+  );
+  class QueueProcessor {
+  }
+  Object.keys(allSrvs).forEach((srv) => {
+    if (!isServiceEnabled(allSrvs[srv]))
+      return;
+    Inject(allSrvs[srv])(QueueProcessor.prototype, lowerlize(srv));
+  });
+  for (const gqlMeta of gqlMetas) {
+    const [argMetas, internalArgMetas] = 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);
+    Process(gqlMeta.key)(QueueProcessor.prototype, gqlMeta.key, descriptor);
+  }
+  Processor(sigMeta.refName)(QueueProcessor);
+  return QueueProcessor;
+};
+const queueOf = (sigRef, queue) => {
+  const sigMeta = getSigMeta(sigRef);
+  const gqlMetas = 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;
+};
+export {
+  processorOf,
+  queueOf
+};

package/src/resolver.mjs

@@ -0,0 +1,118 @@
+import { arraiedModel, Float, getNonArrayModel, ID, Int, JSON, Upload } from "@akanjs/base";
+import { capitalize, lowerlize } from "@akanjs/common";
+import { getClassMeta, getFieldMetas } from "@akanjs/constant";
+import { Access, Account, guards, Me, Req, Res, Self, UserIp } from "@akanjs/nest";
+import { isServiceEnabled } from "@akanjs/service";
+import {
+  copySignal,
+  getArgMetas,
+  getGqlMetas,
+  getResolveFieldMetas,
+  getSigMeta
+} from "@akanjs/signal";
+import { Inject, UseGuards } from "@nestjs/common";
+import * as Nest from "@nestjs/graphql";
+import GraphQLJson from "graphql-type-json";
+import { GraphQLUpload } from "graphql-upload";
+import { generateGql, generateGqlInput } from "./gql";
+const scalarNestReturnMap = /* @__PURE__ */ new Map([
+  [Upload, GraphQLUpload],
+  [ID, Nest.ID],
+  [Int, Nest.Int],
+  [Float, Nest.Float],
+  [JSON, GraphQLJson],
+  [Boolean, Boolean],
+  [Date, Date],
+  [String, String],
+  [Map, GraphQLJson]
+]);
+const getNestReturn = (returns, type = "object") => {
+  const [model, arrDepth] = getNonArrayModel(returns());
+  const modelRef = scalarNestReturnMap.get(model) ?? (type === "object" ? generateGql(model) : generateGqlInput(model));
+  return () => arraiedModel(modelRef, arrDepth);
+};
+const internalArgMap = {
+  Parent: Nest.Parent,
+  Account,
+  UserIp,
+  Access,
+  Self,
+  Me,
+  Req,
+  Res
+};
+const resolverOf = (sigRef, allSrvs) => {
+  const Rsv = copySignal(sigRef);
+  const sigMeta = getSigMeta(Rsv);
+  const gqlMetas = getGqlMetas(Rsv);
+  Object.keys(allSrvs).forEach((srv) => {
+    if (!isServiceEnabled(allSrvs[srv]))
+      return;
+    Inject(allSrvs[srv])(Rsv.prototype, 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] = 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);
+    }
+    UseGuards(...gqlMeta.guards.map((guard) => 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 = getResolveFieldMetas(Rsv);
+  if (sigMeta.returns) {
+    const modelRef = sigMeta.returns();
+    const fieldMetas = getFieldMetas(modelRef);
+    fieldMetas.filter((fieldMeta) => fieldMeta.isClass && !fieldMeta.isScalar).forEach((fieldMeta) => {
+      const classMeta = getClassMeta(fieldMeta.modelRef);
+      const modelName = lowerlize(classMeta.type === "light" ? classMeta.refName.slice(5) : classMeta.refName);
+      const className = 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(() => arraiedModel(fieldMeta.modelRef, fieldMeta.arrDepth)))(
+        Rsv.prototype,
+        fieldMeta.key,
+        Object.getOwnPropertyDescriptor(Rsv.prototype, fieldMeta.key) ?? {}
+      );
+    });
+  }
+  for (const resolveFieldMeta of resolveFieldMetas) {
+    const [, internalArgMetas] = 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;
+};
+export {
+  resolverOf
+};

package/src/schema.mjs

@@ -0,0 +1,219 @@
+import { arraiedModel, dayjs, Enum, Float, ID, Int, JSON } from "@akanjs/base";
+import { isDayjs } from "@akanjs/common";
+import { getClassMeta, getFieldMetas, getFullModelRef, getInputModelRef } from "@akanjs/constant";
+import { getDefaultSchemaOptions, ObjectId } from "@akanjs/document";
+import { makeDefault } from "@akanjs/signal";
+import { Schema, Types } from "mongoose";
+import { applyNestField } from ".";
+class ScalarSchemaStorage {
+}
+class SchemaStorage {
+}
+const scalarMongoTypeMap = /* @__PURE__ */ new Map([
+  [ID, ObjectId],
+  [Int, Number],
+  [Float, Number],
+  [JSON, 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) : 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 = 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 ? dayjs() : value, this) ?? true;
+      };
+    }
+    prop = { type: arraiedModel(prop, fieldMeta.optArrDepth), default: [], required: true };
+    if (fieldMeta.modelRef.prototype === Date.prototype) {
+      prop.get = (dates) => dates.map((date) => dayjs(date));
+      prop.set = (days) => days.map((day) => day.toDate());
+    }
+    if (fieldMeta.isClass && !fieldMeta.isScalar || fieldMeta.modelRef.prototype === ID.prototype) {
+      prop.get = (ids) => ids.map((id) => id.toString());
+      prop.set = (ids) => ids.map((id) => new Types.ObjectId(id));
+    }
+  } else {
+    prop.type = 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 isDayjs(def) ? def.toDate() : def;
+        };
+      else
+        prop.default = isDayjs(fieldMeta.default) ? fieldMeta.default.toDate() : fieldMeta.default instanceof Enum ? [...fieldMeta.default.values] : fieldMeta.default;
+    }
+    if (typeof fieldMeta.immutable !== "undefined")
+      prop.immutable = fieldMeta.immutable;
+    if (fieldMeta.isClass && !fieldMeta.refPath)
+      prop.ref = 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 ? dayjs(date) : void 0;
+      prop.set = (day) => day ? dayjs(day).toDate() : void 0;
+    }
+    if (fieldMeta.isClass && !fieldMeta.isScalar || fieldMeta.modelRef.prototype === ID.prototype) {
+      prop.get = (id) => id ? id.toString() : void 0;
+      prop.set = (id) => id ? new Types.ObjectId(id) : void 0;
+    }
+    if (fieldMeta.isClass && fieldMeta.isScalar && fieldMeta.default === null && !fieldMeta.nullable) {
+      prop.default = makeDefault(fieldMeta.modelRef);
+    }
+    if (fieldMeta.validate) {
+      prop.validate = function(value) {
+        return fieldMeta.validate?.(fieldMeta.name === "Date" && !!value ? dayjs() : value, this) ?? true;
+      };
+    }
+  }
+  schemaProps[fieldMeta.key] = prop;
+};
+const createSchema = (modelRef) => {
+  const classMeta = getClassMeta(modelRef);
+  const schemaMeta = Reflect.getMetadata(classMeta.refName, ScalarSchemaStorage.prototype);
+  if (schemaMeta)
+    return schemaMeta;
+  const fieldMetas = getFieldMetas(modelRef);
+  const schemaProps = {};
+  fieldMetas.forEach((fieldMeta) => {
+    applyMongoProp(schemaProps, fieldMeta);
+  });
+  const schema = new Schema(schemaProps);
+  Reflect.defineMetadata(classMeta.refName, schema, ScalarSchemaStorage.prototype);
+  return schema;
+};
+const schemaOf = (modelRef, docRef, middleware) => {
+  const classMeta = getClassMeta(docRef);
+  const schemaMeta = Reflect.getMetadata(classMeta.refName, SchemaStorage.prototype);
+  if (schemaMeta)
+    return schemaMeta;
+  const fieldMetas = getFieldMetas(docRef);
+  const schemaProps = {
+    createdAt: {
+      type: Date,
+      get: (date) => date ? dayjs(date) : date,
+      set: (day) => day ? dayjs(day).toDate() : day
+    },
+    updatedAt: {
+      type: Date,
+      get: (date) => date ? dayjs(date) : date,
+      set: (day) => day ? dayjs(day).toDate() : day
+    }
+  };
+  fieldMetas.forEach((fieldMeta) => {
+    applyMongoProp(schemaProps, fieldMeta);
+  });
+  const schema = new 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 = getClassMeta(docRef);
+  const originInputClassMeta = getClassMeta(inputRef);
+  const originDoc = getFullModelRef(originDocClassMeta.refName);
+  const originInput = getInputModelRef(originInputClassMeta.refName);
+  const classMeta = getClassMeta(docRef);
+  const modelSchema = Reflect.getMetadata(classMeta.refName, SchemaStorage.prototype);
+  if (!modelSchema)
+    throw new Error(`Schema of ${classMeta.refName} not found`);
+  const fieldMetas = getFieldMetas(docRef);
+  const schemaProps = {
+    createdAt: {
+      type: Date,
+      get: (date) => date ? dayjs(date) : date,
+      set: (day) => day ? dayjs(day).toDate() : day
+    },
+    updatedAt: {
+      type: Date,
+      get: (date) => date ? dayjs(date) : date,
+      set: (day) => day ? dayjs(day).toDate() : day
+    }
+  };
+  fieldMetas.forEach((fieldMeta) => {
+    applyMongoProp(schemaProps, fieldMeta);
+    applyNestField(originDoc, fieldMeta);
+  });
+  const inputFieldMetas = getFieldMetas(inputRef);
+  inputFieldMetas.forEach((fieldMeta) => {
+    applyNestField(originInput, fieldMeta, "input");
+  });
+  const schema = new 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;
+};
+export {
+  addSchema,
+  schemaOf
+};

package/src/searchDaemon.mjs

@@ -0,0 +1,212 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
+var __decorateParam = (index, decorator) => (target, key) => decorator(target, key, index);
+import { Logger, lowerlize } from "@akanjs/common";
+import {
+  getCnstMeta,
+  getFieldMetaMap,
+  getFieldMetas,
+  getFilterSortMap,
+  getFullModelRef
+} from "@akanjs/constant";
+import { getAllDatabaseModelNames } from "@akanjs/document";
+import { Global, Inject, Injectable, Module } from "@nestjs/common";
+import { InjectConnection } from "@nestjs/mongoose";
+const hasTextField = (modelRef) => {
+  const fieldMetas = getFieldMetas(modelRef);
+  return fieldMetas.some(
+    (fieldMeta) => !!fieldMeta.text || fieldMeta.isScalar && fieldMeta.isClass && fieldMeta.select && hasTextField(fieldMeta.modelRef)
+  );
+};
+const getTextFieldKeys = (modelRef) => {
+  const allSearchFields = [];
+  const allFilterFields = [];
+  const fieldMetaMap = getFieldMetaMap(modelRef);
+  const fieldMetas = [...fieldMetaMap.values()];
+  const stringTextFields = fieldMetas.filter((fieldMeta) => !!fieldMeta.text).map((fieldMeta) => {
+    if (fieldMeta.text === "filter")
+      allFilterFields.push(fieldMeta.key);
+    else if (fieldMeta.text === "search")
+      allSearchFields.push(fieldMeta.key);
+    return fieldMeta.key;
+  });
+  const scalarTextFields = fieldMetas.filter(
+    (fieldMeta) => fieldMeta.isScalar && fieldMeta.isClass && fieldMeta.select && hasTextField(fieldMeta.modelRef)
+  ).map((fieldMeta) => fieldMeta.key);
+  const deepFields = scalarTextFields.map((key) => {
+    const fieldMeta = fieldMetaMap.get(key);
+    if (!fieldMeta)
+      throw new Error(`No fieldMeta for ${key}`);
+    const { stringTextFields: stringTextFields2, allTextFields, allSearchFields: allSearchFields2, allFilterFields: allFilterFields2 } = getTextFieldKeys(
+      fieldMeta.modelRef
+    );
+    allFilterFields2.push(...allSearchFields2.map((field) => `${key}.${field}`));
+    allSearchFields2.push(...stringTextFields2.map((field) => `${key}.${field}`));
+    return [
+      ...stringTextFields2.map((field) => `${key}.${field}`),
+      ...allTextFields.map((field) => `${key}.${field}`)
+    ];
+  }).flat();
+  return {
+    stringTextFields,
+    scalarTextFields,
+    allTextFields: [...stringTextFields, ...deepFields],
+    allSearchFields,
+    allFilterFields
+  };
+};
+const makeTextFilter = (modelRef) => {
+  const fieldMetaMap = getFieldMetaMap(modelRef);
+  const { stringTextFields, scalarTextFields } = getTextFieldKeys(modelRef);
+  const filterData = (data, assignObj = {}) => {
+    if (Array.isArray(data))
+      return data.map((d) => filterData(d));
+    return Object.assign(
+      Object.fromEntries([
+        ...stringTextFields.map((key) => [key, data[key]]),
+        ...scalarTextFields.map((key) => {
+          const fieldMeta = fieldMetaMap.get(key);
+          if (!fieldMeta)
+            throw new Error(`No fieldMeta for ${key}`);
+          const filterFunc = makeTextFilter(fieldMeta.modelRef);
+          return [key, filterFunc(data[key])];
+        })
+      ]),
+      assignObj
+    );
+  };
+  return filterData;
+};
+const getSortableAttributes = (refName) => {
+  const cnst = getCnstMeta(refName);
+  const sortMap = getFilterSortMap(cnst.Filter);
+  const sortFields = Object.values(sortMap).filter((val) => typeof val === "object").map((sort) => Object.keys(sort)).flat();
+  return [...new Set(sortFields)];
+};
+let SearchDaemon = class {
+  constructor(connection, meili) {
+    this.connection = connection;
+    this.meili = meili;
+  }
+  logger = new Logger("SearchDaemon");
+  async onModuleInit() {
+    const databaseModelNames = getAllDatabaseModelNames();
+    const indexes = (await this.meili.getIndexes({ limit: 1e3 })).results;
+    const indexMap = new Map(indexes.map((index) => [index.uid, index]));
+    const indexCreationNames = [];
+    const indexUpdateNames = [];
+    for (const modelName of databaseModelNames) {
+      const indexName = lowerlize(modelName);
+      const modelRef = getFullModelRef(modelName);
+      if (!hasTextField(modelRef))
+        continue;
+      const index = indexMap.get(indexName);
+      if (!index)
+        indexCreationNames.push(indexName);
+      else if (index.primaryKey !== "id")
+        indexUpdateNames.push(indexName);
+    }
+    for (const indexName of indexCreationNames)
+      await this.meili.createIndex(indexName, { primaryKey: "id" });
+    for (const indexName of indexUpdateNames)
+      await this.meili.updateIndex(indexName, { primaryKey: "id" });
+    for (const modelName of databaseModelNames) {
+      const indexName = lowerlize(modelName);
+      const model = this.connection.models[modelName];
+      const modelRef = getFullModelRef(modelName);
+      if (!hasTextField(modelRef))
+        continue;
+      const searchIndex = this.meili.index(indexName);
+      const { stringTextFields, scalarTextFields, allSearchFields, allFilterFields } = getTextFieldKeys(modelRef);
+      const settings = await searchIndex.getSettings();
+      const allSearchFieldSet = new Set(allSearchFields);
+      const allFilterFieldSet = new Set(allFilterFields);
+      const searchFieldSet = new Set(settings.searchableAttributes);
+      const filterFieldSet = new Set(settings.filterableAttributes);
+      const needUpdateSetting = !allSearchFields.every((field) => searchFieldSet.has(field)) || !allFilterFields.every((field) => filterFieldSet.has(field)) || !settings.searchableAttributes?.every((field) => allSearchFieldSet.has(field)) || !settings.filterableAttributes?.every((field) => allFilterFieldSet.has(field));
+      if (needUpdateSetting) {
+        this.logger.info(`update index settings (${modelName})`);
+        await searchIndex.updateSettings({
+          searchableAttributes: allSearchFields,
+          filterableAttributes: allFilterFields,
+          sortableAttributes: getSortableAttributes(indexName)
+        });
+      }
+      const stringTextFieldSet = new Set(stringTextFields);
+      const scalarTextFieldSet = new Set(scalarTextFields);
+      const filterText = makeTextFilter(modelRef);
+      model.watch().on("change", async (data) => {
+        try {
+          const id = data.documentKey._id.toString();
+          if (data.operationType === "delete") {
+            this.logger.trace(`delete text doc (${modelName}): ${id}`);
+            return await searchIndex.deleteDocument(id);
+          } else if (data.operationType === "insert") {
+            this.logger.trace(`insert text doc (${modelName}): ${data.documentKey._id}`);
+            if (!data.fullDocument)
+              throw new Error("No fullDocument");
+            const textFilteredData = filterText(data.fullDocument);
+            return await searchIndex.addDocuments([textFilteredData]);
+          } else if (data.operationType === "update") {
+            const updatedFields = data.updateDescription?.updatedFields ?? {};
+            const isRemoved = !!updatedFields.removedAt;
+            if (isRemoved) {
+              this.logger.trace(`remove text doc (${modelName}): ${id}`);
+              return await searchIndex.deleteDocument(id);
+            }
+            this.logger.trace(`update text doc (${modelName}): ${data.documentKey._id}`);
+            const updatedFieldKeys = Object.keys(updatedFields);
+            const removedFieldKeys = data.updateDescription?.removedFields ?? [];
+            const isScalarTextFieldUpdated = [...updatedFieldKeys, ...removedFieldKeys].map((key) => key.split(".")[0]).some((key) => scalarTextFieldSet.has(key));
+            if (isScalarTextFieldUpdated) {
+              const doc = await model.findById(data.documentKey._id);
+              if (!doc)
+                this.logger.error(`No doc for ${data.documentKey._id}`);
+              const textFilteredData = filterText(doc, { id });
+              return await searchIndex.updateDocuments([textFilteredData]);
+            } else {
+              const updateKeys = updatedFieldKeys.filter((key) => stringTextFieldSet.has(key));
+              const removeKeys = removedFieldKeys.filter((key) => stringTextFieldSet.has(key));
+              if (!updateKeys.length && !removeKeys.length)
+                return;
+              const textFilteredData = Object.fromEntries([
+                ["id", id],
+                ...updateKeys.map((key) => [key, updatedFields[key]]),
+                ...removeKeys.map((key) => [key, null])
+              ]);
+              return await searchIndex.updateDocuments([textFilteredData]);
+            }
+          }
+        } catch (e) {
+          this.logger.error(e);
+        }
+      });
+    }
+  }
+};
+SearchDaemon = __decorateClass([
+  Injectable(),
+  __decorateParam(0, InjectConnection()),
+  __decorateParam(1, Inject("MEILI_CLIENT"))
+], SearchDaemon);
+let SearchDaemonModule = class {
+};
+SearchDaemonModule = __decorateClass([
+  Global(),
+  Module({
+    providers: [SearchDaemon]
+  })
+], SearchDaemonModule);
+export {
+  SearchDaemonModule,
+  makeTextFilter
+};