@knocklabs/client 0.9.2 → 0.9.3

package/src/clients/slack/index.ts

@@ -0,0 +1,89 @@
+import { ApiResponse } from "../../api";
+import Knock from "../../knock";
+
+import {
+  AuthCheckInput,
+  GetSlackChannelsInput,
+  RevokeAccessTokenInput,
+} from "./interfaces";
+
+const TENANT_COLLECTION = "$tenants";
+
+class SlackClient {
+  private instance: Knock;
+
+  constructor(instance: Knock) {
+    this.instance = instance;
+  }
+
+  async authCheck({ tenant, knockChannelId }: AuthCheckInput) {
+    const result = await this.instance.client().makeRequest({
+      method: "GET",
+      url: `/v1/providers/slack/${knockChannelId}/auth_check`,
+      params: {
+        access_token_object: {
+          object_id: tenant,
+          collection: TENANT_COLLECTION,
+        },
+        channel_id: knockChannelId,
+      },
+    });
+
+    return this.handleResponse(result);
+  }
+
+  async getChannels(input: GetSlackChannelsInput) {
+    const { knockChannelId, tenant } = input;
+    const queryOptions = input.queryOptions || {};
+
+    const result = await this.instance.client().makeRequest({
+      method: "GET",
+      url: `/v1/providers/slack/${knockChannelId}/channels`,
+      params: {
+        access_token_object: {
+          object_id: tenant,
+          collection: TENANT_COLLECTION,
+        },
+        channel_id: knockChannelId,
+        query_options: {
+          cursor: queryOptions.cursor,
+          limit: queryOptions.limit,
+          exclude_archived: queryOptions.excludeArchived,
+          team_id: queryOptions.teamId,
+          types: queryOptions.types,
+        },
+      },
+    });
+
+    return this.handleResponse(result);
+  }
+
+  async revokeAccessToken({ tenant, knockChannelId }: RevokeAccessTokenInput) {
+    const result = await this.instance.client().makeRequest({
+      method: "PUT",
+      url: `/v1/providers/slack/${knockChannelId}/revoke_access`,
+      params: {
+        access_token_object: {
+          object_id: tenant,
+          collection: TENANT_COLLECTION,
+        },
+        channel_id: knockChannelId,
+      },
+    });
+
+    return this.handleResponse(result);
+  }
+
+  private handleResponse(response: ApiResponse) {
+    if (response.statusCode === "error") {
+      if (response.error?.response?.status < 500) {
+        return response.error || response.body;
+      }
+      throw new Error(response.error || response.body);
+    }
+
+    return response.body;
+  }
+}
+
+export default SlackClient;

package/src/clients/slack/interfaces.ts

@@ -0,0 +1,36 @@
+export type SlackChannelConnection = {
+  access_token?: string;
+  channel_id?: string;
+  incoming_webhook?: string;
+  user_id?: null;
+};
+
+export type GetSlackChannelsInput = {
+  tenant: string;
+  knockChannelId: string;
+  queryOptions?: {
+    limit?: number;
+    cursor?: string;
+    excludeArchived?: boolean;
+    teamId?: string;
+    types?: string;
+  };
+};
+
+export type AuthCheckInput = {
+  tenant: string;
+  knockChannelId: string;
+};
+
+export type RevokeAccessTokenInput = {
+  tenant: string;
+  knockChannelId: string;
+};
+
+export type SlackChannel = {
+  name: string;
+  id: string;
+  is_private: boolean;
+  is_im: boolean;
+  context_team_id: boolean;
+};

package/src/clients/users/index.ts

