@akanjs/server 0.0.39 → 0.0.40

package/src/searchDaemon.js

@@ -0,0 +1,282 @@
+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 searchDaemon_exports = {};
+__export(searchDaemon_exports, {
+  SearchDaemonModule: () => SearchDaemonModule,
+  makeTextFilter: () => makeTextFilter
+});
+module.exports = __toCommonJS(searchDaemon_exports);
+var import_common = require("@akanjs/common");
+var import_constant = require("@akanjs/constant");
+var import_document = require("@akanjs/document");
+var import_common2 = require("@nestjs/common");
+var import_mongoose = require("@nestjs/mongoose");
+var import_meilisearch = __toESM(require("meilisearch"));
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+function _ts_metadata(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata, "_ts_metadata");
+function _ts_param(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param, "_ts_param");
+const hasTextField = /* @__PURE__ */ __name((modelRef) => {
+  const fieldMetas = (0, import_constant.getFieldMetas)(modelRef);
+  return fieldMetas.some((fieldMeta) => !!fieldMeta.text || fieldMeta.isScalar && fieldMeta.isClass && fieldMeta.select && hasTextField(fieldMeta.modelRef));
+}, "hasTextField");
+const getTextFieldKeys = /* @__PURE__ */ __name((modelRef) => {
+  const allSearchFields = [];
+  const allFilterFields = [];
+  const fieldMetaMap = (0, import_constant.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
+  };
+}, "getTextFieldKeys");
+const makeTextFilter = /* @__PURE__ */ __name((modelRef) => {
+  const fieldMetaMap = (0, import_constant.getFieldMetaMap)(modelRef);
+  const { stringTextFields, scalarTextFields } = getTextFieldKeys(modelRef);
+  const filterData = /* @__PURE__ */ __name((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);
+  }, "filterData");
+  return filterData;
+}, "makeTextFilter");
+const getSortableAttributes = /* @__PURE__ */ __name((refName) => {
+  const cnst = (0, import_constant.getCnstMeta)(refName);
+  const sortMap = (0, import_constant.getFilterSortMap)(cnst.Filter);
+  const sortFields = Object.values(sortMap).filter((val) => typeof val === "object").map((sort) => Object.keys(sort)).flat();
+  return [
+    ...new Set(sortFields)
+  ];
+}, "getSortableAttributes");
+let SearchDaemon = class SearchDaemon2 {
+  static {
+    __name(this, "SearchDaemon");
+  }
+  connection;
+  meili;
+  logger;
+  constructor(connection, meili) {
+    this.connection = connection;
+    this.meili = meili;
+    this.logger = new import_common.Logger("SearchDaemon");
+  }
+  async onModuleInit() {
+    const databaseModelNames = (0, import_document.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 = (0, import_common.lowerlize)(modelName);
+      const modelRef = (0, import_constant.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 = (0, import_common.lowerlize)(modelName);
+      const model = this.connection.models[modelName];
+      const modelRef = (0, import_constant.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 = _ts_decorate([
+  (0, import_common2.Injectable)(),
+  _ts_param(0, (0, import_mongoose.InjectConnection)()),
+  _ts_param(1, (0, import_common2.Inject)("MEILI_CLIENT")),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof Connection === "undefined" ? Object : Connection,
+    typeof import_meilisearch.default === "undefined" ? Object : import_meilisearch.default
+  ])
+], SearchDaemon);
+class SearchDaemonModule {
+  static {
+    __name(this, "SearchDaemonModule");
+  }
+}
+SearchDaemonModule = _ts_decorate([
+  (0, import_common2.Global)(),
+  (0, import_common2.Module)({
+    providers: [
+      SearchDaemon
+    ]
+  })
+], SearchDaemonModule);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SearchDaemonModule,
+  makeTextFilter
+});

package/src/types.d.ts

@@ -0,0 +1,18 @@
+import { ReadStream } from 'fs';
+import { Readable } from 'stream';
+export { DynamicModule as Module } from '@nestjs/common';
+
+interface FileStream {
+    filename: string;
+    mimetype: string;
+    encoding: string;
+    createReadStream(): ReadStream | Readable;
+}
+interface LocalFile {
+    filename: string;
+    mimetype: string;
+    encoding: string;
+    localPath: string;
+}
+
+export type { FileStream, LocalFile };

package/src/types.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/src/websocket.d.ts

@@ -0,0 +1,20 @@
+import { T as Type } from '../types-H2HI4YUe.js';
+import { Server } from 'socket.io';
+
+interface Response<T> {
+    data: T;
+}
+declare const websocketOf: (sigRef: Type, allSrvs: {
+    [key: string]: Type;
+}) => {
+    new (): {
+        __sigRef__: Type;
+    };
+};
+declare const websocketServerOf: (sigRef: Type) => {
+    new (): {
+        server: Server;
+    };
+};
+
+export { type Response, websocketOf, websocketServerOf };

package/src/websocket.js

@@ -0,0 +1,192 @@
+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 websocket_exports = {};
+__export(websocket_exports, {
+  websocketOf: () => websocketOf,
+  websocketServerOf: () => websocketServerOf
+});
+module.exports = __toCommonJS(websocket_exports);
+var import_common = require("@akanjs/common");
+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 import_websockets = require("@nestjs/websockets");
+var import_operators = require("rxjs/operators");
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+function _ts_metadata(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata, "_ts_metadata");
+const internalArgMap = {
+  Account: import_nest.Account,
+  UserIp: import_nest.UserIp,
+  Access: import_nest.Access,
+  Self: import_nest.Self,
+  Me: import_nest.Me,
+  Ws: import_nest.Ws
+};
+let TransformInterceptor = class TransformInterceptor2 {
+  static {
+    __name(this, "TransformInterceptor");
+  }
+  intercept(context, next) {
+    const [, gqlKey] = [
+      context.getArgByIndex(1),
+      context.getArgByIndex(3)
+    ];
+    return next.handle().pipe((0, import_operators.map)((data) => ({
+      event: gqlKey,
+      data
+    })));
+  }
+};
+TransformInterceptor = _ts_decorate([
+  (0, import_common2.Injectable)()
+], TransformInterceptor);
+const makeRoomId = /* @__PURE__ */ __name((gqlKey, argValues) => `${gqlKey}-${argValues.join("-")}`, "makeRoomId");
+const getPubsubInterceptor = /* @__PURE__ */ __name((argMetas) => {
+  let PubsubInterceptor = class PubsubInterceptor {
+    static {
+      __name(this, "PubsubInterceptor");
+    }
+    async intercept(context, next) {
+      const [socket, { __subscribe__, ...body }, gqlKey] = [
+        context.getArgByIndex(0),
+        context.getArgByIndex(1),
+        context.getArgByIndex(3)
+      ];
+      const roomId = makeRoomId(gqlKey, argMetas.map((argMeta) => body[argMeta.name]));
+      if (__subscribe__) await socket.join(roomId);
+      else await socket.leave(roomId);
+      return next.handle().pipe((0, import_operators.map)(() => ({
+        event: gqlKey,
+        data: {
+          roomId,
+          __subscribe__
+        }
+      })));
+    }
+  };
+  PubsubInterceptor = _ts_decorate([
+    (0, import_common2.Injectable)()
+  ], PubsubInterceptor);
+  return PubsubInterceptor;
+}, "getPubsubInterceptor");
+const websocketOf = /* @__PURE__ */ __name((sigRef, allSrvs) => {
+  const sigMeta = (0, import_signal.getSigMeta)(sigRef);
+  let WsGateway = class WsGateway {
+    static {
+      __name(this, "WsGateway");
+    }
+    __sigRef__ = sigRef;
+  };
+  Object.keys(allSrvs).forEach((srv) => {
+    if (!(0, import_service.isServiceEnabled)(allSrvs[srv])) return;
+    (0, import_common2.Inject)(allSrvs[srv])(WsGateway.prototype, (0, import_common.lowerlize)(srv));
+  });
+  const messageGqlMetas = (0, import_signal.getGqlMetas)(sigRef).filter((gqlMeta) => gqlMeta.type === "Message");
+  for (const gqlMeta of messageGqlMetas) {
+    const descriptor = {
+      ...Object.getOwnPropertyDescriptor(sigRef.prototype, gqlMeta.key) ?? {}
+    };
+    Object.defineProperty(WsGateway.prototype, gqlMeta.key, descriptor);
+    const [argMetas, internalArgMetas] = (0, import_signal.getArgMetas)(sigRef, gqlMeta.key);
+    argMetas.forEach((argMeta) => {
+      if (argMeta.type !== "Msg") throw new Error(`Argument of Message should be Msg ${sigMeta.refName}-${gqlMeta.key}-${argMeta.name}`);
+      (0, import_websockets.MessageBody)(argMeta.name, ...(0, import_nest.getBodyPipes)(argMeta))(WsGateway.prototype, gqlMeta.key, argMeta.idx);
+    });
+    internalArgMetas.forEach((internalArgMeta) => {
+      const internalDecorator = internalArgMap[internalArgMeta.type];
+      internalDecorator(internalArgMeta.option ?? {})(WsGateway.prototype, gqlMeta.key, internalArgMeta.idx);
+    });
+    (0, import_common2.UseInterceptors)(TransformInterceptor)(WsGateway.prototype, gqlMeta.key, gqlMeta.descriptor);
+    (0, import_websockets.SubscribeMessage)(gqlMeta.key)(WsGateway.prototype, gqlMeta.key, descriptor);
+  }
+  const pubsubGqlMetas = (0, import_signal.getGqlMetas)(sigRef).filter((gqlMeta) => gqlMeta.type === "Pubsub");
+  for (const gqlMeta of pubsubGqlMetas) {
+    const descriptor = {
+      ...Object.getOwnPropertyDescriptor(sigRef.prototype, gqlMeta.key) ?? {}
+    };
+    Object.defineProperty(WsGateway.prototype, gqlMeta.key, descriptor);
+    const [argMetas, internalArgMetas] = (0, import_signal.getArgMetas)(sigRef, gqlMeta.key);
+    argMetas.forEach((argMeta) => {
+      if (argMeta.type !== "Room") throw new Error(`Argument of Message should be Room ${sigMeta.refName}-${gqlMeta.key}-${argMeta.name}`);
+      (0, import_websockets.MessageBody)(argMeta.name, ...(0, import_nest.getBodyPipes)(argMeta))(WsGateway.prototype, gqlMeta.key, argMeta.idx);
+    });
+    internalArgMetas.forEach((internalArgMeta) => {
+      const internalDecorator = internalArgMap[internalArgMeta.type];
+      internalDecorator(internalArgMeta.option ?? {})(WsGateway.prototype, gqlMeta.key, internalArgMeta.idx);
+    });
+    (0, import_common2.UseInterceptors)(getPubsubInterceptor(argMetas))(WsGateway.prototype, gqlMeta.key, gqlMeta.descriptor);
+    (0, import_websockets.SubscribeMessage)(gqlMeta.key)(WsGateway.prototype, gqlMeta.key, descriptor);
+  }
+  (0, import_websockets.WebSocketGateway)({
+    cors: {
+      origin: "*"
+    },
+    transports: [
+      "websocket"
+    ]
+  })(WsGateway);
+  return WsGateway;
+}, "websocketOf");
+const websocketServerOf = /* @__PURE__ */ __name((sigRef) => {
+  const pubsubGqlMetas = (0, import_signal.getGqlMetas)(sigRef).filter((gqlMeta) => gqlMeta.type === "Pubsub");
+  let Websocket = class Websocket {
+    static {
+      __name(this, "Websocket");
+    }
+    server;
+  };
+  _ts_decorate([
+    (0, import_websockets.WebSocketServer)(),
+    _ts_metadata("design:type", typeof Server === "undefined" ? Object : Server)
+  ], Websocket.prototype, "server", void 0);
+  Websocket = _ts_decorate([
+    (0, import_common2.Injectable)(),
+    (0, import_websockets.WebSocketGateway)({
+      cors: {
+        origin: "*"
+      },
+      transports: [
+        "websocket"
+      ]
+    })
+  ], Websocket);
+  for (const gqlMeta of pubsubGqlMetas) {
+    const [argMetas] = (0, import_signal.getArgMetas)(sigRef, gqlMeta.key);
+    Websocket.prototype[gqlMeta.key] = function(...args) {
+      const roomId = makeRoomId(gqlMeta.key, argMetas.map((argMeta) => args[argMeta.idx]));
+      this.server.to(roomId).emit(roomId, args.at(-1));
+    };
+  }
+  return Websocket;
+}, "websocketServerOf");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  websocketOf,
+  websocketServerOf
+});

