@akanjs/server 0.0.45 → 0.0.47

package/src/schema.js

@@ -0,0 +1,238 @@
+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,
+  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(".");
+class ScalarSchemaStorage {
+}
+class 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 = (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;
+};
+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, (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;
+};
+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, (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;
+};

package/src/searchDaemon.js

@@ -0,0 +1,223 @@
+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 __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);
+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");
+const hasTextField = (modelRef) => {
+  const fieldMetas = (0, import_constant.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 = (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
+  };
+};
+const makeTextFilter = (modelRef) => {
+  const fieldMetaMap = (0, import_constant.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 = (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)];
+};
+let SearchDaemon = class {
+  constructor(connection, meili) {
+    this.connection = connection;
+    this.meili = meili;
+  }
+  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 = __decorateClass([
+  (0, import_common2.Injectable)(),
+  __decorateParam(0, (0, import_mongoose.InjectConnection)()),
+  __decorateParam(1, (0, import_common2.Inject)("MEILI_CLIENT"))
+], SearchDaemon);
+let SearchDaemonModule = class {
+};
+SearchDaemonModule = __decorateClass([
+  (0, import_common2.Global)(),
+  (0, import_common2.Module)({
+    providers: [SearchDaemon]
+  })
+], SearchDaemonModule);

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.js

@@ -0,0 +1,141 @@
+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 __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 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");
+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 {
+  intercept(context, next) {
+    const [, gqlKey] = [context.getArgByIndex(1), context.getArgByIndex(3)];
+    return next.handle().pipe((0, import_operators.map)((data) => ({ event: gqlKey, data })));
+  }
+};
+TransformInterceptor = __decorateClass([
+  (0, import_common2.Injectable)()
+], TransformInterceptor);
+const makeRoomId = (gqlKey, argValues) => `${gqlKey}-${argValues.join("-")}`;
+const getPubsubInterceptor = (argMetas) => {
+  let PubsubInterceptor = class {
+    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 = __decorateClass([
+    (0, import_common2.Injectable)()
+  ], PubsubInterceptor);
+  return PubsubInterceptor;
+};
+const websocketOf = (sigRef, allSrvs) => {
+  const sigMeta = (0, import_signal.getSigMeta)(sigRef);
+  class 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;
+};
+const websocketServerOf = (sigRef) => {
+  const pubsubGqlMetas = (0, import_signal.getGqlMetas)(sigRef).filter((gqlMeta) => gqlMeta.type === "Pubsub");
+  let Websocket = class {
+    server;
+  };
+  __decorateClass([
+    (0, import_websockets.WebSocketServer)()
+  ], Websocket.prototype, "server", 2);
+  Websocket = __decorateClass([
+    (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;
+};