@knocklabs/client 0.9.2 → 0.9.4

package/src/clients/feed/index.ts

@@ -0,0 +1,39 @@
+import Knock from "../../knock";
+
+import Feed from "./feed";
+import { FeedClientOptions } from "./interfaces";
+
+class FeedClient {
+  private instance: Knock;
+  private feedInstances: Feed[] = [];
+
+  constructor(instance: Knock) {
+    this.instance = instance;
+  }
+
+  initialize(feedChannelId: string, options: FeedClientOptions = {}) {
+    const feedInstance = new Feed(this.instance, feedChannelId, options);
+    this.feedInstances.push(feedInstance);
+
+    return feedInstance;
+  }
+
+  removeInstance(feed: Feed) {
+    this.feedInstances = this.feedInstances.filter((f) => f !== feed);
+  }
+
+  teardownInstances() {
+    for (const feed of this.feedInstances) {
+      feed.teardown();
+    }
+  }
+
+  reinitializeInstances() {
+    for (const feed of this.feedInstances) {
+      feed.reinitialize();
+    }
+  }
+}
+
+export { Feed };
+export default FeedClient;

package/src/clients/feed/interfaces.ts

@@ -0,0 +1,105 @@
+import { GenericData, PageInfo } from "@knocklabs/types";
+
+import { Activity, Recipient } from "../../interfaces";
+import { NetworkStatus } from "../../networkStatus";
+
+// Specific feed interfaces
+
+export interface FeedClientOptions {
+  before?: string;
+  after?: string;
+  page_size?: number;
+  status?: "unread" | "read" | "unseen" | "seen" | "all";
+  // Optionally scope all notifications to a particular source only
+  source?: string;
+  // Optionally scope all requests to a particular tenant
+  tenant?: string;
+  // Optionally scope to notifications with any tenancy or no tenancy
+  has_tenant?: boolean;
+  // Optionally scope to notifications with any of the categories provided
+  workflow_categories?: string[];
+  // Optionally scope to a given archived status (defaults to `exclude`)
+  archived?: "include" | "exclude" | "only";
+  // Optionally scope all notifications that contain this argument as part of their trigger payload
+  trigger_data?: GenericData;
+  // Optionally enable cross browser feed updates for this feed
+  __experimentalCrossBrowserUpdates?: boolean;
+  // Optionally automatically manage socket connections on changes to tab visibility (defaults to `false`)
+  auto_manage_socket_connection?: boolean;
+  // Optionally set the delay amount in milliseconds when automatically disconnecting sockets from inactive tabs (defaults to `2000`)
+  // Requires `auto_manage_socket_connection` to be `true`
+  auto_manage_socket_connection_delay?: number;
+}
+
+export type FetchFeedOptions = {
+  __loadingType?: NetworkStatus.loading | NetworkStatus.fetchMore;
+  __fetchSource?: "socket" | "http";
+} & Omit<FeedClientOptions, "__experimentalCrossBrowserUpdates">;
+
+export interface ContentBlockBase {
+  name: string;
+  type: "markdown" | "text" | "button_set";
+}
+
+export interface ActionButton {
+  name: string;
+  label: string;
+  action: string;
+}
+
+export interface ButtonSetContentBlock extends ContentBlockBase {
+  type: "button_set";
+  buttons: ActionButton[];
+}
+
+export interface TextContentBlock extends ContentBlockBase {
+  type: "text";
+  rendered: string;
+  content: string;
+}
+
+export interface MarkdownContentBlock extends ContentBlockBase {
+  type: "markdown";
+  rendered: string;
+  content: string;
+}
+
+export interface NotificationSource {
+  key: string;
+  version_id: string;
+}
+
+export type ContentBlock =
+  | MarkdownContentBlock
+  | TextContentBlock
+  | ButtonSetContentBlock;
+
+export interface FeedItem<T = GenericData> {
+  __cursor: string;
+  id: string;
+  activities: Activity<T>[];
+  actors: Recipient[];
+  blocks: ContentBlock[];
+  inserted_at: string;
+  updated_at: string;
+  read_at: string | null;
+  seen_at: string | null;
+  archived_at: string | null;
+  total_activities: number;
+  total_actors: number;
+  data: T | null;
+  source: NotificationSource;
+  tenant: string | null;
+}
+
+export interface FeedMetadata {
+  total_count: number;
+  unread_count: number;
+  unseen_count: number;
+}
+
+export interface FeedResponse {
+  entries: FeedItem[];
+  meta: FeedMetadata;
+  page_info: PageInfo;
+}

