@stream-io/feeds-client 0.1.0

package/src/common/StateStore.ts

@@ -0,0 +1,314 @@
+export type Patch<T> = (value: T) => T;
+export type ValueOrPatch<T> = T | Patch<T>;
+export type Handler<T> = (nextValue: T, previousValue: T | undefined) => void;
+export type Unsubscribe = () => void;
+// aliases
+export type RemovePreprocessor = Unsubscribe;
+export type Preprocessor<T> = Handler<T>;
+
+export const isPatch = <T>(value: ValueOrPatch<T>): value is Patch<T> =>
+  typeof value === 'function';
+
+ 
+const noop = () => {};
+
+export class StateStore<T extends Record<string, unknown>> {
+  protected handlers = new Set<Handler<T>>();
+  protected preprocessors = new Set<Preprocessor<T>>();
+
+  constructor(protected value: T) {}
+
+  /**
+   * Allows merging two stores only if their keys differ otherwise there's no way to ensure the data type stability.
+   * @experimental
+   * This method is experimental and may change in future versions.
+   */
+   
+  public merge<Q extends StateStore<any>>(
+    stateStore: Q extends StateStore<infer L>
+      ? Extract<keyof T, keyof L> extends never
+        ? Q
+        : never
+      : never,
+  ) {
+    return new MergedStateStore<T, Q extends StateStore<infer L> ? L : never>({
+      original: this,
+      merged: stateStore,
+    });
+  }
+
+  public next(newValueOrPatch: ValueOrPatch<T>): void {
+    // newValue (or patch output) should never be a mutated previous value
+    const newValue = isPatch(newValueOrPatch)
+      ? newValueOrPatch(this.value)
+      : newValueOrPatch;
+
+    // do not notify subscribers if the value hasn't changed
+    if (newValue === this.value) return;
+
+    this.preprocessors.forEach((preprocessor) =>
+      preprocessor(newValue, this.value),
+    );
+
+    const oldValue = this.value;
+    this.value = newValue;
+
+    this.handlers.forEach((handler) => handler(this.value, oldValue));
+  }
+
+  public partialNext = (partial: Partial<T>): void =>
+    this.next((current) => ({ ...current, ...partial }));
+
+  public getLatestValue(): T {
+    return this.value;
+  }
+
+  public subscribe(handler: Handler<T>): Unsubscribe {
+    handler(this.value, undefined);
+    this.handlers.add(handler);
+    return () => {
+      this.handlers.delete(handler);
+    };
+  }
+
+  public subscribeWithSelector = <
+    O extends Readonly<Record<string, unknown>> | readonly unknown[],
+  >(
+    selector: (nextValue: T) => O,
+    handler: Handler<O>,
+  ) => {
+    // begin with undefined to reduce amount of selector calls
+    let previouslySelectedValues: O | undefined;
+
+    const wrappedHandler: Handler<T> = (nextValue) => {
+      const newlySelectedValues = selector(nextValue);
+
+      let hasUpdatedValues = typeof previouslySelectedValues === 'undefined';
+
+      for (const key in previouslySelectedValues) {
+        if (previouslySelectedValues[key] === newlySelectedValues[key])
+          continue;
+        hasUpdatedValues = true;
+        break;
+      }
+
+      if (!hasUpdatedValues) return;
+
+      // save a copy of previouslySelectedValues before running
+      // handler - if previouslySelectedValues are set to
+      // newlySelectedValues after the handler call, there's a chance
+      // that it'll never get set as handler can throw and flow might
+      // go out of sync
+      const previouslySelectedValuesCopy = previouslySelectedValues;
+      previouslySelectedValues = newlySelectedValues;
+
+      handler(newlySelectedValues, previouslySelectedValuesCopy);
+    };
+
+    return this.subscribe(wrappedHandler);
+  };
+
+  /**
+   * Registers a preprocessor function that will be called before the state is updated.
+   *
+   * Preprocessors are invoked with the new and previous values whenever `next` or `partialNext` methods
+   * are called, allowing you to mutate or react to the new value before it is set. Preprocessors run in the
+   * order they were registered.
+   *
+   * @example
+   * ```ts
+   * const store = new StateStore<{ count: number; isMaxValue: bool; }>({ count: 0, isMaxValue: false });
+   *
+   * store.addPreprocessor((nextValue, prevValue) => {
+   *   if (nextValue.count > 10) {
+   *     nextValue.count = 10; // Clamp the value to a maximum of 10
+   *   }
+   *
+   *   if (nextValue.count === 10) {
+   *     nextValue.isMaxValue = true; // Set isMaxValue to true if count is 10
+   *   } else {
+   *     nextValue.isMaxValue = false; // Reset isMaxValue otherwise
+   *   }
+   * });
+   *
+   * store.partialNext({ count: 15 });
+   *
+   * store.getLatestValue(); // { count: 10, isMaxValue: true }
+   *
+   * store.partialNext({ count: 5 });
+   *
+   * store.getLatestValue(); // { count: 5, isMaxValue: false }
+   * ```
+   *
+   * @param preprocessor - The function to be called with the next and previous values before the state is updated.
+   * @returns A `RemovePreprocessor` function that removes the preprocessor when called.
+   */
+  public addPreprocessor(preprocessor: Preprocessor<T>): RemovePreprocessor {
+    this.preprocessors.add(preprocessor);
+
+    return () => {
+      this.preprocessors.delete(preprocessor);
+    };
+  }
+}
+
+/**
+ * Represents a merged state store that combines two separate state stores into one.
+ *
+ * The MergedStateStore allows combining two stores with non-overlapping keys.
+ * It extends StateStore with the combined type of both source stores.
+ * Changes to either the original or merged store will propagate to the combined store.
+ *
+ * Note: Direct mutations (next, partialNext, addPreprocessor) are disabled on the merged store.
+ * You should instead call these methods on the original or merged stores.
+ *
+ * @template O The type of the original state store
+ * @template M The type of the merged state store
+ *
+ * @experimental
+ * This class is experimental and may change in future versions.
+ */
+export class MergedStateStore<
+  O extends Record<string, unknown>,
+  M extends Record<string, unknown>,
+> extends StateStore<O & M> {
+  public readonly original: StateStore<O>;
+  public readonly merged: StateStore<M>;
+  private cachedOriginalValue: O;
+  private cachedMergedValue: M;
+
+  constructor({
+    original,
+    merged,
+  }: {
+    original: StateStore<O>;
+    merged: StateStore<M>;
+  }) {
+    const originalValue = original.getLatestValue();
+    const mergedValue = merged.getLatestValue();
+
+    super({
+      ...originalValue,
+      ...mergedValue,
+    });
+
+    this.cachedOriginalValue = originalValue;
+    this.cachedMergedValue = mergedValue;
+
+    this.original = original;
+    this.merged = merged;
+  }
+
+  /**
+   * Subscribes to changes in the merged state store.
+   *
+   * This method extends the base subscribe functionality to handle the merged nature of this store:
+   * 1. The first subscriber triggers registration of helper subscribers that listen to both source stores
+   * 2. Changes from either source store are propagated to this merged store
+   * 3. Source store values are cached to prevent unnecessary updates
+   *
+   * When the first subscriber is added, the method sets up listeners on both original and merged stores.
+   * These listeners update the combined store value whenever either source store changes.
+   * All subscriptions (helpers and the actual handler) are tracked so they can be properly cleaned up.
+   *
+   * @param handler - The callback function that will be executed when the state changes
+   * @returns An unsubscribe function that, when called, removes the subscription and any helper subscriptions
+   */
+  public subscribe(handler: Handler<O & M>) {
+    const unsubscribeFunctions: Unsubscribe[] = [];
+
+    // first subscriber will also register helpers which listen to changes of the
+    // "original" and "merged" stores, combined outputs will be emitted through super.next
+    // whenever cached values do not equal (always apart from the initial subscription)
+    // since the actual handler subscription is registered after helpers, the actual
+    // handler will run only once
+    if (!this.handlers.size) {
+      const base = (nextValue: O | M) => {
+        super.next((currentValue) => ({
+          ...currentValue,
+          ...nextValue,
+        }));
+      };
+
+      unsubscribeFunctions.push(
+        this.original.subscribe((nextValue) => {
+          if (nextValue === this.cachedOriginalValue) return;
+          this.cachedOriginalValue = nextValue;
+          base(nextValue);
+        }),
+        this.merged.subscribe((nextValue) => {
+          if (nextValue === this.cachedMergedValue) return;
+          this.cachedMergedValue = nextValue;
+          base(nextValue);
+        }),
+      );
+    }
+
+    unsubscribeFunctions.push(super.subscribe(handler));
+
+    return () => {
+      unsubscribeFunctions.forEach((unsubscribe) => unsubscribe());
+    };
+  }
+
+  /**
+   * Retrieves the latest combined state from both original and merged stores.
+   *
+   * This method extends the base getLatestValue functionality to ensure the merged store
+   * remains in sync with its source stores even when there are no active subscribers.
+   *
+   * When there are no handlers registered, the method:
+   * 1. Fetches the latest values from both source stores
+   * 2. Compares them with the cached values to detect changes
+   * 3. If changes are detected, updates the internal value and caches
+   *    the new source values to maintain consistency
+   *
+   * This approach ensures that calling getLatestValue() always returns the most
+   * up-to-date combined state, even if the merged store hasn't been actively
+   * receiving updates through subscriptions.
+   *
+   * @returns The latest combined state from both original and merged stores
+   */
+  public getLatestValue() {
+    // if there are no handlers registered to MergedStore then the local value might be out-of-sync
+    // pull latest and compare against cached - if they differ, cache latest and produce new combined
+    if (!this.handlers.size) {
+      const originalValue = this.original.getLatestValue();
+      const mergedValue = this.merged.getLatestValue();
+
+      if (
+        originalValue !== this.cachedOriginalValue ||
+        mergedValue !== this.cachedMergedValue
+      ) {
+        this.value = {
+          ...originalValue,
+          ...mergedValue,
+        };
+        this.cachedMergedValue = mergedValue;
+        this.cachedOriginalValue = originalValue;
+      }
+    }
+
+    return super.getLatestValue();
+  }
+
+  // override original methods and "disable" them
+  public next = () => {
+    console.warn(
+      `${MergedStateStore.name}.next is disabled, call original.next or merged.next instead`,
+    );
+  };
+
+  public partialNext = () => {
+    console.warn(
+      `${MergedStateStore.name}.partialNext is disabled, call original.partialNext or merged.partialNext instead`,
+    );
+  };
+
+  public addPreprocessor() {
+    console.warn(
+      `${MergedStateStore.name}.addPreprocessor is disabled, call original.addPreprocessor or merged.addPreprocessor instead`,
+    );
+    return noop;
+  }
+}

