stream-chat-angular 5.0.0-v5.8 → 5.0.0

package/esm2020/lib/channel-query.mjs

@@ -0,0 +1,77 @@
+/**
+ * This class allows you to make paginated channel query requests.
+ */
+export class ChannelQuery {
+    constructor(chatService, channelService, filters, sort = { last_message_at: -1 }, options = {
+        limit: 25,
+        state: true,
+        presence: true,
+        watch: true,
+    }) {
+        this.chatService = chatService;
+        this.channelService = channelService;
+        this.filters = filters;
+        this.sort = sort;
+        this.options = options;
+    }
+    async query(queryType) {
+        if (queryType === 'first-page' || queryType === 'recover-state') {
+            this.nextPageConfiguration = undefined;
+        }
+        const prevChannels = queryType === 'recover-state' ? [] : this.channelService.channels;
+        let filters;
+        let options;
+        if (this.nextPageConfiguration) {
+            if (this.nextPageConfiguration.type === 'filter') {
+                filters = {
+                    ...this.filters,
+                    ...this.nextPageConfiguration.paginationFilter,
+                };
+                options = this.options;
+            }
+            else {
+                options = {
+                    ...this.options,
+                    offset: this.nextPageConfiguration.offset,
+                };
+                filters = this.filters;
+            }
+        }
+        else {
+            filters = this.filters;
+            options = this.options;
+        }
+        const channels = await this.chatService.chatClient.queryChannels(filters, this.sort || {}, options);
+        this.setNextPageConfiguration(channels);
+        const currentActiveChannel = this.channelService.activeChannel;
+        if (queryType === 'recover-state' &&
+            currentActiveChannel &&
+            !channels.find((c) => c.cid === currentActiveChannel?.cid)) {
+            try {
+                await currentActiveChannel.watch();
+                channels.unshift(currentActiveChannel);
+            }
+            catch (error) {
+                this.chatService.chatClient.logger('warn', 'Unable to refetch active channel after state recover', error);
+            }
+        }
+        return {
+            channels: [...prevChannels, ...channels],
+            hasMorePage: channels.length >= this.options.limit,
+        };
+    }
+    setNextPageConfiguration(channelQueryResult) {
+        if (this.customPaginator) {
+            this.nextPageConfiguration = this.customPaginator(channelQueryResult);
+        }
+        else {
+            this.nextPageConfiguration = {
+                type: 'offset',
+                offset: (this.nextPageConfiguration?.type === 'offset'
+                    ? this.nextPageConfiguration.offset
+                    : 0) + channelQueryResult.length,
+            };
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"channel-query.js","sourceRoot":"","sources":["../../../../projects/stream-chat-angular/src/lib/channel-query.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Channel,\n  ChannelFilters,\n  ChannelOptions,\n  ChannelSort,\n} from 'stream-chat';\nimport { ChannelService } from './channel.service';\nimport {\n  ChannelQueryResult,\n  ChannelQueryType,\n  DefaultStreamChatGenerics,\n  NextPageConfiguration,\n} from './types';\nimport { ChatClientService } from './chat-client.service';\n\n/**\n * This class allows you to make paginated channel query requests.\n */\nexport class ChannelQuery<\n  T extends DefaultStreamChatGenerics = DefaultStreamChatGenerics\n> {\n  /**\n   * By default the SDK uses an offset based pagination, you can change/extend this by providing your own custom paginator method.\n   *\n   * The method will be called with the result of the latest channel query.\n   *\n   * You can return either an offset, or a filter using the [`$lte`/`$gte` operator](https://getstream.io/chat/docs/javascript/query_syntax_operators/). If you return a filter, it will be merged with the filter provided for the `init` method.\n   */\n  customPaginator?: (channelQueryResult: Channel<T>[]) => NextPageConfiguration;\n  private nextPageConfiguration?: NextPageConfiguration;\n\n  constructor(\n    private chatService: ChatClientService<T>,\n    private channelService: ChannelService<T>,\n    private filters: ChannelFilters<T>,\n    private sort: ChannelSort<T> = { last_message_at: -1 },\n    private options: ChannelOptions = {\n      limit: 25,\n      state: true,\n      presence: true,\n      watch: true,\n    }\n  ) {}\n\n  async query(queryType: ChannelQueryType): Promise<ChannelQueryResult<T>> {\n    if (queryType === 'first-page' || queryType === 'recover-state') {\n      this.nextPageConfiguration = undefined;\n    }\n    const prevChannels =\n      queryType === 'recover-state' ? [] : this.channelService.channels;\n    let filters: ChannelFilters<T>;\n    let options: ChannelOptions;\n    if (this.nextPageConfiguration) {\n      if (this.nextPageConfiguration.type === 'filter') {\n        filters = {\n          ...this.filters,\n          ...this.nextPageConfiguration.paginationFilter,\n        };\n        options = this.options;\n      } else {\n        options = {\n          ...this.options,\n          offset: this.nextPageConfiguration.offset,\n        };\n        filters = this.filters;\n      }\n    } else {\n      filters = this.filters;\n      options = this.options;\n    }\n    const channels = await this.chatService.chatClient.queryChannels(\n      filters,\n      this.sort || {},\n      options\n    );\n    this.setNextPageConfiguration(channels);\n\n    const currentActiveChannel = this.channelService.activeChannel;\n    if (\n      queryType === 'recover-state' &&\n      currentActiveChannel &&\n      !channels.find((c) => c.cid === currentActiveChannel?.cid)\n    ) {\n      try {\n        await currentActiveChannel.watch();\n        channels.unshift(currentActiveChannel);\n      } catch (error) {\n        this.chatService.chatClient.logger(\n          'warn',\n          'Unable to refetch active channel after state recover',\n          error as Record<string, unknown>\n        );\n      }\n    }\n\n    return {\n      channels: [...prevChannels, ...channels],\n      hasMorePage: channels.length >= this.options.limit!,\n    };\n  }\n\n  setNextPageConfiguration(channelQueryResult: Channel<T>[]) {\n    if (this.customPaginator) {\n      this.nextPageConfiguration = this.customPaginator(channelQueryResult);\n    } else {\n      this.nextPageConfiguration = {\n        type: 'offset',\n        offset:\n          (this.nextPageConfiguration?.type === 'offset'\n            ? this.nextPageConfiguration.offset\n            : 0) + channelQueryResult.length,\n      };\n    }\n  }\n}\n"]}