@knocklabs/node 0.2.2 → 0.4.0

package/README.md

@@ -61,6 +61,8 @@ await knockClient.notify("dinosaurs-loose", {
     type: "trex",
     priority: 1,
   },
+  // an optional identifier for the tenant that the notifications belong to
+  tenant: "jurassic-park",
   // an optional key to provide to cancel a notify
   cancellationKey: triggerAlert.id,
 });
@@ -91,7 +93,7 @@ const { Knock } = require("@knocklabs/node");
 const knockClient = new Knock("sk_12345");
 
 // Set an entire preference set
-await knockClient.preferences.set("jhammond", {
+await knockClient.users.setPreferences("jhammond", {
   channel_types: { email: true, sms: false },
   workflows: {
     "dinosaurs-loose": {
@@ -101,21 +103,25 @@ await knockClient.preferences.set("jhammond", {
 });
 
 // Retrieve a whole preference set
-const preferences = await knockClient.preferences.get("jhammond");
+const preferences = await knockClient.users.getPreferences("jhammond");
+```
 
-// Granular preference setting for channel types
-await knockClient.preferences.setChannelType("jhammond", "email", false);
+### Getting and setting channel data
 
-// Granular preference setting for workflows
-await knockClient.preferences.setWorkflow("jhammond", "dinosaurs-loose", {
-  channel_types: {
-    email: true,
-    in_app_feed: false,
-  },
+```javascript
+const { Knock } = require("@knocklabs/node");
+const knockClient = new Knock("sk_12345");
+
+// Setting channel data for an APNS
+await knockClient.users.setChannelData("jhammond", KNOCK_APNS_CHANNEL_ID, {
+  tokens: [apnsToken],
 });
+
+// Getting channel data for the APNS channel
+await knockClient.users.getChannelData("jhammond", KNOCK_APNS_CHANNEL_ID);
 ```
 
-### Cancelling workflows
+### Canceling workflows
 
 ```javascript
 const { Knock } = require("@knocklabs/node");
@@ -133,7 +139,7 @@ You can use the `jsonwebtoken` package to [sign JWTs easily](https://www.npmjs.c
 You will need to generate an environment specific signing key, which you can find in the Knock dashboard.
 
 If you're using a signing token you will need to pass this to your client to perform authentication.
-You can read more about [clientside authentication here](https://docs.knock.app/client-integration/authenticating-users).
+You can read more about [client-side authentication here](https://docs.knock.app/client-integration/authenticating-users).
 
 ```javascript
 const jwt = require("jsonwebtoken");

package/dist/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@knocklabs/node",
-    "version": "0.2.2",
+    "version": "0.4.0",
     "description": "Library for interacting with the Knock API",
     "homepage": "https://github.com/knocklabs/knock-node",
     "author": "@knocklabs",

package/dist/src/common/interfaces.d.ts

@@ -15,3 +15,11 @@ export interface UnprocessableEntityError {
     type: string;
     field: string;
 }
+export declare type ChannelType = "email" | "in_app_feed" | "sms" | "push" | "chat";
+export declare type CommonMetadata = Record<string, any>;
+export interface ChannelData<T = CommonMetadata> {
+    channel_id: string;
+    data: T;
+}
+export interface SetChannelDataProperties {
+}

package/dist/src/knock.d.ts

@@ -1,9 +1,11 @@
-import { AxiosError, AxiosResponse } from "axios";
+import { AxiosResponse } from "axios";
 import { KnockOptions, PostAndPutOptions } from "./common/interfaces";
 import { Users } from "./resources/users";
 import { Preferences } from "./resources/preferences";
 import { Workflows } from "./resources/workflows";
 import { TriggerWorkflowProperties } from "./resources/workflows/interfaces";
+import { BulkOperations } from "./resources/bulk_operations";
+import { Objects } from "./resources/objects";
 declare class Knock {
     readonly key?: string | undefined;
     readonly options: KnockOptions;
@@ -12,13 +14,15 @@ declare class Knock {
     readonly users: Users;
     readonly preferences: Preferences;
     readonly workflows: Workflows;
+    readonly bulkOperations: BulkOperations;
+    readonly objects: Objects;
     constructor(key?: string | undefined, options?: KnockOptions);
     notify(workflowKey: string, properties: TriggerWorkflowProperties): Promise<import("./resources/workflows/interfaces").WorkflowRun>;
     post(path: string, entity: any, options?: PostAndPutOptions): Promise<AxiosResponse>;
     put(path: string, entity: any, options?: PostAndPutOptions): Promise<AxiosResponse>;
     delete(path: string, entity?: any): Promise<AxiosResponse>;
     get(path: string, query?: any): Promise<AxiosResponse>;
-    handleErrorResponse(path: string, { response }: AxiosError): void;
+    handleErrorResponse(path: string, error: any): void;
     emitWarning(warning: string): void;
 }
 export { Knock };

package/dist/src/knock.js

@@ -19,14 +19,19 @@ const exceptions_1 = require("./common/exceptions");
 const users_1 = require("./resources/users");
 const preferences_1 = require("./resources/preferences");
 const workflows_1 = require("./resources/workflows");
+const bulk_operations_1 = require("./resources/bulk_operations");
+const objects_1 = require("./resources/objects");
 const DEFAULT_HOSTNAME = "https://api.knock.app";
 class Knock {
     constructor(key, options = {}) {
         this.key = key;
         this.options = options;
+        // Service accessors
         this.users = new users_1.Users(this);
         this.preferences = new preferences_1.Preferences(this);
         this.workflows = new workflows_1.Workflows(this);
+        this.bulkOperations = new bulk_operations_1.BulkOperations(this);
+        this.objects = new objects_1.Objects(this);
         if (!key) {
             this.key = process.env.KNOCK_API_KEY;
             if (!this.key) {
@@ -100,9 +105,9 @@ class Knock {
             }
         });
     }
-    handleErrorResponse(path, { response }) {
-        if (response) {
-            const { status, data, headers } = response;
+    handleErrorResponse(path, error) {
+        if (axios_1.default.isAxiosError(error) && error.response) {
+            const { status, data, headers } = error.response;
             const requestID = headers["X-Request-ID"];
             switch (status) {
                 case 401: {

package/dist/src/resources/bulk_operations/index.d.ts

@@ -0,0 +1,7 @@
+import { Knock } from "../../knock";
+import { BulkOperation } from "../bulk_operations/interfaces";
+export declare class BulkOperations {
+    readonly knock: Knock;
+    constructor(knock: Knock);
+    get(id: string): Promise<BulkOperation>;
+}

package/dist/src/resources/{identify → bulk_operations}/index.js

@@ -9,14 +9,16 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.identify = void 0;
-function identify(knock) {
-    return (userId, properties = {}) => __awaiter(this, void 0, void 0, function* () {
-        if (!userId) {
-            throw new Error(`Incomplete arguments. At a minimum you need to specify 'userId'.`);
-        }
-        const { data } = yield knock.put(`/v1/users/${userId}`, properties);
-        return data;
-    });
+exports.BulkOperations = void 0;
+class BulkOperations {
+    constructor(knock) {
+        this.knock = knock;
+    }
+    get(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.knock.get(`/v1/bulk_operations/${id}`);
+            return data;
+        });
+    }
 }
-exports.identify = identify;
+exports.BulkOperations = BulkOperations;

package/dist/src/resources/bulk_operations/interfaces.d.ts

@@ -0,0 +1,12 @@
+export interface BulkOperation {
+    id: string;
+    name: string;
+    status: "queued" | "processing" | "completed" | "failed";
+    processed_rows: number;
+    estimated_total_rows: number;
+    started_at?: string;
+    completed_at?: string;
+    failed_at?: string;
+    inserted_at: string;
+    updated_at: string;
+}

package/dist/src/resources/objects/index.d.ts

@@ -0,0 +1,15 @@
+import { ChannelData, CommonMetadata, SetChannelDataProperties } from "../../common/interfaces";
+import { Knock } from "../../knock";
+import { BulkSetObjectOption, Object, SetObjectProperties } from "./interfaces";
+import { BulkOperation } from "../bulk_operations/interfaces";
+export declare class Objects {
+    readonly knock: Knock;
+    constructor(knock: Knock);
+    get<T = CommonMetadata>(collection: string, id: string): Promise<Object<T>>;
+    set<T = CommonMetadata>(collection: string, id: string, properties: SetObjectProperties): Promise<Object<T>>;
+    bulkSet(collection: string, objects: BulkSetObjectOption[]): Promise<BulkOperation>;
+    delete(collection: string, id: string): Promise<null>;
+    bulkDelete(collection: string, objectIds: string[]): Promise<BulkOperation>;
+    getChannelData<T = CommonMetadata>(collection: string, id: string, channelId: string): Promise<ChannelData<T>>;
+    setChannelData<T = CommonMetadata>(collection: string, id: string, channelId: string, channelData: SetChannelDataProperties): Promise<ChannelData<T>>;
+}

package/dist/src/resources/objects/index.js

@@ -0,0 +1,66 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Objects = void 0;
+class Objects {
+    constructor(knock) {
+        this.knock = knock;
+    }
+    get(collection, id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.knock.get(`/v1/objects/${collection}/${id}`);
+            return data;
+        });
+    }
+    set(collection, id, properties) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.knock.put(`/v1/objects/${collection}/${id}`, properties);
+            return data;
+        });
+    }
+    bulkSet(collection, objects) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const attrs = { objects };
+            const { data } = yield this.knock.post(`/v1/objects/${collection}/bulk/set`, attrs);
+            return data;
+        });
+    }
+    delete(collection, id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.knock.delete(`/v1/objects/${collection}/${id}`);
+            return data;
+        });
+    }
+    bulkDelete(collection, objectIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const attrs = {
+                object_ids: objectIds,
+            };
+            const { data } = yield this.knock.post(`/v1/objects/${collection}/bulk/delete`, attrs);
+            return data;
+        });
+    }
+    // Channel data
+    getChannelData(collection, id, channelId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.knock.get(`/v1/objects/${collection}/${id}/channel_data/${channelId}`);
+            return data;
+        });
+    }
+    setChannelData(collection, id, channelId, channelData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const attrs = { data: channelData };
+            const { data } = yield this.knock.put(`/v1/objects/${collection}/${id}/channel_data/${channelId}`, attrs);
+            return data;
+        });
+    }
+}
+exports.Objects = Objects;

package/dist/src/resources/objects/interfaces.d.ts

@@ -0,0 +1,21 @@
+import { CommonMetadata } from "../../common/interfaces";
+export interface ObjectRef {
+    collection: string;
+    id: string;
+}
+export interface Object<T = CommonMetadata> {
+    id: string;
+    collection: string;
+    properties: T;
+    created_at?: string;
+    updated_at: string;
+}
+export interface SetObjectProperties {
+    name?: string;
+    [key: string]: any;
+}
+export interface BulkSetObjectOption {
+    id: string;
+    name?: string;
+    [key: string]: any;
+}

package/dist/src/resources/preferences/helpers.d.ts

@@ -0,0 +1,7 @@
+import { WorkflowPreferenceSetting } from "./interfaces";
+export declare function buildUpdateParam(param: WorkflowPreferenceSetting): {
+    channel_types: import("./interfaces").ChannelTypePreferences;
+} | {
+    subscribed: boolean;
+};
+export declare const DEFAULT_PREFERENCE_SET_ID = "default";

package/dist/src/resources/preferences/helpers.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_PREFERENCE_SET_ID = exports.buildUpdateParam = void 0;
+function buildUpdateParam(param) {
+    if (typeof param === "object") {
+        return param;
+    }
+    return { subscribed: param };
+}
+exports.buildUpdateParam = buildUpdateParam;
+exports.DEFAULT_PREFERENCE_SET_ID = "default";

package/dist/src/resources/preferences/index.d.ts

@@ -1,15 +1,43 @@
+import { ChannelType } from "../../common/interfaces";
 import { Knock } from "../../knock";
-import { ChannelType, ChannelTypePreferences, WorkflowPreferenceSetting, WorkflowPreferences, PreferenceOptions, SetPreferencesProperties, PreferenceSet } from "./interfaces";
+import { ChannelTypePreferences, WorkflowPreferenceSetting, WorkflowPreferences, PreferenceOptions, SetPreferencesProperties, PreferenceSet } from "./interfaces";
 export declare class Preferences {
     readonly knock: Knock;
     constructor(knock: Knock);
+    /**
+     * @deprecated Use `users.getAllPreferences` instead
+     */
     getAll(userId: string): Promise<PreferenceSet[]>;
+    /**
+     * @deprecated Use `users.getPreferences` instead
+     */
     get(userId: string, options?: PreferenceOptions): Promise<PreferenceSet>;
+    /**
+     * @deprecated Use `users.setPreferences` instead
+     */
     set(userId: string, preferenceSet: SetPreferencesProperties, options?: PreferenceOptions): Promise<PreferenceSet>;
+    /**
+     * @deprecated Use `users.setChannelTypesPreferences` instead
+     */
     setChannelTypes(userId: string, channelTypePreferences: ChannelTypePreferences, options?: PreferenceOptions): Promise<PreferenceSet>;
+    /**
+     * @deprecated Use `users.setChannelTypePreferences` instead
+     */
     setChannelType(userId: string, channelType: ChannelType, setting: boolean, options?: PreferenceOptions): Promise<PreferenceSet>;
+    /**
+     * @deprecated Use `users.setWorkflowsPreferences` instead
+     */
     setWorkflows(userId: string, workflowPreferences: WorkflowPreferences, options?: PreferenceOptions): Promise<PreferenceSet>;
+    /**
+     * @deprecated Use `users.setWorkflowPreferences` instead
+     */
     setWorkflow(userId: string, workflowKey: string, setting: WorkflowPreferenceSetting, options?: PreferenceOptions): Promise<PreferenceSet>;
+    /**
+     * @deprecated Use `users.setCategoriesPreferences` instead
+     */
     setCategories(userId: string, categoryPreferences: WorkflowPreferences, options?: PreferenceOptions): Promise<PreferenceSet>;
+    /**
+     * @deprecated Use `users.setCategoryPreferences` instead
+     */
     setCategory(userId: string, categoryKey: string, setting: WorkflowPreferenceSetting, options?: PreferenceOptions): Promise<PreferenceSet>;
 }

package/dist/src/resources/preferences/index.js

@@ -10,77 +10,81 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Preferences = void 0;
-const DEFAULT_PREFERENCE_SET_ID = "default";
-function buildUpdateParam(param) {
-    if (typeof param === "object") {
-        return param;
-    }
-    return { subscribed: param };
-}
+// Deprecated all of the methods in this to be removed in `0.5.0`
 class Preferences {
     constructor(knock) {
         this.knock = knock;
     }
+    /**
+     * @deprecated Use `users.getAllPreferences` instead
+     */
     getAll(userId) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { data } = yield this.knock.get(`/v1/users/${userId}/preferences`);
-            return data;
+            return this.knock.users.getAllPreferences(userId);
         });
     }
+    /**
+     * @deprecated Use `users.getPreferences` instead
+     */
     get(userId, options = {}) {
         return __awaiter(this, void 0, void 0, function* () {
-            const preferenceSetId = options.preferenceSet || DEFAULT_PREFERENCE_SET_ID;
-            const { data } = yield this.knock.get(`/v1/users/${userId}/preferences/${preferenceSetId}`);
-            return data;
+            return this.knock.users.getPrefences(userId, options);
         });
     }
+    /**
+     * @deprecated Use `users.setPreferences` instead
+     */
     set(userId, preferenceSet, options = {}) {
         return __awaiter(this, void 0, void 0, function* () {
-            const preferenceSetId = options.preferenceSet || DEFAULT_PREFERENCE_SET_ID;
-            const { data } = yield this.knock.put(`/v1/users/${userId}/preferences/${preferenceSetId}`, preferenceSet);
-            return data;
+            return this.knock.users.setPreferences(userId, preferenceSet, options);
         });
     }
+    /**
+     * @deprecated Use `users.setChannelTypesPreferences` instead
+     */
     setChannelTypes(userId, channelTypePreferences, options = {}) {
         return __awaiter(this, void 0, void 0, function* () {
-            const preferenceSetId = options.preferenceSet || DEFAULT_PREFERENCE_SET_ID;
-            const { data } = yield this.knock.put(`/v1/users/${userId}/preferences/${preferenceSetId}/channel_types`, channelTypePreferences);
-            return data;
+            return this.knock.users.setChannelTypesPreferences(userId, channelTypePreferences, options);
         });
     }
+    /**
+     * @deprecated Use `users.setChannelTypePreferences` instead
+     */
     setChannelType(userId, channelType, setting, options = {}) {
         return __awaiter(this, void 0, void 0, function* () {
-            const preferenceSetId = options.preferenceSet || DEFAULT_PREFERENCE_SET_ID;
-            const { data, } = yield this.knock.put(`/v1/users/${userId}/preferences/${preferenceSetId}/channel_types/${channelType}`, { subscribed: setting });
-            return data;
+            return this.knock.users.setChannelTypePreferences(userId, channelType, setting, options);
         });
     }
+    /**
+     * @deprecated Use `users.setWorkflowsPreferences` instead
+     */
     setWorkflows(userId, workflowPreferences, options = {}) {
         return __awaiter(this, void 0, void 0, function* () {
-            const preferenceSetId = options.preferenceSet || DEFAULT_PREFERENCE_SET_ID;
-            const { data } = yield this.knock.put(`/v1/users/${userId}/preferences/${preferenceSetId}/workflows`, workflowPreferences);
-            return data;
+            return this.knock.users.setWorkflowsPreferences(userId, workflowPreferences, options);
         });
     }
+    /**
+     * @deprecated Use `users.setWorkflowPreferences` instead
+     */
     setWorkflow(userId, workflowKey, setting, options = {}) {
         return __awaiter(this, void 0, void 0, function* () {
-            const preferenceSetId = options.preferenceSet || DEFAULT_PREFERENCE_SET_ID;
-            const { data } = yield this.knock.put(`/v1/users/${userId}/preferences/${preferenceSetId}/workflows/${workflowKey}`, buildUpdateParam(setting));
-            return data;
+            return this.knock.users.setWorkflowPreferences(userId, workflowKey, setting, options);
         });
     }
+    /**
+     * @deprecated Use `users.setCategoriesPreferences` instead
+     */
     setCategories(userId, categoryPreferences, options = {}) {
         return __awaiter(this, void 0, void 0, function* () {
-            const preferenceSetId = options.preferenceSet || DEFAULT_PREFERENCE_SET_ID;
-            const { data } = yield this.knock.put(`/v1/users/${userId}/preferences/${preferenceSetId}/categories`, categoryPreferences);
-            return data;
+            return this.knock.users.setCategoriesPreferences(userId, categoryPreferences, options);
         });
     }
+    /**
+     * @deprecated Use `users.setCategoryPreferences` instead
+     */
     setCategory(userId, categoryKey, setting, options = {}) {
         return __awaiter(this, void 0, void 0, function* () {
-            const preferenceSetId = options.preferenceSet || DEFAULT_PREFERENCE_SET_ID;
-            const { data } = yield this.knock.put(`/v1/users/${userId}/preferences/${preferenceSetId}/categories/${categoryKey}`, buildUpdateParam(setting));
-            return data;
+            return this.knock.users.setCategoryPreferences(userId, categoryKey, setting, options);
         });
     }
 }

package/dist/src/resources/preferences/interfaces.d.ts

@@ -1,7 +1,6 @@
-export declare type ChannelType = "email" | "in_app_feed";
+import { ChannelType } from "../../common/interfaces";
 export declare type ChannelTypePreferences = {
-    email: boolean;
-    in_app_feed: boolean;
+    [K in ChannelType]: boolean;
 };
 export declare type WorkflowPreferenceSetting = boolean | {
     channel_types: ChannelTypePreferences;
@@ -10,9 +9,9 @@ export interface WorkflowPreferences {
     [key: string]: WorkflowPreferenceSetting;
 }
 export interface SetPreferencesProperties {
-    workflows: WorkflowPreferences;
-    categories: WorkflowPreferences;
-    channel_types: ChannelTypePreferences;
+    workflows?: WorkflowPreferences;
+    categories?: WorkflowPreferences;
+    channel_types?: ChannelTypePreferences;
 }
 export interface PreferenceSet {
     id: string;

package/dist/src/resources/users/index.d.ts

@@ -1,9 +1,27 @@
+import { ChannelData, ChannelType, CommonMetadata } from "../../common/interfaces";
+import { BulkOperation } from "../bulk_operations/interfaces";
+import { ChannelTypePreferences, PreferenceOptions, PreferenceSet, SetPreferencesProperties, WorkflowPreferences, WorkflowPreferenceSetting } from "../preferences/interfaces";
 import { Knock } from "../../knock";
-import { IdentifyProperties } from "./interfaces";
+import { BulkIdentifyUser, IdentifyProperties, User, UserFeedOptions } from "./interfaces";
 export declare class Users {
     readonly knock: Knock;
     constructor(knock: Knock);
-    identify(userId: string, properties?: IdentifyProperties): Promise<any>;
-    get(userId: string): Promise<any>;
-    delete(userId: string): Promise<any>;
+    identify(userId: string, properties?: IdentifyProperties): Promise<User>;
+    bulkIdentify(users: BulkIdentifyUser[]): Promise<BulkOperation>;
+    get(userId: string): Promise<User>;
+    delete(userId: string): Promise<null>;
+    bulkDelete(userIds: string[]): Promise<BulkOperation>;
+    getFeed(userId: string, channelId: string, feedOptions?: UserFeedOptions): Promise<any>;
+    getAllPreferences(userId: string): Promise<any>;
+    getPrefences(userId: string, options?: PreferenceOptions): Promise<PreferenceSet>;
+    setPreferences(userId: string, preferenceSet: SetPreferencesProperties, options?: PreferenceOptions): Promise<PreferenceSet>;
+    bulkSetPreferences(userIds: string[], preferenceSet: SetPreferencesProperties, options?: PreferenceOptions): Promise<BulkOperation>;
+    setChannelTypesPreferences(userId: string, channelTypePreferences: ChannelTypePreferences, options?: PreferenceOptions): Promise<PreferenceSet>;
+    setChannelTypePreferences(userId: string, channelType: ChannelType, setting: boolean, options?: PreferenceOptions): Promise<PreferenceSet>;
+    setWorkflowsPreferences(userId: string, workflowPreferences: WorkflowPreferences, options?: PreferenceOptions): Promise<PreferenceSet>;
+    setWorkflowPreferences(userId: string, workflowKey: string, setting: WorkflowPreferenceSetting, options?: PreferenceOptions): Promise<PreferenceSet>;
+    setCategoriesPreferences(userId: string, categoryPreferences: WorkflowPreferences, options?: PreferenceOptions): Promise<PreferenceSet>;
+    setCategoryPreferences(userId: string, categoryKey: string, setting: WorkflowPreferenceSetting, options?: PreferenceOptions): Promise<PreferenceSet>;
+    getChannelData<T = CommonMetadata>(userId: string, channelId: string): Promise<ChannelData<T>>;
+    setChannelData<T = CommonMetadata>(userId: string, channelId: string, channelData: Record<string, string>): Promise<ChannelData<T>>;
 }

package/dist/src/resources/users/index.js

@@ -10,10 +10,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Users = void 0;
+const helpers_1 = require("../preferences/helpers");
 class Users {
     constructor(knock) {
         this.knock = knock;
     }
+    //
+    // User management
+    //
     identify(userId, properties = {}) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!userId) {
@@ -23,6 +27,13 @@ class Users {
             return data;
         });
     }
+    bulkIdentify(users) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const attrs = { users };
+            const { data } = yield this.knock.post(`/v1/users/bulk/identify`, attrs);
+            return data;
+        });
+    }
     get(userId) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!userId) {
@@ -41,5 +52,119 @@ class Users {
             return data;
         });
     }
+    bulkDelete(userIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const attrs = { user_ids: userIds };
+            const { data } = yield this.knock.post(`/v1/users/bulk/delete`, attrs);
+            return data;
+        });
+    }
+    //
+    // Feeds
+    //
+    getFeed(userId, channelId, feedOptions = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.knock.get(`/v1/users/${userId}/feeds/${channelId}`, feedOptions);
+            return data;
+        });
+    }
+    //
+    // Preferences
+    //
+    getAllPreferences(userId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.knock.get(`/v1/users/${userId}/preferences`);
+            return data;
+        });
+    }
+    getPrefences(userId, options = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const preferenceSetId = options.preferenceSet || helpers_1.DEFAULT_PREFERENCE_SET_ID;
+            const { data } = yield this.knock.get(`/v1/users/${userId}/preferences/${preferenceSetId}`);
+            return data;
+        });
+    }
+    setPreferences(userId, preferenceSet, options = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const preferenceSetId = options.preferenceSet || helpers_1.DEFAULT_PREFERENCE_SET_ID;
+            const { data } = yield this.knock.put(`/v1/users/${userId}/preferences/${preferenceSetId}`, preferenceSet);
+            return data;
+        });
+    }
+    bulkSetPreferences(userIds, preferenceSet, options = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const preferenceSetId = options.preferenceSet || helpers_1.DEFAULT_PREFERENCE_SET_ID;
+            const attrs = {
+                user_ids: userIds,
+                preferences: Object.assign(Object.assign({}, preferenceSet), { id: preferenceSetId }),
+            };
+            const { data } = yield this.knock.post(`/v1/users/bulk/preferences`, attrs);
+            return data;
+        });
+    }
+    setChannelTypesPreferences(userId, channelTypePreferences, options = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const preferenceSetId = options.preferenceSet || helpers_1.DEFAULT_PREFERENCE_SET_ID;
+            const { data } = yield this.knock.put(`/v1/users/${userId}/preferences/${preferenceSetId}/channel_types`, channelTypePreferences);
+            return data;
+        });
+    }
+    setChannelTypePreferences(userId, channelType, setting, options = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const preferenceSetId = options.preferenceSet || helpers_1.DEFAULT_PREFERENCE_SET_ID;
+            const { data, } = yield this.knock.put(`/v1/users/${userId}/preferences/${preferenceSetId}/channel_types/${channelType}`, { subscribed: setting });
+            return data;
+        });
+    }
+    setWorkflowsPreferences(userId, workflowPreferences, options = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const preferenceSetId = options.preferenceSet || helpers_1.DEFAULT_PREFERENCE_SET_ID;
+            const { data } = yield this.knock.put(`/v1/users/${userId}/preferences/${preferenceSetId}/workflows`, workflowPreferences);
+            return data;
+        });
+    }
+    setWorkflowPreferences(userId, workflowKey, setting, options = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const preferenceSetId = options.preferenceSet || helpers_1.DEFAULT_PREFERENCE_SET_ID;
+            const { data } = yield this.knock.put(`/v1/users/${userId}/preferences/${preferenceSetId}/workflows/${workflowKey}`, helpers_1.buildUpdateParam(setting));
+            return data;
+        });
+    }
+    setCategoriesPreferences(userId, categoryPreferences, options = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const preferenceSetId = options.preferenceSet || helpers_1.DEFAULT_PREFERENCE_SET_ID;
+            const { data } = yield this.knock.put(`/v1/users/${userId}/preferences/${preferenceSetId}/categories`, categoryPreferences);
+            return data;
+        });
+    }
+    setCategoryPreferences(userId, categoryKey, setting, options = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const preferenceSetId = options.preferenceSet || helpers_1.DEFAULT_PREFERENCE_SET_ID;
+            const { data } = yield this.knock.put(`/v1/users/${userId}/preferences/${preferenceSetId}/categories/${categoryKey}`, helpers_1.buildUpdateParam(setting));
+            return data;
+        });
+    }
+    //
+    // Channel data
+    //
+    getChannelData(userId, channelId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!userId || !channelId) {
+                throw new Error(`Incomplete arguments. You must provide a 'userId' and a 'channelId'`);
+            }
+            const { data } = yield this.knock.get(`/v1/users/${userId}/channel_data/${channelId}`);
+            return data;
+        });
+    }
+    setChannelData(userId, channelId, channelData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!userId || !channelId) {
+                throw new Error(`Incomplete arguments. You must provide a 'userId' and a 'channelId'`);
+            }
+            const args = { data: channelData };
+            const { data } = yield this.knock.put(`/v1/users/${userId}/channel_data/${channelId}`, args);
+            return data;
+        });
+    }
 }
 exports.Users = Users;

package/dist/src/resources/users/interfaces.d.ts

@@ -3,3 +3,24 @@ export interface IdentifyProperties {
     email?: string;
     [key: string]: any;
 }
+export interface User {
+    id: string;
+    name: string;
+    email: string;
+    phone_number?: string;
+    avatar?: string;
+    created_at?: string;
+    updated_at?: string;
+    [key: string]: any;
+}
+export interface BulkIdentifyUser extends IdentifyProperties {
+    id: string;
+}
+export interface UserFeedOptions {
+    page_size?: number;
+    after?: string;
+    before?: string;
+    source?: string;
+    tenant?: string;
+    status?: "unread" | "unseen" | "all";
+}

package/dist/src/resources/workflows/index.d.ts

@@ -3,6 +3,6 @@ import { CancelWorkflowProperties, TriggerWorkflowProperties, WorkflowRun } from
 export declare class Workflows {
     readonly knock: Knock;
     constructor(knock: Knock);
-    trigger(workflowKey: string, { actor, recipients, cancellationKey, data: notifyData, }: TriggerWorkflowProperties): Promise<WorkflowRun>;
+    trigger(workflowKey: string, { actor, recipients, cancellationKey, tenant, data: notifyData, }: TriggerWorkflowProperties): Promise<WorkflowRun>;
     cancel(workflowKey: string, cancellationKey: string, { recipients }?: CancelWorkflowProperties): Promise<any>;
 }

package/dist/src/resources/workflows/index.js

@@ -14,7 +14,7 @@ class Workflows {
     constructor(knock) {
         this.knock = knock;
     }
-    trigger(workflowKey, { actor, recipients, cancellationKey, data: notifyData, }) {
+    trigger(workflowKey, { actor, recipients, cancellationKey, tenant, data: notifyData, }) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!workflowKey && !actor && !recipients) {
                 throw new Error(`Incomplete arguments. At a minimum you need to specify 'workflowKey', 'actor', and 'recipients'.`);
@@ -23,6 +23,7 @@ class Workflows {
                 actor,
                 recipients,
                 cancellation_key: cancellationKey,
+                tenant,
                 data: notifyData,
             });
             return data;

package/dist/src/resources/workflows/interfaces.d.ts

@@ -1,13 +1,15 @@
+import { ObjectRef } from "../objects/interfaces";
 export interface TriggerWorkflowProperties {
-    actor: string;
-    recipients?: string[];
+    actor?: string | ObjectRef;
+    recipients?: string[] | ObjectRef[];
     cancellationKey?: string;
+    tenant?: string;
     data?: {
         [key: string]: any;
     };
 }
 export interface CancelWorkflowProperties {
-    recipients?: string[];
+    recipients?: string[] | ObjectRef;
 }
 export interface WorkflowRun {
     workflow_run_id: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@knocklabs/node",
-  "version": "0.2.2",
+  "version": "0.4.0",
   "description": "Library for interacting with the Knock API",
   "homepage": "https://github.com/knocklabs/knock-node",
   "author": "@knocklabs",

package/dist/src/resources/identify/index.d.ts

@@ -1,3 +0,0 @@
-import { Knock } from "../../knock";
-import { IdentifyProperties } from "./interfaces";
-export declare function identify(knock: Knock): (userId: string, properties?: IdentifyProperties) => Promise<any>;

package/dist/src/resources/identify/interfaces.d.ts

@@ -1,5 +0,0 @@
-export interface IdentifyProperties {
-    name?: string;
-    email?: string;
-    [key: string]: any;
-}

package/dist/src/resources/notify/index.d.ts

@@ -1,2 +0,0 @@
-import { Knock } from "../../knock";
-export declare function notify(knock: Knock): (workflowKey: string, { actor, recipients, cancellationKey, data: notifyData, }: import("../..").TriggerWorkflowProperties) => Promise<import("../..").WorkflowRun>;

package/dist/src/resources/notify/index.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.notify = void 0;
-function notify(knock) {
-    // This is just an alias to triggering the workflow
-    return knock.workflows.trigger;
-}
-exports.notify = notify;

package/dist/src/resources/notify/interfaces.d.ts

@@ -1,11 +0,0 @@
-export interface NotifyProperties {
-    actor: string;
-    recipients?: string[];
-    cancelationKey?: string;
-    data?: {
-        [key: string]: any;
-    };
-}
-export interface CancelNotifyProperties {
-    recipients?: string[];
-}