package/src/clients/feed/store.ts

@@ -0,0 +1,93 @@
+import create from "zustand/vanilla";
+
+import { NetworkStatus } from "../../networkStatus";
+
+import { FeedItem } from "./interfaces";
+import { FeedStoreState } from "./types";
+import { deduplicateItems, sortItems } from "./utils";
+
+function processItems(items: FeedItem[]) {
+  const deduped = deduplicateItems(items);
+  const sorted = sortItems(deduped);
+
+  return sorted;
+}
+
+const defaultSetResultOptions = {
+  shouldSetPage: true,
+  shouldAppend: false,
+};
+
+const initialStoreState = {
+  items: [],
+  metadata: {
+    total_count: 0,
+    unread_count: 0,
+    unseen_count: 0,
+  },
+  pageInfo: {
+    before: null,
+    after: null,
+    page_size: 50,
+  },
+};
+
+export default function createStore() {
+  return create<FeedStoreState>((set) => ({
+    // Keeps track of all of the items loaded
+    ...initialStoreState,
+    // The network status indicates what's happening with the request
+    networkStatus: NetworkStatus.ready,
+    loading: false,
+
+    setNetworkStatus: (networkStatus: NetworkStatus) =>
+      set(() => ({
+        networkStatus,
+        loading: networkStatus === NetworkStatus.loading,
+      })),
+
+    setResult: (
+      { entries, meta, page_info },
+      options = defaultSetResultOptions,
+    ) =>
+      set((state) => {
+        // We resort the list on set, so concating everything is fine (if a bit suboptimal)
+        const items = options.shouldAppend
+          ? processItems(state.items.concat(entries))
+          : entries;
+
+        return {
+          items,
+          metadata: meta,
+          pageInfo: options.shouldSetPage ? page_info : state.pageInfo,
+          loading: false,
+          networkStatus: NetworkStatus.ready,
+        };
+      }),
+
+    setMetadata: (metadata) => set(() => ({ metadata })),
+
+    resetStore: (metadata = initialStoreState.metadata) =>
+      set(() => ({ ...initialStoreState, metadata })),
+
+    setItemAttrs: (itemIds, attrs) => {
+      // Create a map for the items to the updates to be made
+      const itemUpdatesMap: { [id: string]: object } = itemIds.reduce(
+        (acc, itemId) => ({ ...acc, [itemId]: attrs }),
+        {},
+      );
+
+      return set((state) => {
+        const items = state.items.map((item) => {
+          if (itemUpdatesMap[item.id]) {
+            return { ...item, ...itemUpdatesMap[item.id] };
+          }
+
+          return item;
+        });
+
+        return { items };
+      });
+    },
+  }));
+}

package/src/clients/feed/types.ts