package/src/common/TokenManager.ts

@@ -0,0 +1,112 @@
+import { isFunction, retryInterval, sleep } from './utils';
+
+/**
+ * TokenManager
+ *
+ * Handles all the operations around user token.
+ */
+export class TokenManager {
+  loadTokenPromise: Promise<string> | null;
+  type: 'static' | 'provider';
+  token?: string;
+  tokenProvider?: string | (() => Promise<string>);
+
+  constructor() {
+    this.loadTokenPromise = null;
+
+    this.type = 'static';
+  }
+
+  /**
+   * Set the static string token or token provider.
+   * Token provider should return a token string or a promise which resolves to string token.
+   *
+   * @param {TokenOrProvider} tokenOrProvider - the token or token provider.
+   * @param {UserResponse} user - the user object.
+   * @param {boolean} isAnonymous - whether the user is anonymous or not.
+   */
+  setTokenOrProvider = (tokenOrProvider?: string | (() => Promise<string>)) => {
+    if (isFunction(tokenOrProvider)) {
+      this.tokenProvider = tokenOrProvider;
+      this.type = 'provider';
+    }
+
+    if (typeof tokenOrProvider === 'string') {
+      this.token = tokenOrProvider;
+      this.type = 'static';
+    }
+  };
+
+  /**
+   * Resets the token manager.
+   * Useful for client disconnection or switching user.
+   */
+  reset = () => {
+    this.token = undefined;
+    this.loadTokenPromise = null;
+  };
+
+  // Fetches a token from tokenProvider function and sets in tokenManager.
+  // In case of static token, it will simply resolve to static token.
+  loadToken = () => {
+    if (this.loadTokenPromise) {
+      return this.loadTokenPromise;
+    }
+
+    this.loadTokenPromise = new Promise(async (resolve, reject) => {
+      if (this.type === 'static') {
+        this.loadTokenPromise = null;
+        return resolve(this.token!);
+      }
+
+      if (this.tokenProvider && typeof this.tokenProvider !== 'string') {
+        this.token = undefined;
+        const tokenProvider = this.tokenProvider;
+        const loadTokenWithRetries = async (previousFailuresCount = 0) => {
+          try {
+            this.token = await tokenProvider();
+          } catch (e) {
+            const numberOfFailures = ++previousFailuresCount;
+            await sleep(retryInterval(numberOfFailures));
+            if (numberOfFailures === 3) {
+              this.loadTokenPromise = null;
+              return reject(
+                new Error(
+
+                  `Stream error: tried to get token ${numberOfFailures} times, but it failed with ${e}. Check your token provider`,
+                  { cause: e },
+                ),
+              );
+            } else {
+              return await loadTokenWithRetries(numberOfFailures);
+            }
+          }
+          this.loadTokenPromise = null;
+          resolve(this.token);
+        };
+        return await loadTokenWithRetries();
+      }
+    });
+
+    return this.loadTokenPromise;
+  };
+
+  // Returns the current token, or fetches in a new one if there is no current token
+  getToken = () => {
+    if (this.token) {
+      return this.token;
+    }
+
+    if (this.tokenProvider) {
+      if (this.loadTokenPromise) {
+        return this.loadTokenPromise;
+      } else {
+        return this.loadToken();
+      }
+    }
+
+    throw new Error(`Can't get token because token provider isn't set`);
+  };
+
+  isStatic = () => this.type === 'static';
+}

