@conduitplatform/grpc-sdk 0.17.0-alpha.7 → 0.17.0-alpha.8

package/dist/index.esm.js

@@ -521,6 +521,143 @@ var UserChangePass = {
     return message;
   }
 };
+function createBaseUserChangeEmail() {
+  return { userId: "", newEmail: "" };
+}
+var UserChangeEmail = {
+  encode(message, writer = new BinaryWriter2()) {
+    if (message.userId !== "") {
+      writer.uint32(10).string(message.userId);
+    }
+    if (message.newEmail !== "") {
+      writer.uint32(18).string(message.newEmail);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader2 ? input : new BinaryReader2(input);
+    const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
+    if (previousRecursionDepth >= 100) {
+      throw new globalThis.Error("protobuf decode recursion limit exceeded");
+    }
+    reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
+    try {
+      const end = length === void 0 ? reader.len : reader.pos + length;
+      const message = createBaseUserChangeEmail();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            if (tag !== 10) {
+              break;
+            }
+            message.userId = reader.string();
+            continue;
+          }
+          case 2: {
+            if (tag !== 18) {
+              break;
+            }
+            message.newEmail = reader.string();
+            continue;
+          }
+        }
+        if ((tag & 7) === 4 || tag === 0) {
+          break;
+        }
+        reader.skip(tag & 7);
+      }
+      return message;
+    } finally {
+      reader.__tsProtoDecodeDepth = previousRecursionDepth;
+    }
+  },
+  fromJSON(object) {
+    return {
+      userId: isSet(object.userId) ? globalThis.String(object.userId) : "",
+      newEmail: isSet(object.newEmail) ? globalThis.String(object.newEmail) : ""
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.userId !== "") {
+      obj.userId = message.userId;
+    }
+    if (message.newEmail !== "") {
+      obj.newEmail = message.newEmail;
+    }
+    return obj;
+  },
+  create(base) {
+    return UserChangeEmail.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseUserChangeEmail();
+    message.userId = object.userId ?? "";
+    message.newEmail = object.newEmail ?? "";
+    return message;
+  }
+};
+function createBaseUserChangeEmailResponse() {
+  return { message: "" };
+}
+var UserChangeEmailResponse = {
+  encode(message, writer = new BinaryWriter2()) {
+    if (message.message !== "") {
+      writer.uint32(10).string(message.message);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader2 ? input : new BinaryReader2(input);
+    const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
+    if (previousRecursionDepth >= 100) {
+      throw new globalThis.Error("protobuf decode recursion limit exceeded");
+    }
+    reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
+    try {
+      const end = length === void 0 ? reader.len : reader.pos + length;
+      const message = createBaseUserChangeEmailResponse();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            if (tag !== 10) {
+              break;
+            }
+            message.message = reader.string();
+            continue;
+          }
+        }
+        if ((tag & 7) === 4 || tag === 0) {
+          break;
+        }
+        reader.skip(tag & 7);
+      }
+      return message;
+    } finally {
+      reader.__tsProtoDecodeDepth = previousRecursionDepth;
+    }
+  },
+  fromJSON(object) {
+    return { message: isSet(object.message) ? globalThis.String(object.message) : "" };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.message !== "") {
+      obj.message = message.message;
+    }
+    return obj;
+  },
+  create(base) {
+    return UserChangeEmailResponse.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseUserChangeEmailResponse();
+    message.message = object.message ?? "";
+    return message;
+  }
+};
 function createBaseUserDeleteRequest() {
   return { userId: "" };
 }
@@ -2063,6 +2200,14 @@ var AuthenticationDefinition = {
       responseStream: false,
       options: {}
     },
+    changeEmail: {
+      name: "ChangeEmail",
+      requestType: UserChangeEmail,
+      requestStream: false,
+      responseType: UserChangeEmailResponse,
+      responseStream: false,
+      options: {}
+    },
     userDelete: {
       name: "UserDelete",
       requestType: UserDeleteRequest,
@@ -4099,6 +4244,83 @@ var EditMessageRequest = {
     return message;
   }
 };
