epicenter-libs 3.33.0 → 3.34.1

package/dist/types/adapters/chat.d.ts

@@ -136,3 +136,66 @@ export declare function getMessages(chatKey: string, optionals?: {
     maxRecords?: number;
     horizon?: number;
 } & RoutingOptions): Promise<ChatMessageReadOutView[]>;
+/**
+ * Retrieves messages for a given user; requires facilitator authentication; works with an admin user
+ * Base URL: GET `https://forio.com/api/v3/{ACCOUNT}/{PROJECT}/chat/message/{CHAT_KEY}/{PSEUDONYM_KEY}`
+ *
+ * @example
+ * import { chatAdapter } from 'epicenter-libs';
+ * // gets the chat message with id: 5
+ * const message = await chatAdapter.getMessagesForUser('0000017dd3bf540e5ada5b1e058f08f20461', '000001796733eef0842f4d6d960997018a33', { horizon: 5, maxRecords: 1 });
+ * // gets the 10 chat messages starting from id 5 (inclusive)
+ * const messages = await chatAdapter.getMessagesForUser('0000017dd3bf540e5ada5b1e058f08f20461', '000001796733eef0842f4d6d960997018a33', { horizon: 5, maxRecords: 10 });
+ *
+ * @param chatKey                   Key associated with the chat
+ * @param pseudonymKey             Key associated with the user whose messages are being retrieved
+ * @param [optionals]               Optional arguments; pass network call options overrides here. Special arguments specific to this method are listed below if they exist.
+ * @param [optionals.maxRecords]    Maximum number of messages to get
+ * @param [optionals.horizon]       The message ID from which to start with; works backwards so if `maxRecords=20` and `horizon=50`, it will get the 20 messages starting from message ID 50, working backwards (50, 49, 48..., etc.). If this value is omitted the platform assumes it is the most recent message in the chat
+ * @returns promise that resolves to the list of chat messages requested
+ */
+export declare function getMessagesForUser(chatKey: string, pseudonymKey: string, optionals?: {
+    maxRecords?: number;
+    horizon?: number;
+} & RoutingOptions): Promise<ChatMessageReadOutView[]>;
+/**
+ * Retrieves messages from for a given chat for an admin user; requires support authentication
+ * Base URL: GET `https://forio.com/api/v3/{ACCOUNT}/{PROJECT}/chat/message/all/{CHAT_KEY}`
+ *
+ * @example
+ * import { chatAdapter } from 'epicenter-libs';
+ * // gets the chat message with id: 5
+ * const message = await chatAdapter.getMessagesAdmin('0000017dd3bf540e5ada5b1e058f08f20461', { horizon: 5, maxRecords: 1 });
+ * // gets the 10 chat messages starting from id 5 (inclusive)
+ * const messages = await chatAdapter.getMessagesAdmin('0000017dd3bf540e5ada5b1e058f08f20461', { horizon: 5, maxRecords: 10 });
+ *
+ * @param chatKey                   Key associated with the chat
+ * @param [optionals]               Optional arguments; pass network call options overrides here. Special arguments specific to this method are listed below if they exist.
+ * @param [optionals.maxRecords]    Maximum number of messages to get
+ * @param [optionals.horizon]       The message ID from which to start with; works backwards so if `maxRecords=20` and `horizon=50`, it will get the 20 messages starting from message ID 50, working backwards (50, 49, 48..., etc.). If this value is omitted the platform assumes it is the most recent message in the chat
+ * @returns promise that resolves to the list of chat messages requested
+ */
+export declare function getMessagesAdmin(chatKey: string, optionals?: {
+    maxRecords?: number;
+    horizon?: number;
+} & RoutingOptions): Promise<ChatMessageReadOutView[]>;
+/**
+ * Sends a message to a chat as an admin user; requires support authentication
+ * Base URL: PUT `https://forio.com/api/v3/{ACCOUNT}/{PROJECT}/chat/message/system/{CHAT_KEY}` or PUT `https://forio.com/api/v3/{ACCOUNT}/{PROJECT}/chat/message/system/{CHAT_KEY}/{USER_KEY}`
+ *
+ * @example
+ * import { chatAdapter } from 'epicenter-libs';
+ * // Send a public message to the chat
+ * await chatAdapter.sendMessageAdmin('0000017dd3bf540e5ada5b1e058f08f20461', 'hello');
+ * // Send a private message to a specific user
+ * await chatAdapter.sendMessageAdmin('0000017dd3bf540e5ada5b1e058f08f20461', 'hello, privately', { userKey: '000001796733eef0842f4d6d960997018a33' });
+ *
+ * @param chatKey               Key associated with the chat
+ * @param message               Message text to send
+ * @param [optionals]           Optional arguments; pass network call options overrides here. Special arguments specific to this method are listed below if they exist.
+ * @param [optionals.userKey]   Key of the user to send the message to. If omitted, will send as a public message
+ * @returns promise that resolves to the chat message created
+ */
+export declare function sendMessageAdmin(chatKey: string, message: string, optionals?: {
+    userKey?: string;
+} & RoutingOptions): Promise<ChatMessageReadOutView>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "epicenter-libs",
-  "version": "3.33.0",
+  "version": "3.34.1",
   "main": "dist/cjs/epicenter.js",
   "type": "module",
   "module": "dist/module/epicenter.js",