package/src/common/UserSearchSource.ts

@@ -0,0 +1,93 @@
+import { BaseSearchSource } from './BaseSearchSource';
+import type { SearchSourceOptions } from './BaseSearchSource';
+
+import { FeedsClient } from '../FeedsClient';
+import { UserResponse } from '../gen/models';
+
+export class UserSearchSource extends BaseSearchSource<UserResponse> {
+  readonly type = 'user' as const;
+  private readonly client: FeedsClient;
+  // messageSearchChannelFilters: ChannelFilters | undefined;
+  // messageSearchFilters: MessageFilters | undefined;
+  // messageSearchSort: SearchMessageSort | undefined;
+  // channelQueryFilters: ChannelFilters | undefined;
+  // channelQuerySort: ChannelSort | undefined;
+  // channelQueryOptions: Omit<ChannelOptions, 'limit' | 'offset'> | undefined;
+
+  constructor(client: FeedsClient, options?: SearchSourceOptions) {
+    super(options);
+    this.client = client;
+  }
+
+  protected async query(searchQuery: string) {
+    const { connectedUser } = this.client.state.getLatestValue();
+    if (!connectedUser) return { items: [] };
+
+    // const channelFilters: ChannelFilters = {
+    //   members: { $in: [this.client.userID] },
+    //   ...this.messageSearchChannelFilters,
+    // } as ChannelFilters;
+
+    // const messageFilters: MessageFilters = {
+    //   text: searchQuery,
+    //   type: 'regular', // FIXME: type: 'reply' resp. do not filter by type and allow to jump to a message in a thread - missing support
+    //   ...this.messageSearchFilters,
+    // } as MessageFilters;
+
+    // const sort: SearchMessageSort = {
+    //   created_at: -1,
+    //   ...this.messageSearchSort,
+    // };
+
+    // const options = {
+    //   limit: this.pageSize,
+    //   next: this.next,
+    //   sort,
+    // } as SearchOptions;
+
+    // const { next, results } = await this.client.search(
+    //   channelFilters,
+    //   messageFilters,
+    //   options,
+    // );
+    // const items = results.map(({ message }) => message);
+
+    // const cids = Array.from(
+    //   items.reduce((acc, message) => {
+    //     if (message.cid && !this.client.activeChannels[message.cid])
+    //       acc.add(message.cid);
+    //     return acc;
+    //   }, new Set<string>()), // keep the cids unique
+    // );
+    // const allChannelsLoadedLocally = cids.length === 0;
+    // if (!allChannelsLoadedLocally) {
+    //   await this.client.queryChannels(
+    //     {
+    //       cid: { $in: cids },
+    //       ...this.channelQueryFilters,
+    //     } as ChannelFilters,
+    //     {
+    //       last_message_at: -1,
+    //       ...this.channelQuerySort,
+    //     },
+    //     this.channelQueryOptions,
+    //   );
+    // }
+
+    const { users: items } = await this.client.queryUsers({
+      payload: {
+        filter_conditions: {
+          name: {
+            $autocomplete: searchQuery,
+          },
+        },
+      },
+    });
+
+    return { items, next: undefined };
+  }
+
+  protected filterQueryResults(items: UserResponse[]) {
+    return items;
+  }
+}

package/src/common/gen-imports.ts

@@ -0,0 +1,2 @@
+export type { ApiClient } from './ApiClient';
+export type { StreamResponse } from './types';

package/src/common/rate-limit.ts

@@ -0,0 +1,23 @@
+import { RateLimit } from './types';
+
+export const getRateLimitFromResponseHeader = (
+  response_headers: Record<string, string>,
+) => {
+  const rate_limit = response_headers['x-ratelimit-limit']
+    ? +response_headers['x-ratelimit-limit']!
+    : undefined;
+  const rate_limit_remaining = response_headers['x-ratelimit-remaining']
+    ? +response_headers['x-ratelimit-remaining']!
+    : undefined;
+  const rate_limit_reset = response_headers['x-ratelimit-reset']
+    ? new Date(+response_headers['x-ratelimit-reset']! * 1000)
+    : undefined;
+
+  const result: RateLimit = {
+    rate_limit,
+    rate_limit_remaining,
+    rate_limit_reset,
+  };
+
+  return result;
+};