+function createBaseDeleteMessageRequest() {
+  return { messageId: "", userId: "" };
+}
+var DeleteMessageRequest = {
+  encode(message, writer = new BinaryWriter4()) {
+    if (message.messageId !== "") {
+      writer.uint32(10).string(message.messageId);
+    }
+    if (message.userId !== "") {
+      writer.uint32(18).string(message.userId);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader4 ? input : new BinaryReader4(input);
+    const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
+    if (previousRecursionDepth >= 100) {
+      throw new globalThis.Error("protobuf decode recursion limit exceeded");
+    }
+    reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
+    try {
+      const end = length === void 0 ? reader.len : reader.pos + length;
+      const message = createBaseDeleteMessageRequest();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            if (tag !== 10) {
+              break;
+            }
+            message.messageId = reader.string();
+            continue;
+          }
+          case 2: {
+            if (tag !== 18) {
+              break;
+            }
+            message.userId = reader.string();
+            continue;
+          }
+        }
+        if ((tag & 7) === 4 || tag === 0) {
+          break;
+        }
+        reader.skip(tag & 7);
+      }
+      return message;
+    } finally {
+      reader.__tsProtoDecodeDepth = previousRecursionDepth;
+    }
+  },
+  fromJSON(object) {
+    return {
+      messageId: isSet3(object.messageId) ? globalThis.String(object.messageId) : "",
+      userId: isSet3(object.userId) ? globalThis.String(object.userId) : ""
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.messageId !== "") {
+      obj.messageId = message.messageId;
+    }
+    if (message.userId !== "") {
+      obj.userId = message.userId;
+    }
+    return obj;
+  },
+  create(base) {
+    return DeleteMessageRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseDeleteMessageRequest();
+    message.messageId = object.messageId ?? "";
+    message.userId = object.userId ?? "";
+    return message;
+  }
+};
 function createBaseDeleteRoomRequest() {
   return { _id: "" };
 }
@@ -4348,6 +4570,14 @@ var ChatDefinition = {
       responseType: Empty,
       responseStream: false,
       options: {}
+    },
+    deleteMessage: {
+      name: "DeleteMessage",
+      requestType: DeleteMessageRequest,
+      requestStream: false,
+      responseType: Empty,
+      responseStream: false,
+      options: {}
     }
   }
 };