package/src/adapters/chat.ts

@@ -224,3 +224,98 @@ export async function getMessages(
         .get(`/chat/message/${chatKey}`, routingOptions)
         .then(({ body }) => body);
 }
+
+/**
+ * Retrieves messages for a given user; requires facilitator authentication; works with an admin user
+ * Base URL: GET `https://forio.com/api/v3/{ACCOUNT}/{PROJECT}/chat/message/{CHAT_KEY}/{PSEUDONYM_KEY}`
+ *
+ * @example
+ * import { chatAdapter } from 'epicenter-libs';
+ * // gets the chat message with id: 5
+ * const message = await chatAdapter.getMessagesForUser('0000017dd3bf540e5ada5b1e058f08f20461', '000001796733eef0842f4d6d960997018a33', { horizon: 5, maxRecords: 1 });
+ * // gets the 10 chat messages starting from id 5 (inclusive)
+ * const messages = await chatAdapter.getMessagesForUser('0000017dd3bf540e5ada5b1e058f08f20461', '000001796733eef0842f4d6d960997018a33', { horizon: 5, maxRecords: 10 });
+ *
+ * @param chatKey                   Key associated with the chat
+ * @param pseudonymKey             Key associated with the user whose messages are being retrieved
+ * @param [optionals]               Optional arguments; pass network call options overrides here. Special arguments specific to this method are listed below if they exist.
+ * @param [optionals.maxRecords]    Maximum number of messages to get
+ * @param [optionals.horizon]       The message ID from which to start with; works backwards so if `maxRecords=20` and `horizon=50`, it will get the 20 messages starting from message ID 50, working backwards (50, 49, 48..., etc.). If this value is omitted the platform assumes it is the most recent message in the chat
+ * @returns promise that resolves to the list of chat messages requested
+ */
+export async function getMessagesForUser(
+    chatKey: string,
+    pseudonymKey: string,
+    optionals: {
+        maxRecords?: number;
+        horizon?: number;
+    } & RoutingOptions = {},
+): Promise<ChatMessageReadOutView[]> {
+    const { maxRecords, horizon, ...routingOptions } = optionals;
+    return new Router()
+        .withSearchParams({ maxRecords, horizon })
+        .get(`/chat/message/${chatKey}/${pseudonymKey}`, routingOptions)
+        .then(({ body }) => body);
+}
+
+/**
+ * Retrieves messages from for a given chat for an admin user; requires support authentication
+ * Base URL: GET `https://forio.com/api/v3/{ACCOUNT}/{PROJECT}/chat/message/all/{CHAT_KEY}`
+ *
+ * @example
+ * import { chatAdapter } from 'epicenter-libs';
+ * // gets the chat message with id: 5
+ * const message = await chatAdapter.getMessagesAdmin('0000017dd3bf540e5ada5b1e058f08f20461', { horizon: 5, maxRecords: 1 });
+ * // gets the 10 chat messages starting from id 5 (inclusive)
+ * const messages = await chatAdapter.getMessagesAdmin('0000017dd3bf540e5ada5b1e058f08f20461', { horizon: 5, maxRecords: 10 });
+ *
+ * @param chatKey                   Key associated with the chat
+ * @param [optionals]               Optional arguments; pass network call options overrides here. Special arguments specific to this method are listed below if they exist.
+ * @param [optionals.maxRecords]    Maximum number of messages to get
+ * @param [optionals.horizon]       The message ID from which to start with; works backwards so if `maxRecords=20` and `horizon=50`, it will get the 20 messages starting from message ID 50, working backwards (50, 49, 48..., etc.). If this value is omitted the platform assumes it is the most recent message in the chat
+ * @returns promise that resolves to the list of chat messages requested
+ */
+export async function getMessagesAdmin(
+    chatKey: string,
+    optionals: {
+        maxRecords?: number;
+        horizon?: number;
+    } & RoutingOptions = {},
+): Promise<ChatMessageReadOutView[]> {
+    const { maxRecords, horizon, ...routingOptions } = optionals;
+    return new Router()
+        .withSearchParams({ maxRecords, horizon })
+        .get(`/chat/message/all/${chatKey}`, routingOptions)
+        .then(({ body }) => body);
+}
+
+/**
+ * Sends a message to a chat as an admin user; requires support authentication
+ * Base URL: PUT `https://forio.com/api/v3/{ACCOUNT}/{PROJECT}/chat/message/system/{CHAT_KEY}` or PUT `https://forio.com/api/v3/{ACCOUNT}/{PROJECT}/chat/message/system/{CHAT_KEY}/{USER_KEY}`
+ *
+ * @example
+ * import { chatAdapter } from 'epicenter-libs';
+ * // Send a public message to the chat
+ * await chatAdapter.sendMessageAdmin('0000017dd3bf540e5ada5b1e058f08f20461', 'hello');
+ * // Send a private message to a specific user
+ * await chatAdapter.sendMessageAdmin('0000017dd3bf540e5ada5b1e058f08f20461', 'hello, privately', { userKey: '000001796733eef0842f4d6d960997018a33' });
+ *
+ * @param chatKey               Key associated with the chat
+ * @param message               Message text to send
+ * @param [optionals]           Optional arguments; pass network call options overrides here. Special arguments specific to this method are listed below if they exist.
+ * @param [optionals.userKey]   Key of the user to send the message to. If omitted, will send as a public message
+ * @returns promise that resolves to the chat message created
+ */
+export async function sendMessageAdmin(
+    chatKey: string,
+    message: string,
+    optionals: { userKey?: string } & RoutingOptions = {},
+): Promise<ChatMessageReadOutView> {
+    const { userKey, ...routingOptions } = optionals;
+    const uriComponent = userKey ? `/${userKey}` : '';
+    return new Router()
+        .put(`/chat/message/system/${chatKey}${uriComponent}`, {
+            body: { message },
+            ...routingOptions,
+        }).then(({ body }) => body);
+}