@@ -0,0 +1,90 @@
+import { ApiResponse } from "../../api";
+import { ChannelData } from "../../interfaces";
+import Knock from "../../knock";
+import {
+  GetPreferencesOptions,
+  PreferenceOptions,
+  PreferenceSet,
+  SetPreferencesProperties,
+} from "../preferences/interfaces";
+import { GetChannelDataInput, SetChannelDataInput } from "./interfaces";
+
+const DEFAULT_PREFERENCE_SET_ID = "default";
+
+class UserClient {
+  private instance: Knock;
+
+  constructor(instance: Knock) {
+    this.instance = instance;
+  }
+
+  async getAllPreferences() {
+    const result = await this.instance.client().makeRequest({
+      method: "GET",
+      url: `/v1/users/${this.instance.userId}/preferences`,
+    });
+
+    return this.handleResponse<PreferenceSet[]>(result);
+  }
+
+  async getPreferences(
+    options: GetPreferencesOptions = {},
+  ): Promise<PreferenceSet> {
+    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}`,
+      params: { tenant: options.tenant },
+    });
+
+    return this.handleResponse<PreferenceSet>(result);
+  }
+
+  async setPreferences(
+    preferenceSet: SetPreferencesProperties,
+    options: PreferenceOptions = {},
+  ): Promise<PreferenceSet> {
+    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<PreferenceSet>(result);
+  }
+
+  async getChannelData<T = any>(params: GetChannelDataInput) {
+    const result = await this.instance.client().makeRequest({
+      method: "GET",
+      url: `/v1/users/${this.instance.userId}/channel_data/${params.channelId}`,
+    });
+
+    return this.handleResponse<ChannelData<T>>(result);
+  }
+
+  async setChannelData<T = any>({
+    channelId,
+    channelData,
+  }: SetChannelDataInput) {
+    const result = await this.instance.client().makeRequest({
+      method: "PUT",
+      url: `/v1/users/${this.instance.userId}/channel_data/${channelId}`,
+      data: { data: channelData },
+    });
+
+    return this.handleResponse<ChannelData<T>>(result);
+  }
+
+  private handleResponse<T>(response: ApiResponse) {
+    if (response.statusCode === "error") {
+      throw new Error(response.error || response.body);
+    }
+
+    return response.body as T;
+  }
+}
+
+export default UserClient;

package/src/clients/users/interfaces.ts

@@ -0,0 +1,8 @@
+export interface SetChannelDataInput {
+  channelId: string;
+  channelData: Record<string, any>;
+}
+
+export interface GetChannelDataInput {
+  channelId: string;
+}

package/src/index.ts

@@ -0,0 +1,16 @@
+import FeedClient, { Feed } from "./clients/feed";
+import Knock from "./knock";
+
+export * from "./interfaces";
+export * from "./clients/feed/types";
+export * from "./clients/feed/interfaces";
+export * from "./clients/objects";
+export * from "./clients/objects/constants";
+export * from "./clients/preferences/interfaces";
+export * from "./clients/slack";
+export * from "./clients/slack/interfaces";
+export * from "./clients/users";
+export * from "./networkStatus";
+
+export default Knock;
+export { Feed, FeedClient };

package/src/interfaces.ts

@@ -0,0 +1,52 @@
+import { GenericData } from "@knocklabs/types";
+
+export type LogLevel = "debug";
+
+export interface KnockOptions {
+  host?: string;
+  logLevel?: LogLevel;
+}
+
+export interface KnockObject<T = GenericData> {
+  id: string;
+  collection: string;
+  properties: T;
+  updated_at: string;
+  created_at: string | null;
+}
+
+export interface User extends GenericData {
+  id: string;
+  email: string | null;
+  name: string | null;
+  phone_number: string | null;
+  avatar: string | null;
+  updated_at: string;
+  created_at: string | null;
+}
+
+export type Recipient = User | KnockObject;
+
+export interface Activity<T = GenericData> {
+  id: string;
+  inserted_at: string;
+  updated_at: string;
+  recipient: Recipient;
+  actor: Recipient | null;
+  data: T | null;
+}
+
+export interface ChannelData<T = any> {
+  channel_id: string;
+  data: T;
+}
+
+export type UserTokenExpiringCallback = (
+  currentToken: string,
+  decodedToken: any,
+) => Promise<string | void>;
+
+export interface AuthenticateOptions {
+  onUserTokenExpiring?: UserTokenExpiringCallback;
+  timeBeforeExpirationInMs?: number;
+}

package/src/knock.ts

@@ -0,0 +1,182 @@
+import { jwtDecode } from "jwt-decode";
+
+import ApiClient from "./api";
+import FeedClient from "./clients/feed";
+import ObjectClient from "./clients/objects";
+import Preferences from "./clients/preferences";
+import SlackClient from "./clients/slack";
+import UserClient from "./clients/users";
+import {
+  AuthenticateOptions,
+  KnockOptions,
+  LogLevel,
+  UserTokenExpiringCallback,
+} from "./interfaces";
+
+const DEFAULT_HOST = "https://api.knock.app";
+
+class Knock {
+  public host: string;
+  private apiClient: ApiClient | null = null;
+  public userId: string | undefined;
+  public userToken?: string;
+  public logLevel?: LogLevel;
+  private tokenExpirationTimer: ReturnType<typeof setTimeout> | null = null;
+  readonly feeds = new FeedClient(this);
+  readonly objects = new ObjectClient(this);
+  readonly preferences = new Preferences(this);
+  readonly slack = new SlackClient(this);
+  readonly user = new UserClient(this);
+
+  constructor(
+    readonly apiKey: string,
+    options: KnockOptions = {},
+  ) {
+    this.host = options.host || DEFAULT_HOST;
+    this.logLevel = options.logLevel;
+
+    this.log("Initialized Knock instance");
+
+    // Fail loudly if we're using the wrong API key
+    if (this.apiKey && this.apiKey.startsWith("sk_")) {
+      throw new Error(
+        "[Knock] You are using your secret API key on the client. Please use the public key.",
+      );
+    }
+  }
+
+  client() {
+    if (!this.userId) {
+      console.warn(
+        `[Knock] You must call authenticate(userId, userToken) first before trying to make a request.
+        Typically you'll see this message when you're creating a feed instance before having called
+        authenticate with a user Id and token. That means we won't know who to issue the request
+        to Knock on behalf of.
+        `,
+      );
+    }
+
+    // Initiate a new API client if we don't have one yet
+    if (!this.apiClient) {
+      this.apiClient = this.createApiClient();
+    }
+
+    return this.apiClient;
+  }
+
+  /*
+    Authenticates the current user. In non-sandbox environments
+    the userToken must be specified.
+  */
+  authenticate(
+    userId: string,
+    userToken?: string,
+    options?: AuthenticateOptions,
+  ) {
+    let reinitializeApi = false;
+    const currentApiClient = this.apiClient;
+
+    // If we've previously been initialized and the values have now changed, then we
+    // need to reinitialize any stateful connections we have
+    if (
+      currentApiClient &&
+      (this.userId !== userId || this.userToken !== userToken)
+    ) {
+      this.log("userId or userToken changed; reinitializing connections");
+      this.feeds.teardownInstances();
+      this.teardown();
+      reinitializeApi = true;
+    }
+
+    this.userId = userId;
+    this.userToken = userToken;
+
+    this.log(`Authenticated with userId ${userId}`);
+
+    if (this.userToken && options?.onUserTokenExpiring instanceof Function) {
+      this.maybeScheduleUserTokenExpiration(
+        options.onUserTokenExpiring,
+        options.timeBeforeExpirationInMs,
+      );
+    }
+
+    // If we get the signal to reinitialize the api client, then we want to create a new client
+    // and the reinitialize any existing feed real-time connections we have so everything continues
+    // to work with the new credentials we've been given
+    if (reinitializeApi) {
+      this.apiClient = this.createApiClient();
+      this.feeds.reinitializeInstances();
+      this.log("Reinitialized real-time connections");
+    }
+
+    return;
+  }
+
+  /*
+    Returns whether or this Knock instance is authenticated. Passing `true` will check the presence
+    of the userToken as well.
+  */
+  isAuthenticated(checkUserToken = false) {
+    return checkUserToken ? !!(this.userId && this.userToken) : !!this.userId;
+  }
+
+  // Used to teardown any connected instances
+  teardown() {
+    if (this.tokenExpirationTimer) {
+      clearTimeout(this.tokenExpirationTimer);
+    }
+    if (this.apiClient?.socket && this.apiClient.socket.isConnected()) {
+      this.apiClient.socket.disconnect();
+    }
+  }
+
+  log(message: string) {
+    if (this.logLevel === "debug") {
+      console.log(`[Knock] ${message}`);
+    }
+  }
+
+  /**
+   * Initiates an API client
+   */
+  private createApiClient() {
+    return new ApiClient({
+      apiKey: this.apiKey,
+      host: this.host,
+      userToken: this.userToken,
+    });
+  }
+
+  private async maybeScheduleUserTokenExpiration(
+    callbackFn: UserTokenExpiringCallback,
+    timeBeforeExpirationInMs: number = 30_000,
+  ) {
+    if (!this.userToken) return;
+
+    const decoded = jwtDecode(this.userToken);
+    const expiresAtMs = (decoded.exp ?? 0) * 1000;
+    const nowMs = Date.now();
+
+    // Expiration is in the future
+    if (expiresAtMs && expiresAtMs > nowMs) {
+      // Check how long until the token should be regenerated
+      // | ----------------- | ----------------------- |
+      // ^ now               ^ expiration offset       ^ expires at
+      const msInFuture = expiresAtMs - timeBeforeExpirationInMs - nowMs;
+
+      this.tokenExpirationTimer = setTimeout(async () => {
+        const newToken = await callbackFn(this.userToken as string, decoded);
+
+        // Reauthenticate which will handle reinitializing sockets
+        if (typeof newToken === "string") {
+          this.authenticate(this.userId!, newToken, {
+            onUserTokenExpiring: callbackFn,
+            timeBeforeExpirationInMs: timeBeforeExpirationInMs,
+          });
+        }
+      }, msInFuture);
+    }
+  }
+}
+
+export default Knock;

package/src/networkStatus.ts

@@ -0,0 +1,19 @@
+export enum NetworkStatus {
+  // Performing a top level loading operation
+  loading = "loading",
+
+  // Performing a fetch more on some already loaded data
+  fetchMore = "fetchMore",
+
+  // No operation is currently in progress
+  ready = "ready",
+
+  // The last operation failed with an error
+  error = "error",
+}
+
+export function isRequestInFlight(networkStatus: NetworkStatus): boolean {
+  return [NetworkStatus.loading, NetworkStatus.fetchMore].includes(
+    networkStatus,
+  );
+}