@@ -9498,6 +9728,113 @@ function isSet4(value) {
 
 // src/protoUtils/core.ts
 import { BinaryReader as BinaryReader6, BinaryWriter as BinaryWriter6 } from "@bufbuild/protobuf/wire";
+function createBaseSocketPushRequest() {
+  return { event: "", data: void 0, receivers: [], rooms: [] };
+}
+var SocketPushRequest = {
+  encode(message, writer = new BinaryWriter6()) {
+    if (message.event !== "") {
+      writer.uint32(10).string(message.event);
+    }
+    if (message.data !== void 0) {
+      writer.uint32(18).string(message.data);
+    }
+    for (const v of message.receivers) {
+      writer.uint32(26).string(v);
+    }
+    for (const v of message.rooms) {
+      writer.uint32(34).string(v);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader6 ? input : new BinaryReader6(input);
+    const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
+    if (previousRecursionDepth >= 100) {
+      throw new globalThis.Error("protobuf decode recursion limit exceeded");
+    }
+    reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
+    try {
+      const end = length === void 0 ? reader.len : reader.pos + length;
+      const message = createBaseSocketPushRequest();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            if (tag !== 10) {
+              break;
+            }
+            message.event = reader.string();
+            continue;
+          }
+          case 2: {
+            if (tag !== 18) {
+              break;
+            }
+            message.data = reader.string();
+            continue;
+          }
+          case 3: {
+            if (tag !== 26) {
+              break;
+            }
+            message.receivers.push(reader.string());
+            continue;
+          }
+          case 4: {
+            if (tag !== 34) {
+              break;
+            }
+            message.rooms.push(reader.string());
+            continue;
+          }
+        }
+        if ((tag & 7) === 4 || tag === 0) {
+          break;
+        }
+        reader.skip(tag & 7);
+      }
+      return message;
+    } finally {
+      reader.__tsProtoDecodeDepth = previousRecursionDepth;
+    }
+  },
+  fromJSON(object) {
+    return {
+      event: isSet5(object.event) ? globalThis.String(object.event) : "",
+      data: isSet5(object.data) ? globalThis.String(object.data) : void 0,
+      receivers: globalThis.Array.isArray(object?.receivers) ? object.receivers.map((e) => globalThis.String(e)) : [],
+      rooms: globalThis.Array.isArray(object?.rooms) ? object.rooms.map((e) => globalThis.String(e)) : []
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.event !== "") {
+      obj.event = message.event;
+    }
+    if (message.data !== void 0) {
+      obj.data = message.data;
+    }
+    if (message.receivers?.length) {
+      obj.receivers = message.receivers;
+    }
+    if (message.rooms?.length) {
+      obj.rooms = message.rooms;
+    }
+    return obj;
+  },
+  create(base) {
+    return SocketPushRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseSocketPushRequest();
+    message.event = object.event ?? "";
+    message.data = object.data ?? void 0;
+    message.receivers = object.receivers?.map((e) => e) || [];
+    message.rooms = object.rooms?.map((e) => e) || [];
+    return message;
+  }
+};
 function createBaseRegisterAdminRouteRequest() {
   return { routes: [], routerUrl: void 0 };
 }
@@ -11573,6 +11910,14 @@ var AdminDefinition = {
       responseType: Empty,
       responseStream: false,
       options: {}
+    },
+    socketPush: {
+      name: "SocketPush",
+      requestType: SocketPushRequest,
+      requestStream: false,
+      responseType: Empty,
+      responseStream: false,
+      options: {}
     }
   }
 };
@@ -22588,6 +22933,11 @@ var PostgresIndexType = /* @__PURE__ */ ((PostgresIndexType2) => {
   PostgresIndexType2["BRIN"] = "BRIN";
   return PostgresIndexType2;
 })(PostgresIndexType || {});
+var CompatibleIndexType = /* @__PURE__ */ ((CompatibleIndexType2) => {
+  CompatibleIndexType2["Ascending"] = "Ascending";
+  CompatibleIndexType2["Descending"] = "Descending";
+  return CompatibleIndexType2;
+})(CompatibleIndexType || {});
 var ConduitModelOptionsPermModifyType = [
   "Everything",
   "Nothing",
@@ -23216,6 +23566,9 @@ var Admin = class extends ConduitModule {
     };
     return this.client.registerAdminRoute(request);
   }