package/src/utils/identification.ts

@@ -230,6 +230,10 @@ class Identification {
             const project = account && projectShortName ? `/${projectShortName}` : '';
             this.session = session;
             cookies.removeItem(EPI_SSO_KEY, { path: `/app${account}${project}` });
+            cookies.removeItem(EPI_SSO_KEY, {
+                domain: `.${window.location.hostname}`,
+                path: `/app${account}${project}`,
+            });
         }
     }
 }

package/dist/test/_virtual/runtime.js

@@ -1,3 +0,0 @@
-import { __require as requireRuntime } from '../node_modules/regenerator-runtime/runtime.js';
-
-requireRuntime();

package/dist/test/_virtual/runtime2.js

@@ -1,3 +0,0 @@
-var runtime = {exports: {}};
-
-export { runtime as __module };

package/dist/test/adapters/account.js

@@ -1,169 +0,0 @@
-import Router from '../utils/router.js';
-
-/**
- * Retrieves account information by account short name
- * Base URL: GET `https://forio.com/api/v3/{ACCOUNT}/account`
- *
- * @example
- * import { accountAdapter } from 'epicenter-libs';
- * const account = await accountAdapter.getAccount('acme');
- *
- * @param accountShortName  The short name of the account to retrieve
- * @returns promise that resolves to the account information
- */
-async function getAccount(accountShortName) {
-  return await new Router().withAccountShortName(accountShortName).get('/account').then(({
-    body
-  }) => body);
-}
-
-/**
- * Creates a new personal or team account
- * Base URL: POST `https://forio.com/api/v3/epicenter/manager/account`
- *
- * @example
- * import { accountAdapter } from 'epicenter-libs';
- * // Create a personal account
- * const personalAccount = await accountAdapter.createAccount({
- *     objectType: 'personal',
- *     adminKey: 'admin-key',
- *     name: 'John Doe',
- *     shortName: 'johndoe',
- * });
- * // Create a team account with billing
- * const teamAccount = await accountAdapter.createAccount({
- *     objectType: 'team',
- *     adminKey: 'admin-key',
- *     name: 'Acme Corp',
- *     shortName: 'acme',
- *     billingInformation: {
- *         billingInterval: 'monthly',
- *         subscriptionPlan: 'standard',
- *     },
- * });
- *
- * @param view                                      Account creation information
- * @param view.objectType                           Account type; either 'personal' or 'team'
- * @param view.shortName                            Unique short name for account, used as part of URL
- * @param view.adminKey                             Admin key for the account
- * @param view.name                                 Descriptive name of account
- * @param [view.workerPartition]                    Defines location of model execution
- * @param [view.active]                             Determines if the account can be used
- * @param [view.sharedSecret]                       Optional shared secret for the account
- * @param [view.secretStrategy]                     Configuration related to account secrets (team only)
- * @param [view.displayNameStrategy]                Configuration related to user displayName (team only)
- * @param [view.allowDeletion]                      Determines if this account can be deleted (team only)
- * @param [view.retentionPreference]                Configuration related to data, user, group retention preferences (team only)
- * @param [view.multiFactorStrategy]                Configuration related to multifactor authentication (team only)
- * @param [view.apiSecret]                          Configuration related to API secret keys (team only)
- * @param [view.accountSetting]                     Configuration related to account usage limits and capabilities (team only)
- * @param [view.billingInformation]                 Subscription and billing configuration (team only)
- * @param [view.legacySettings]                     API settings used for compatibility with legacy accounts (team only)
- * @param [view.allowStrongFacilitators]            Determines if facilitators can update participants' identifying information (team only)
- * @param [view.allowAmbiguousHandles]              Determines if a handle can be reused for an admin and a user in this account (team only)
- * @param [view.lockoutLimits]                      Configuration related to failed login attempt limits (team only)
- * @returns promise that resolves to the newly created account
- */
-async function createAccount(view) {
-  return await new Router().withAccountShortName('epicenter').withProjectShortName('manager').post('/account', {
-    body: view
-  }).then(({
-    body
-  }) => body);
-}
-
-/**
- * Updates an existing personal or team account
- * Base URL: PATCH `https://forio.com/api/v3/{ACCOUNT}/account`
- *
- * @example
- * import { accountAdapter } from 'epicenter-libs';
- * // Update a personal account
- * const updatedPersonal = await accountAdapter.updateAccount({
- *     objectType: 'personal',
- *     name: 'Jane Doe',
- *     active: true,
- * });
- * // Update a team account
- * const updatedTeam = await accountAdapter.updateAccount({
- *     objectType: 'team',
- *     name: 'Acme Corporation',
- *     billingInterval: 'annual',
- * });
- *
- * @param view                          Account update information
- * @param view.objectType               Account type; either 'personal' or 'team'
- * @param [view.name]                   Updated descriptive name of account
- * @param [view.workerPartition]        Updated location of model execution
- * @param [view.active]                 Updated status determining if the account can be used
- * @param [view.billingInterval]        Updated billing interval (team only)
- * @param [optionals]                   Optional arguments; pass network call options overrides here.
- * @returns promise that resolves to the updated account information
- */
-async function updateAccount(view, optionals = {}) {
-  return await new Router().patch('/account', {
-    body: view,
-    ...optionals
-  }).then(({
-    body
-  }) => body);
-}
-
-/**
- * Deletes an account by account short name
- * Base URL: DELETE `https://forio.com/api/v3/{ACCOUNT}/account`
- *
- * @example
- * import { accountAdapter } from 'epicenter-libs';
- * await accountAdapter.removeAccount('acme');
- *
- * @param accountShortName  The short name of the account to delete
- * @returns promise that resolves when the account is deleted
- */
-async function removeAccount(accountShortName) {
-  return await new Router().withAccountShortName(accountShortName).delete('/account').then(({
-    body
-  }) => body);
-}
-
-/**
- * Retrieves all team accounts for a given admin user
- * Base URL: GET `https://forio.com/api/v3/epicenter/manager/account/team/for/{ADMIN_KEY}`
- *
- * @example
- * import { accountAdapter } from 'epicenter-libs';
- * const teams = await accountAdapter.teamForAdmin('admin-key-123', {
- *     includeAllMembers: true,
- *     filter: 'active',
- *     first: 0,
- *     max: 50,
- * });
- *
- * @param adminKey                          Admin key to retrieve teams for
- * @param [optionals]                       Optional arguments; pass network call options overrides here. Special arguments specific to this method are listed below if they exist.
- * @param [optionals.includeAllMembers]     Include all members in the response
- * @param [optionals.filter]                Filter string for results
- * @param [optionals.first]                 Index of first result to return
- * @param [optionals.max]                   Maximum number of results to return
- * @returns promise that resolves to an array of team accounts
- */
-async function teamForAdmin(adminKey, optionals = {}) {
-  const {
-    includeAllMembers,
-    filter,
-    first,
-    max,
-    ...routingOptions
-  } = optionals;
-  const searchParams = {
-    includeAllMembers,
-    filter,
-    first,
-    max
-  };
-  return await new Router().withAccountShortName('epicenter').withProjectShortName('manager').withSearchParams(searchParams).get(`/account/team/for/${adminKey}`, routingOptions).then(({
-    body
-  }) => body);
-}
-
-export { createAccount, getAccount, removeAccount, teamForAdmin, updateAccount };