@@ -0,0 +1,64 @@
+import { PageInfo } from "@knocklabs/types";
+
+import { NetworkStatus } from "../../networkStatus";
+
+import { FeedItem, FeedMetadata, FeedResponse } from "./interfaces";
+
+export type StoreFeedResultOptions = {
+  shouldSetPage?: boolean;
+  shouldAppend?: boolean;
+};
+
+export type FeedStoreState = {
+  items: FeedItem[];
+  pageInfo: PageInfo;
+  metadata: FeedMetadata;
+  loading: boolean;
+  networkStatus: NetworkStatus;
+  setResult: (response: FeedResponse, opts?: StoreFeedResultOptions) => void;
+  setMetadata: (metadata: FeedMetadata) => void;
+  setNetworkStatus: (networkStatus: NetworkStatus) => void;
+  setItemAttrs: (itemIds: string[], attrs: object) => void;
+  resetStore: (metadata?: FeedMetadata) => void;
+};
+
+export type FeedMessagesReceivedPayload = {
+  metadata: FeedMetadata;
+};
+
+/*
+Event types:
+- `messages.new`: legacy event fired for all messages (feed items) received, real-time or not
+- `items.received.realtime`: all real-time items received via a socket update
+- `items.received.page`: invoked every time a page is fetched (like on initial load)
+*/
+export type FeedRealTimeEvent = "messages.new";
+
+export type FeedEvent =
+  | FeedRealTimeEvent
+  | "items.received.page"
+  | "items.received.realtime"
+  | "items.archived"
+  | "items.unarchived"
+  | "items.seen"
+  | "items.unseen"
+  | "items.read"
+  | "items.unread"
+  | "items.all_archived"
+  | "items.all_read"
+  | "items.all_seen";
+
+// Because we can bind to wild card feed events, this is here to accomodate whatever can be bound to
+export type BindableFeedEvent = FeedEvent | "items.received.*" | "items.*";
+
+export type FeedEventPayload = {
+  event: Omit<FeedEvent, "messages.new">;
+  items: FeedItem[];
+  metadata: FeedMetadata;
+};
+
+export type FeedRealTimeCallback = (resp: FeedResponse) => void;
+
+export type FeedEventCallback = (payload: FeedEventPayload) => void;
+
+export type FeedItemOrItems = FeedItem | FeedItem[];

package/src/clients/feed/utils.ts

@@ -0,0 +1,23 @@
+import { FeedItem } from "./interfaces";
+
+export function deduplicateItems(items: FeedItem[]): FeedItem[] {
+  const seen: Record<string, boolean> = {};
+  const values: FeedItem[] = [];
+
+  return items.reduce((acc, item) => {
+    if (seen[item.id]) {
+      return acc;
+    }
+
+    seen[item.id] = true;
+    return [...acc, item];
+  }, values);
+}
+
+export function sortItems(items: FeedItem[]) {
+  return items.sort((a, b) => {
+    return (
+      new Date(b.inserted_at).getTime() - new Date(a.inserted_at).getTime()
+    );
+  });
+}

package/src/clients/objects/constants.ts

@@ -0,0 +1 @@
+export const TENANT_OBJECT_COLLECTION = "$tenants";

package/src/clients/objects/index.ts

@@ -0,0 +1,61 @@
+import { ApiResponse } from "../../api";
+import { ChannelData } from "../../interfaces";
+import Knock from "../../knock";
+
+type GetChannelDataInput = {
+  objectId: string;
+  collection: string;
+  channelId: string;
+};
+
+type SetChannelDataInput = {
+  objectId: string;
+  collection: string;
+  channelId: string;
+  data: any;
+};
+
+class ObjectClient {
+  private instance: Knock;
+
+  constructor(instance: Knock) {
+    this.instance = instance;
+  }
+  async getChannelData<T = any>({
+    collection,
+    objectId,
+    channelId,
+  }: GetChannelDataInput) {
+    const result = await this.instance.client().makeRequest({
+      method: "GET",
+      url: `/v1/objects/${collection}/${objectId}/channel_data/${channelId}`,
+    });
+
+    return this.handleResponse<ChannelData<T>>(result);
+  }
+
+  async setChannelData({
+    objectId,
+    collection,
+    channelId,
+    data,
+  }: SetChannelDataInput) {
+    const result = await this.instance.client().makeRequest({
+      method: "PUT",
+      url: `v1/objects/${collection}/${objectId}/channel_data/${channelId}`,
+      data: { data },
+    });
+
+    return this.handleResponse(result);
+  }
+
+  private handleResponse<T>(response: ApiResponse) {
+    if (response.statusCode === "error") {
+      throw new Error(response.error || response.body);
+    }
+
+    return response.body as T;
+  }
+}
+
+export default ObjectClient;