+  socketPush(data) {
+    return this.client.socketPush(data);
+  }
   patchRouteMiddlewares(path, action, middlewares) {
     return this.client.patchRouteMiddlewares({
       path,
@@ -23318,6 +23671,9 @@ var Chat = class extends ConduitModule {
   editMessage(messageData) {
     return this.client.editMessage(EditMessageRequest.fromPartial(messageData));
   }
+  deleteMessage(messageData) {
+    return this.client.deleteMessage(DeleteMessageRequest.fromPartial(messageData));
+  }
   createRoom(name, participants) {
     return this.client.createRoom({ name, participants });
   }
@@ -23407,6 +23763,9 @@ var Authentication = class extends ConduitModule {
   changePass(email, password) {
     return this.client.changePass({ email, password });
   }
+  changeEmail(userId, newEmail) {
+    return this.client.changeEmail({ userId, newEmail });
+  }
   getTeam(teamId) {
     return this.client.getTeam({ teamId });
   }
@@ -23732,72 +24091,136 @@ import crypto from "crypto";
 var EventBus = class {
   _clientSubscriber;
   _clientPublisher;
-  _subscribedChannels;
-  _subscribers;
+  /** channelName -> subscriberId -> callback */
+  _channelCallbacks;
+  /** subscriberId -> channelName */
+  _subscriberChannels;
+  /** channels with a successful Redis SUBSCRIBE */
+  _redisSubscribedChannels;
+  _subscribeInFlight = /* @__PURE__ */ new Map();
   _signature;
+  _anonymousSubscriberSeq = 0;
+  _shuttingDown = false;
   constructor(redisManager) {
-    this._subscribedChannels = {};
-    this._subscribers = {};
+    this._channelCallbacks = /* @__PURE__ */ new Map();
+    this._subscriberChannels = /* @__PURE__ */ new Map();
+    this._redisSubscribedChannels = /* @__PURE__ */ new Set();
     this._clientSubscriber = redisManager.getClient({ keyPrefix: "bus_" });
     this._clientPublisher = redisManager.getClient({ keyPrefix: "bus_" });
     this._signature = crypto.randomBytes(20).toString("hex");
     this._clientSubscriber.on("ready", () => {
       getLogger().log("The Bus is in the station...hehe");
     });
+    this._clientSubscriber.on("message", (channel, message) => {
+      this.dispatch(channel, message);
+    });
     process.on("exit", () => {
-      this._clientSubscriber.quit();
-      this._clientPublisher.quit();
+      this.quit();
     });
   }
+  quit() {
+    if (this._shuttingDown) return;
+    this._shuttingDown = true;
+    void this._clientSubscriber.quit();
+    void this._clientPublisher.quit();
+  }
   unsubscribe(subscriberId) {
-    if (this._subscribers[subscriberId]) {
-      const [channelName, index] = this._subscribers[subscriberId];
-      this._subscribedChannels[channelName].splice(index, 1);
-      delete this._subscribers[subscriberId];
-      if (this._subscribedChannels[channelName].length === 0) {
-        delete this._subscribedChannels[channelName];
+    const channelName = this._subscriberChannels.get(subscriberId);
+    if (!channelName) {
+      return;
+    }
+    const callbacks = this._channelCallbacks.get(channelName);
+    callbacks?.delete(subscriberId);
+    this._subscriberChannels.delete(subscriberId);
+    if (callbacks && callbacks.size === 0) {
+      this._channelCallbacks.delete(channelName);
+      if (this._redisSubscribedChannels.delete(channelName)) {
         this._clientSubscriber.unsubscribe(channelName, () => {
         });
       }
     }
   }
   subscribe(channelName, callback, subscriberId) {
+    void this.subscribeAck(channelName, callback, subscriberId).catch((err) => {
+      getLogger().error(
+        `EventBus subscribe failed for ${channelName}: ${err instanceof Error ? err.message : String(err)}`
+      );
+    });
+  }
+  async subscribeAck(channelName, callback, subscriberId) {
+    if (this._shuttingDown) {
+      return;
+    }
+    const id = subscriberId ?? `anon:${channelName}:${++this._anonymousSubscriberSeq}:${crypto.randomBytes(4).toString("hex")}`;
     if (subscriberId) {
       this.unsubscribe(subscriberId);
     }
-    if (this._subscribedChannels[channelName]) {
-      this._subscribedChannels[channelName].push(callback);
-      if (subscriberId) {
-        this._subscribers[subscriberId] = [
-          channelName,
-          this._subscribedChannels[channelName].length - 1
-        ];
-      }
+    let callbacks = this._channelCallbacks.get(channelName);
+    if (!callbacks) {
+      callbacks = /* @__PURE__ */ new Map();
+      this._channelCallbacks.set(channelName, callbacks);
+    }
+    callbacks.set(id, callback);
+    this._subscriberChannels.set(id, channelName);
+    if (this._redisSubscribedChannels.has(channelName)) {
       return;
     }
-    this._subscribedChannels[channelName] = [callback];
-    this._clientSubscriber.subscribe(channelName, () => {
-    });
-    const self = this;
-    this._clientSubscriber.on("message", (channel, message) => {
-      if (channel !== channelName) return;
-      if (message.indexOf("CND_Signature") !== -1) {
-        if (message.indexOf(self._signature) === -1) {
-          self._subscribedChannels[channelName].forEach((fn) => {
-            fn(message.split("CND_Signature:")[0]);
-          });
-        }
-      } else {
-        self._subscribedChannels[channelName].forEach((fn) => {
-          fn(message);
+    let inFlight = this._subscribeInFlight.get(channelName);
+    if (!inFlight) {
+      inFlight = new Promise((resolve, reject) => {
+        this._clientSubscriber.subscribe(channelName, (err) => {
+          if (err) {
+            reject(err);
+            return;
+          }
+          this._redisSubscribedChannels.add(channelName);
+          resolve();
         });
+      }).finally(() => {
+        this._subscribeInFlight.delete(channelName);
+      });
+      this._subscribeInFlight.set(channelName, inFlight);
+    }
+    try {
+      await inFlight;
+    } catch (err) {
+      if (!this._redisSubscribedChannels.has(channelName)) {
+        this.removeChannelCallbacks(channelName);
       }
-    });
+      this.unsubscribe(id);
+      throw err;
+    }
   }
   publish(channelName, message) {
     message = message + `CND_Signature:${this._signature}`;
     this._clientPublisher.publish(channelName, message);
   }
+  removeChannelCallbacks(channelName) {
+    const callbacks = this._channelCallbacks.get(channelName);
+    if (!callbacks) {
+      return;
+    }
+    for (const subId of callbacks.keys()) {
+      this._subscriberChannels.delete(subId);
+    }
+    this._channelCallbacks.delete(channelName);
+  }
+  dispatch(channel, message) {
+    const callbacks = this._channelCallbacks.get(channel);
+    if (!callbacks || callbacks.size === 0) {
+      return;
+    }
+    let payload = message;
+    if (message.indexOf("CND_Signature") !== -1) {
+      if (message.indexOf(this._signature) !== -1) {
+        return;
+      }
+      payload = message.split("CND_Signature:")[0];
+    }
+    for (const fn of callbacks.values()) {
+      fn(payload);
+    }
+  }
 };
 
 // src/utilities/RedisManager.ts
@@ -23934,6 +24357,9 @@ var StateManager = class {
   getKey(keyName) {
     return this.redisClient.get(keyName);
   }
+  incr(keyName) {
+    return this.redisClient.incr(keyName);
+  }
 };
 
 // src/index.ts
@@ -24647,6 +25073,7 @@ export {
   ColumnExistenceResponse,
   Communications,
   CommunicationsDefinition,
+  CompatibleIndexType,
   ConduitAuthorizedResource,
   ConduitError,
   ConduitGrpcSdk,
@@ -24680,6 +25107,7 @@ export {
   DeleteEmbeddingConfigRequest,
   DeleteEmbeddingConfigResponse,
   DeleteFileResponse,
+  DeleteMessageRequest,
   DeleteResourceRequest,
   DeleteRoomRequest,
   DeleteVectorIndexRequest,
@@ -24843,6 +25271,7 @@ export {
   SetNotificationTokenRequest,
   SetNotificationTokenResponse,
   SocketData,
+  SocketPushRequest,
   SocketRequest,
   SocketResponse,
   StartBackfillRequest,
@@ -24864,6 +25293,8 @@ export {
   UpdateTemplateRequest,
   UpsertConfigRequest,
   UpsertConfigResponse,
+  UserChangeEmail,
+  UserChangeEmailResponse,
   UserChangePass,
   UserCreateByUsernameRequest,
   UserCreateRequest,