package/dist/test/adapters/admin.js

@@ -1,53 +0,0 @@
-import Router from '../utils/router.js';
-
-/**
- * Creates a new admin user
- * Base URL: POST `https://forio.com/api/v3/epicenter/manager/admin`
- *
- * @example
- * import { adminAdapter } from 'epicenter-libs';
- * const admin = await adminAdapter.createAdmin({
- *     handle: 'admin@example.com',
- *     email: 'admin@example.com',
- *     givenName: 'Jane',
- *     familyName: 'Doe',
- *     verified: true,
- *     active: true,
- * });
- *
- * @param view                  Admin user information
- * @param view.handle           Handle for the admin user
- * @param view.email            Email address for the admin user
- * @param [view.givenName]      Admin user's given name
- * @param [view.familyName]     Admin user's family name
- * @param view.verified         Verification status; must be true
- * @param [view.active]         Active status; defaults to true if unset
- * @returns promise that resolves to the newly created admin user
- */
-async function createAdmin(view) {
-  return await new Router().withAccountShortName('epicenter').withProjectShortName('manager').post('/admin', {
-    body: view
-  }).then(({
-    body
-  }) => body);
-}
-
-/**
- * Retrieves an admin user by handle
- * Base URL: GET `https://forio.com/api/v3/epicenter/manager/admin/with/{HANDLE}`
- *
- * @example
- * import { adminAdapter } from 'epicenter-libs';
- * const admin = await adminAdapter.getWithHandle('admin@example.com');
- *
- * @param handle        Handle for the admin user
- * @param [optionals]   Optional arguments; pass network call options overrides here.
- * @returns promise that resolves to the admin user
- */
-async function getWithHandle(handle, optionals = {}) {
-  return await new Router().withAccountShortName('epicenter').withProjectShortName('manager').get(`/admin/with/${handle}`, optionals).then(({
-    body
-  }) => body);
-}
-
-export { createAdmin, getWithHandle };