package/types-CUkhtrLV.d.ts

@@ -0,0 +1,53 @@
+import { Dayjs } from 'dayjs';
+import { ReadStream } from 'fs';
+import { Readable } from 'stream';
+
+declare class BaseObject {
+    id: string;
+    createdAt: Dayjs;
+    updatedAt: Dayjs;
+    removedAt: Dayjs | null;
+}
+declare class Int {
+    __Scalar__: "int";
+}
+declare class Upload {
+    __Scalar__: "upload";
+    filename: string;
+    mimetype: string;
+    encoding: string;
+    createReadStream: () => ReadStream | Readable;
+}
+declare class Float {
+    __Scalar__: "float";
+}
+declare class ID {
+    __Scalar__: "id";
+}
+declare class JSON {
+    __Scalar__: "json";
+}
+declare const gqlScalars: readonly [StringConstructor, BooleanConstructor, DateConstructor, typeof ID, typeof Int, typeof Float, typeof Upload, typeof JSON, MapConstructor];
+type GqlScalar = (typeof gqlScalars)[number];
+
+type Optional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>;
+type OptionalKeys<T> = T extends {
+    [key: string]: any;
+} ? {
+    [K in keyof T]-?: null extends T[K] ? K : never;
+}[keyof T] : never;
+type ObjectToId<O, D = Dayjs> = O extends BaseObject ? string : O extends BaseObject[] ? string[] : O extends Dayjs ? D : O extends {
+    [key: string]: any;
+} ? DocumentModel<O> : O;
+type FilterType = Record<string, any>;
+type DocumentModel<T, D = Dayjs> = T extends (infer S)[] ? DocumentModel<S>[] : T extends string ? T : T extends number ? T : T extends boolean ? T : T extends Dayjs ? T : T extends Map<infer K, infer V> ? Map<K, DocumentModel<V, D>> : Optional<{
+    [K in keyof GetStateObject<T>]: T[K] extends infer S ? S extends null ? undefined : ObjectToId<T[K], D> : never;
+}, OptionalKeys<GetStateObject<T>>>;
+type GetStateObject<T> = Omit<{
+    [K in keyof T as T[K] extends (...args: any) => any ? never : K]: T[K];
+}, "prototype">;
+interface TextDoc {
+    [key: string]: string | TextDoc;
+}
+
+export { BaseObject as B, type DocumentModel as D, type FilterType as F, type GqlScalar as G, type TextDoc as T };

package/types-H2HI4YUe.d.ts

@@ -0,0 +1,3 @@
+type Type<T = any> = new (...args: any[]) => T;
+
+export type { Type as T };