package/src/clients/preferences/index.ts

@@ -0,0 +1,196 @@
+import { ChannelType } from "@knocklabs/types";
+import { ApiResponse } from "../../api";
+import Knock from "../../knock";
+import {
+  ChannelTypePreferences,
+  PreferenceOptions,
+  SetPreferencesProperties,
+  WorkflowPreferenceSetting,
+  WorkflowPreferences,
+  PreferenceSet,
+} from "./interfaces";
+
+const DEFAULT_PREFERENCE_SET_ID = "default";
+
+function buildUpdateParam(param: WorkflowPreferenceSetting) {
+  if (typeof param === "object") {
+    return param;
+  }
+
+  return { subscribed: param };
+}
+
+class Preferences {
+  private instance: Knock;
+
+  constructor(instance: Knock) {
+    this.instance = instance;
+  }
+
+  /**
+   * @deprecated Use `user.getAllPreferences()` instead
+   */
+  async getAll() {
+    const result = await this.instance.client().makeRequest({
+      method: "GET",
+      url: `/v1/users/${this.instance.userId}/preferences`,
+    });
+
+    return this.handleResponse(result);
+  }
+
+  /**
+   * @deprecated Use `user.getPreferences()` instead
+   */
+  async get(options: PreferenceOptions = {}) {
+    const preferenceSetId = options.preferenceSet || DEFAULT_PREFERENCE_SET_ID;
+
+    const result = await this.instance.client().makeRequest({
+      method: "GET",
+      url: `/v1/users/${this.instance.userId}/preferences/${preferenceSetId}`,
+    });
+
+    return this.handleResponse(result);
+  }
+
+  /**
+   * @deprecated Use `user.setPreferences(preferenceSet, options)` instead
+   */
+  async set(
+    preferenceSet: SetPreferencesProperties,
+    options: PreferenceOptions = {},
+  ) {
+    const preferenceSetId = options.preferenceSet || DEFAULT_PREFERENCE_SET_ID;
+
+    const result = await this.instance.client().makeRequest({
+      method: "PUT",
+      url: `/v1/users/${this.instance.userId}/preferences/${preferenceSetId}`,
+      data: preferenceSet,
+    });
+
+    return this.handleResponse(result);
+  }
+
+  /**
+   * @deprecated Use `user.setPreferences(preferenceSet, options)` instead
+   */
+  async setChannelTypes(
+    channelTypePreferences: ChannelTypePreferences,
+    options: PreferenceOptions = {},
+  ) {
+    const preferenceSetId = options.preferenceSet || DEFAULT_PREFERENCE_SET_ID;
+
+    const result = await this.instance.client().makeRequest({
+      method: "PUT",
+      url: `/v1/users/${this.instance.userId}/preferences/${preferenceSetId}/channel_types`,
+      data: channelTypePreferences,
+    });
+
+    return this.handleResponse(result);
+  }
+
+  /**
+   * @deprecated Use `user.setPreferences(preferenceSet, options)` instead
+   */
+  async setChannelType(
+    channelType: ChannelType,
+    setting: boolean,
+    options: PreferenceOptions = {},
+  ) {
+    const preferenceSetId = options.preferenceSet || DEFAULT_PREFERENCE_SET_ID;
+
+    const result = await this.instance.client().makeRequest({
+      method: "PUT",
+      url: `/v1/users/${this.instance.userId}/preferences/${preferenceSetId}/channel_types/${channelType}`,
+      data: { subscribed: setting },
+    });
+
+    return this.handleResponse(result);
+  }
+
+  /**
+   * @deprecated Use `user.setPreferences(preferenceSet, options)` instead
+   */
+  async setWorkflows(
+    workflowPreferences: WorkflowPreferences,
+    options: PreferenceOptions = {},
+  ) {
+    const preferenceSetId = options.preferenceSet || DEFAULT_PREFERENCE_SET_ID;
+
+    const result = await this.instance.client().makeRequest({
+      method: "PUT",
+      url: `/v1/users/${this.instance.userId}/preferences/${preferenceSetId}/workflows`,
+      data: workflowPreferences,
+    });
+
+    return this.handleResponse(result);
+  }
+
+  /**
+   * @deprecated Use `user.setPreferences(preferenceSet, options)` instead
+   */
+  async setWorkflow(
+    workflowKey: string,
+    setting: WorkflowPreferenceSetting,
+    options: PreferenceOptions = {},
+  ) {
+    const preferenceSetId = options.preferenceSet || DEFAULT_PREFERENCE_SET_ID;
+    const params = buildUpdateParam(setting);
+
+    const result = await this.instance.client().makeRequest({
+      method: "PUT",
+      url: `/v1/users/${this.instance.userId}/preferences/${preferenceSetId}/workflows/${workflowKey}`,
+      data: params,
+    });
+
+    return this.handleResponse(result);
+  }
+
+  /**
+   * @deprecated Use `user.setPreferences(preferenceSet, options)` instead
+   */
+  async setCategories(
+    categoryPreferences: WorkflowPreferences,
+    options: PreferenceOptions = {},
+  ) {
+    const preferenceSetId = options.preferenceSet || DEFAULT_PREFERENCE_SET_ID;
+
+    const result = await this.instance.client().makeRequest({
+      method: "PUT",
+      url: `/v1/users/${this.instance.userId}/preferences/${preferenceSetId}/categories`,
+      data: categoryPreferences,
+    });
+
+    return this.handleResponse(result);
+  }
+
+  /**
+   * @deprecated Use `user.setPreferences(preferenceSet, options)` instead
+   */
+  async setCategory(
+    categoryKey: string,
+    setting: WorkflowPreferenceSetting,
+    options: PreferenceOptions = {},
+  ) {
+    const preferenceSetId = options.preferenceSet || DEFAULT_PREFERENCE_SET_ID;
+    const params = buildUpdateParam(setting);
+
+    const result = await this.instance.client().makeRequest({
+      method: "PUT",
+      url: `/v1/users/${this.instance.userId}/preferences/${preferenceSetId}/categories/${categoryKey}`,
+      data: params,
+    });
+
+    return this.handleResponse(result);
+  }
+
+  private handleResponse(response: ApiResponse) {
+    if (response.statusCode === "error") {
+      throw new Error(response.error || response.body);
+    }
+
+    return response.body as PreferenceSet;
+  }
+}
+
+export default Preferences;

package/src/clients/preferences/interfaces.ts

@@ -0,0 +1,34 @@
+import { ChannelType } from "@knocklabs/types";
+
+export type ChannelTypePreferences = {
+  [K in ChannelType]?: boolean;
+};
+
+export type WorkflowPreferenceSetting =
+  | boolean
+  | { channel_types: ChannelTypePreferences };
+
+export type WorkflowPreferences = Partial<
+  Record<string, WorkflowPreferenceSetting>
+>;
+
+export interface SetPreferencesProperties {
+  workflows: WorkflowPreferences;
+  categories: WorkflowPreferences;
+  channel_types: ChannelTypePreferences;
+}
+
+export interface PreferenceSet {
+  id: string;
+  categories: WorkflowPreferences;
+  workflows: WorkflowPreferences;
+  channel_types: ChannelTypePreferences;
+}
+
+export interface PreferenceOptions {
+  preferenceSet?: string;
+}
+
+export interface GetPreferencesOptions extends PreferenceOptions {
+  tenant?: string;
+}