epicenter-libs 3.11.0

package/src/adapters/group.ts

@@ -0,0 +1,511 @@
+import type { UserSession } from '../utils/identification';
+import type { RoutingOptions, Page, GenericSearchOptions } from '../utils/router';
+import type { User } from './user';
+
+import { Router, EpicenterError, identification, ROLE } from '../utils';
+
+enum AUGMENT {
+    MEMBERS = 'MEMBERS',
+    QUANTIZED = 'QUANTIZED',
+}
+
+interface Pricing {
+    amount: number
+}
+
+interface FlightRecorder {
+    start: number,
+    stop: number,
+    enabled: boolean,
+}
+
+interface GroupUpdate {
+    runLimit?: number,
+    organization?: string,
+    allowSelfRegistration?: boolean,
+    flightRecorder?: FlightRecorder,
+    event?: string,
+    allowMembershipChanges?: boolean,
+    pricing?: Pricing,
+    startDate?: Date,
+    expirationDate?: Date,
+    capacity?: number,
+}
+
+interface GroupPermission {
+    available: boolean,
+    objectType: 'group',
+    role: keyof typeof ROLE,
+}
+
+export interface Member extends GroupPermission {
+    user: User,
+}
+
+export interface Group extends GroupUpdate {
+    name: string,
+    groupKey: string,
+    members?: Member[],
+}
+
+
+/**
+ * Provides information on a particular Epicenter group.
+ * @example
+ * import { authAdapter, groupAdapter } from 'epicenter';
+ * const session = authAdapter.getLocalSession();
+ * // include members of the group in the response
+ * const group = await groupAdapter.get(session.groupKey, { augment: 'MEMBERS' });
+ * // include metrics relating to the group in the response
+ * const group = await groupAdapter.get(session.groupKey, { augment: 'QUANTIZED' });
+ * @param [optionals]           Optional arguments; pass network call options overrides here. Special arguments specific to this method are listed below if they exist.
+ * @param [optionals.augment]   Specifies which additional information you'd like returned with the group
+ * @param [optionals.groupKey]  Group key, if omitted will attempt to use the group associated with the current session
+ * @returns promise that resolves to a group
+ */
+export async function get(
+    optionals: {
+        augment?: keyof typeof AUGMENT,
+        groupKey?: string,
+    } & RoutingOptions = {}
+): Promise<Group> {
+    const {
+        groupKey, augment,
+        ...routingOptions
+    } = optionals;
+    let uriComponent = '';
+    if (augment === AUGMENT.MEMBERS) uriComponent = '/member';
+    if (augment === AUGMENT.QUANTIZED) uriComponent = '/quantized';
+    const session = identification.session as UserSession;
+    return await new Router()
+        .get(`/group${uriComponent}/${groupKey ?? session?.groupKey}`, routingOptions)
+        .then(({ body }) => body);
+}
+
+
+/**
+ * Deletes the group; available only to Epicenter admins
+ * @example
+ * epicenter.groupAdapter.destroy('0000017dd3bf540e5ada5b1e058f08f20461');
+ * @param groupKey      Key associated with group
+ * @param [optionals]   Optional arguments; pass network call options overrides here.
+ * @returns promise that resolves to undefined if successful
+ */
+export async function destroy(
+    groupKey: string,
+    optionals: RoutingOptions = {},
+): Promise<void> {
+
+    return await new Router()
+        .delete(`/group/${groupKey}`, optionals)
+        .then(({ body }) => body);
+}
+
+
+/**
+ * Provides information on for all groups in the project
+ * @example
+ * const groups = await epicenter.groupAdapter.gather();
+ * @param [optionals]                   Optional arguments; pass network call options overrides here.
+ * @param [optionals.includeExpired]    Indicates whether to include expired groups in the query
+ * @returns promise that resolves to a list of groups
+ */
+export async function gather(
+    optionals: { includeExpired?: boolean } & RoutingOptions = {}
+): Promise<Group[]> {
+    const {
+        includeExpired,
+        ...routingOptions
+    } = optionals;
+
+    return await new Router()
+        .withSearchParams({ includeExpired })
+        .get('/group', routingOptions)
+        .then(({ body }) => body);
+}
+
+
+/**
+ * Updates fields for a particular group; available only to Epicenter admins.
+ * @example
+ * epicenter.groupAdapter.update('0000017dd3bf540e5ada5b1e058f08f20461', { event: 'Orientation Day' });
+ * @param groupKey                          Key associated with group
+ * @param update                            Attributes you wish to update
+ * @param [update.runLimit]                 Defines the upper limit of runs allowed in the group
+ * @param [update.organization]             Name of the organization owning the group
+ * @param [update.allowSelfRegistration]    TODO -- this does something, it's just that the frontend devs don't know what yet
+ * @param [update.flightRecorder]           Diagnostic tool for logging http requests for the server
+ * @param [update.flightRecorder].start     Start time (epoch time)
+ * @param [update.flightRecorder].stop      End time (epoch time)
+ * @param [update.flightRecorder].enabled   Enabled flag for the flight recorder
+ * @param [update.event]                    Name of the event the group is playing for
+ * @param [update.allowMembershipChanges]   TODO -- this does something, it's just that the frontend devs don't know what yet
+ * @param [update.pricing]                  TODO -- this does something, it's just that the frontend devs don't know what yet
+ * @param [update.pricing].number           TODO -- this does something, it's just that the frontend devs don't know what yet
+ * @param [update.startDate]                TODO -- this does something, it's just that the frontend devs don't know what yet
+ * @param [update.expirationDate]           Date the group expires
+ * @param [update.capacity]                 Defines the upper limit on the number of users allowed in the group
+ * @param [optionals]                       Optional arguments; pass network call options overrides here.
+ * @returns promise that resolves to the updated group
+ */
+export async function update(
+    groupKey: string,
+    update: GroupUpdate,
+    optionals: RoutingOptions = {}
+): Promise<Group> {
+    const {
+        runLimit, organization, allowSelfRegistration, flightRecorder,
+        event, allowMembershipChanges, pricing,
+        startDate, expirationDate, capacity,
+    } = update;
+
+    return await new Router()
+        .patch(`/group/${groupKey}`, {
+            body: {
+                runLimit, organization, allowSelfRegistration, flightRecorder,
+                event, allowMembershipChanges, pricing,
+                startDate, expirationDate, capacity,
+            },
+            ...optionals,
+        })
+        .then(({ body }) => body);
+}
+
+
+/**
+ * Creates a new group; available only to Epicenter admins
+ * @example
+ * epicenter.groupAdapter.create({
+ *      runLimit: 10,
+ *      name: 'my-group-name',
+ * });
+ * @param group                             Group object
+ * @param group.name                        Group name (required)
+ * @param [group.runLimit]                  Defines the upper limit on the number of runs allowed in the group
+ * @param [group.organization]              Name of the organization owning the group
+ * @param [group.allowSelfRegistration]     TODO -- this does something, it's just that the frontend devs don't know what yet
+ * @param [group.flightRecorder]            Diagnostic tool for loggin http requests for the server
+ * @param [group.flightRecorder.start]      Start time (epoch time)
+ * @param [group.flightRecorder.stop]       End time (epoch time)
+ * @param [group.flightRecorder.enabled]    Enabled flag for the flight recorder
+ * @param [group.event]                     Name of the event the group is playing for
+ * @param [group.allowMembershipChanges]    TODO -- this does something, it's just that the frontend devs don't know what yet
+ * @param [group.pricing]                   TODO -- this does something, it's just that the frontend devs don't know what yet
+ * @param [group.startDate]                 TODO -- this does something, it's just that the frontend devs don't know what yet
+ * @param [group.expirationDate]            Date the group expires
+ * @param [group.capacity]                  Defines the upper limit on the number of users allowed in the group
+ * @param [optionals]                       Optional arguments; pass network call options overrides here.
+ * @returns promise that resolves to the newly created group
+ */
+export async function create(
+    group: Group,
+    optionals: RoutingOptions = {}
+): Promise<Group> {
+    const {
+        name, runLimit, organization, allowSelfRegistration,
+        flightRecorder, event, allowMembershipChanges, pricing,
+        startDate, expirationDate, capacity,
+    } = group;
+    if (!name) throw new EpicenterError('Cannot create a group with no name');
+    return await new Router()
+        .post('/group', {
+            body: {
+                name, runLimit, organization, allowSelfRegistration,
+                flightRecorder, event, allowMembershipChanges, pricing,
+                startDate, expirationDate, capacity,
+            },
+            ...optionals,
+        })
+        .then(({ body }) => body);
+}
+
+
+/**
+ * Queries for groups
+ * @example
+ * import { groupAdapter } from 'epicenter';
+ * const filter = [
+ *      'name|=group1|group2',                              // look for groups whose name is 'group1' or 'group2'
+ *      'groupKey=0000017dd3bf540e5ada5b1e058f08f20461',    // look for groups with the specific group key
+ *      'approximateMemberCount>30',                        // look for groups larger than 30
+ *      'startDate<2022-01-03T20:30:53.054Z',               // look for groups with start date before Jan 3rd 2022
+ *      'expirationDate<2022-01-03T20:30:53.054Z',          // look for groups with expiration date before Jan 3rd 2022
+ *      // 'account.shortName=acme',                        // specifies account, intended for admin use
+ *      // 'project.shortName=simulations',                 // specifies project, intended for admin use
+ * ];
+ * groupAdapter.query({
+ *      filter,
+ *      sort: ['+group.name']   // sort all findings by group name ascending (lexigraphically)
+ *      first: 3,               // page should start with the 4th item found (will default to 0)
+ *      max: 10,                // page should only include the first 10 items
+ * });
+ * @param searchOptions             Search options for the query
+ * @param [searchOptions.filter]    Filters for searching
+ * @param [searchOptions.sort]      Sorting criteria
+ * @param [searchOptions.first]     The starting index of the page returned
+ * @param [searchOptions.max]       The number of entries per page
+ * @param [optionals]               Optional arguments; pass network call options overrides here.
+ * @returns promise that resolves to a page of groups
+ */
+export async function query(
+    searchOptions: { quantized?: boolean } & GenericSearchOptions,
+    optionals: RoutingOptions = {}
+): Promise<Page<Group>> {
+    const { filter = [], sort = [], first, max, quantized } = searchOptions;
+
+    const searchParams = {
+        filter: filter.join(';') || undefined,
+        sort: sort.join(';') || undefined,
+        first, max,
+    };
+
+    return await new Router()
+        .withSearchParams(searchParams)
+        .get(`/group${quantized ? '/quantized' : ''}/search`, {
+            paginated: true,
+            ...optionals,
+        })
+        .then(({ body }) => body);
+}
+/** DEPRECATED -- use groupAdapter.query instead */
+export async function search(
+    optionals: { quantized?: boolean } & GenericSearchOptions & RoutingOptions = {}
+): Promise<Page<Group>> {
+    console.warn('DEPRECATION WARNING: groupAdapter.search is deprecated and will be removed with the next release. Use groupAdapter.query instead.');
+    const { filter = [], sort = [], first, max, quantized, ...routingOptions } = optionals;
+    const searchOptions = { filter, sort, first, max, quantized };
+    return await query(searchOptions, routingOptions);
+}
+
+
+/**
+ * Retrieves a group with given group name
+ * @example
+ * epicenter.groupAdapter.withGroupName('my-group-name');
+ * @param name          Name associated with the group
+ * @param [optionals]   Optional arguments; pass network call options overrides here.
+ * @returns promise that resolves to a group
+ */
+export async function withGroupName(
+    name: string,
+    optionals: RoutingOptions = {}
+): Promise<Group> {
+
+    return await new Router()
+        .get(`/group/with/${name}`, optionals)
+        .then(({ body }) => body);
+}
+
+
+/**
+ * Retrieves the list of groups a particular user is in; intended for admin use
+ * @example
+ * epicenter.groupAdapter.forUser(
+ *      '000001796733eef0842f4d6d960997018a3b', // get groups where this user is a member of
+ *      { role: ['FACILITATOR'] }               // where this user is a facilitator in the group
+ * );
+ * @param userKey                       Name associated with the group
+ * @param [optionals]                   Optional arguments; pass network call options overrides here. Special arguments specific to this method are listed below if they exist.
+ * @param [optionals.includeExpired]    Indicates whether to include expired groups in the query
+ * @param [optionals.includeAllMembers] Indicates whether to include the other members in the group (by default, only the requested user appears)
+ * @param [optionals.role]              Role or list of possible roles the user holds in the group
+ * @returns promise that resolves to a list of groups
+ */
+export async function forUser(
+    userKey: string,
+    optionals: {
+        includeAllMembers?: boolean,
+        includeExpired?: boolean,
+        role?: string | string[],
+    } & RoutingOptions = {},
+): Promise<Group[]> {
+    const {
+        includeExpired, includeAllMembers, role,
+        ...routingOptions
+    } = optionals;
+    const isMultiple = Array.isArray(role) && role.length > 0;
+    const roleList = isMultiple ? role : [role];
+    const searchParams = {
+        includeExpired,
+        includeAllMembers,
+        role: role ? roleList : undefined,
+    };
+
+    return await new Router()
+        .withSearchParams(searchParams)
+        .get(`/group/member/for/${userKey}`, routingOptions)
+        .then(({ body }) => body);
+}
+
+
+/**
+ * Retrieves the list of groups particular to the current session
+ * @example
+ * const groups = await epicenter.groupAdapter.getSessionGroups();
+ * @param [optionals]                   Optional arguments; pass network call options overrides here.
+ * @param [optionals.includeExpired]    Indicates whether to include expired groups in the query
+ * @param [optionals.includeAllMembers] Indicates whether to include the other members in the group (by default, only the requested user appears)
+ * @param [optionals.role]              Role or list of possible roles the user holds in the group
+ * @returns promise that resolves to a list of groups
+ */
+export async function getSessionGroups(
+    optionals: {
+        includeAllMembers?: boolean,
+        includeExpired?: boolean,
+        role?: string | string[],
+    } & RoutingOptions = {},
+): Promise<Group[]> {
+    const {
+        includeExpired, role,
+        ...routingOptions
+    } = optionals;
+    const isMultiple = Array.isArray(role) && role.length > 0;
+    const roleList = isMultiple ? role : [role];
+    const searchParams = {
+        includeExpired,
+        role: role ? roleList : undefined,
+    };
+
+    return await new Router()
+        .withSearchParams(searchParams)
+        .get('/group/member', routingOptions)
+        .then(({ body }) => body);
+}
+
+
+/**
+ * Self-application for membership in a group; will only work if the group has the self-registration setting turned on.
+ * @example
+ * epicenter.groupAdapter.register('0000017dd3bf540e5ada5b1e058f08f20461');
+ * @param groupKey      Key associated with group
+ * @param [optionals]   Optional arguments; pass network call options overrides here.
+ * @returns promise that resolves in a group
+ */
+export async function register(
+    groupKey: string,
+    optionals: RoutingOptions = {}
+): Promise<Group> {
+
+    return await new Router()
+        .post(`/group/selfRegistration/${groupKey}`, optionals)
+        .then(({ body }) => body);
+}
+
+
+type UserInput = string | { userKey: string, role?: keyof typeof ROLE, available?: boolean };
+/**
+ * Adds user(s) to the group
+ * @example
+ * epicenter.groupAdapter.addUser('000001796733eef0842f4d6d960997018a3b');
+ * epicenter.groupAdapter.addUser([{
+ *      userKey: '000001796733eef0842f4d6d960997018a3b',
+ *      role: 'REVIEWER',
+ *      available: false,
+ * }]);
+ * @param usersInput                List of user keys or user input objects (properties defined below)
+ * @param usersInput[].userKey      User key
+ * @param [usersInput[].role]       User's role -- defaults to PARTICIPANT if unset; See [ROLE](#ROLE) for all types
+ * @param [usersInput[].available]  Indicates whether or not the user is 'active' (for semantic labeling) -- defaults to true if unset
+ * @param [optionals]               Optional arguments; pass network call options overrides here. Special arguments specific to this method are listed below if they exist.
+ * @param [optionals.groupKey]      Group key to do indicate the group; will default to the group key associated with the current session
+ * @returns promise that resolves to the group the user was added to
+ */
+export async function addUser(
+    usersInput: UserInput | UserInput[],
+    optionals: { groupKey?: string } & RoutingOptions = {}
+):Promise<Group> {
+    const { groupKey, ...routingOptions } = optionals;
+
+    const users = Array.isArray(usersInput) ? usersInput : [usersInput];
+    const session = identification.session as UserSession;
+    return await new Router()
+        .post(`/group/member/${groupKey ?? session?.groupKey}`, {
+            body: users.map((u) => {
+                const userKey = typeof u === 'string' ? u : u.userKey;
+                const role = typeof u === 'string' ? ROLE.PARTICIPANT : u.role;
+                const available = typeof u === 'string' ? true : u.available;
+
+                return {
+                    role,
+                    userKey,
+                    objectType: 'group',
+                    available: available ?? true,
+                };
+            }),
+            ...routingOptions,
+        })
+        .then(({ body }) => body);
+}
+
+
+/**
+ * Updates a user's group membership information
+ * @example
+ * epicenter.groupAdapter.updateUser('000001796733eef0842f4d6d960997018a3b', { role: 'LEADER' });
+ * @param userKey               User key
+ * @param update                Object containing the updates to a user's group membership information
+ * @param [update.role]         User's role; See [ROLE](#ROLE) for all types
+ * @param [update.available]    Indicates whether or not the user is 'active' (for semantic labeling)
+ * @param [optionals]           Optional arguments; pass network call options overrides here.
+ * @returns promise that resolves to the membership information that was updated
+ */
+export async function updateUser(
+    userKey: string,
+    update: { role?: keyof typeof ROLE, available?: boolean },
+    optionals: { groupKey?: string } & RoutingOptions = {}
+):Promise<GroupPermission> {
+    const { role, available } = update;
+    const { groupKey, ...routingOptions } = optionals;
+    const session = identification.session as UserSession;
+    return await new Router()
+        .patch(`/group/member/${groupKey ?? session?.groupKey}/${userKey}`, {
+            body: {
+                objectType: 'group',
+                role,
+                available,
+            },
+            ...routingOptions,
+        })
+        .then(({ body }) => body);
+}
+
+
+/**
+ * Removes user(s) from the group
+ * @example
+ * const userKeys = members.map(({ userKey }) => userKey);
+ * epicenter.groupAdapter.removeUsers(userKeys)
+ * @param userKey               Key associated with the user or an array of user keys to remove from group
+ * @param [optionals]           Optional arguments; pass network call options overrides here. Special arguments specific to this method are listed below if they exist.
+ * @param [optionals.groupKey]  Group key for the group you want to remove from; defaults to the group in the current session
+ * @returns promise that resolves to undefined when successful
+ */
+export async function removeUser(
+    userKey: string | string[],
+    optionals: { groupKey?: string } & RoutingOptions = {}
+): Promise<void> {
+    const { groupKey, ...routingOptions } = optionals;
+    const hasMultiple = Array.isArray(userKey) && userKey.length > 1;
+    const uriComponent = hasMultiple ? '' : `/${userKey.length === 1 ? userKey[0] : userKey}`;
+    const searchParams = hasMultiple ? { userKey } : undefined;
+    const session = identification.session as UserSession;
+    return await new Router()
+        .withSearchParams(searchParams)
+        .delete(`/group/member/${groupKey ?? session?.groupKey}${uriComponent}`, routingOptions)
+        .then(({ body }) => body);
+}
+
+
+export async function statusUpdate(
+    code: string,
+    message: string,
+    optionals: { groupKey?: string } & RoutingOptions = {}
+): Promise<Group> {
+    const { groupKey, ...routingOptions } = optionals;
+    const session = identification.session as UserSession;
+    return await new Router()
+        .patch(`/group/status/${groupKey ?? session?.groupKey}`, {
+            body: { code, message },
+            ...routingOptions,
+        }).then(({ body }) => body);
+}

package/src/adapters/index.ts

@@ -0,0 +1,43 @@
+import * as accountAdapter from './account';
+import * as adminAdapter from './admin';
+import * as authAdapter from './authentication';
+import * as assetAdapter from './asset';
+import * as emailAdapter from './email';
+import * as episodeAdapter from './episode';
+import * as groupAdapter from './group';
+import * as leaderboardAdapter from './leaderboard';
+import * as presenceAdapter from './presence';
+import * as projectAdapter from './project';
+import * as recaptchaAdapter from './recaptcha';
+import * as runAdapter from './run';
+import * as userAdapter from './user';
+import * as vaultAdapter from './vault';
+import * as worldAdapter from './world';
+import * as timeAdapter from './time';
+import * as taskAdapter from './task';
+import * as chatAdapter from './chat';
+import { default as cometdAdapter } from './cometd';
+import { default as Channel } from './channel';
+
+export {
+    accountAdapter,
+    adminAdapter,
+    authAdapter,
+    assetAdapter,
+    chatAdapter,
+    cometdAdapter,
+    emailAdapter,
+    episodeAdapter,
+    groupAdapter,
+    leaderboardAdapter,
+    presenceAdapter,
+    projectAdapter,
+    recaptchaAdapter,
+    runAdapter,
+    timeAdapter,
+    userAdapter,
+    vaultAdapter,
+    worldAdapter,
+    taskAdapter,
+    Channel,
+};

package/src/adapters/leaderboard.ts

@@ -0,0 +1,122 @@
+import type { UserSession } from 'utils/identification';
+import type { RoutingOptions, GenericSearchOptions } from 'utils/router';
+import type { GenericScope } from 'utils/constants';
+
+import { identification, Router } from 'utils';
+
+
+interface Score {
+    name: string,
+    quantity: number,
+}
+
+interface Tag {
+    label: string,
+    content: string,
+}
+
+interface Leaderboard {
+    lastUpdated: Date,
+}
+
+
+/**
+ * Creates a leaderboard entry.
+ * @example
+ * import { leaderboardAdapter } from 'epicenter';
+ * const leaderboard = await leaderboardAdapter.post(
+ *      'class-23-leaderboard',
+ *      [{ name: 'total', quantity: 20 }, { name: 'extraCredit', quantity: 2 }],
+ *      { scopeBoundary: SCOPE_BOUNDARY.GROUP, scopeKey: '0000017dd3bf540e5ada5b1e058f08f20461' },
+ *      { tags: [{ label: 'role', content: 'doctor' }] }
+ * );
+ * @param collection            Name of the leaderboard
+ * @param scope                 Scope attached to the leaderboard entry; allows for scoping
+ * @param scope.scopeBoundary   Can be a couple things, commonly group, project, episode, or world
+ * @param scope.scopeKey        Key of the resource defined by the scope boundary
+ * @param scope.userKey         User key for the user creating the entry, if omitted will use the one in current session
+ * @param scores                List of score objects
+ * @param scores[].name         Name of the score
+ * @param scores[].quantity     Value of the score
+ * @param [optionals]           Optional arguments; pass network call options overrides here. Special arguments specific to this method are listed below if they exist.
+ * @params [optionals.tags]     Tags for the leaderboard entry, helps to provide another layer of scope if needed
+ * @returns promise that resolves to the leaderboard entry created
+ */
+export async function update(
+    collection: string,
+    scope: { userKey?: string } & GenericScope,
+    scores: Score[],
+    optionals: { tags?: Tag[] } & RoutingOptions = {}
+): Promise<Leaderboard> {
+    const { tags, ...routingOptions } = optionals;
+    const { scopeBoundary, scopeKey, userKey } = scope;
+    const session = identification.session as UserSession;
+    return await new Router()
+        .post('/leaderboard', {
+            body: {
+                scope: {
+                    scopeBoundary,
+                    scopeKey,
+                    userKey: userKey ?? session?.userKey,
+                },
+                collection,
+                scores, tags,
+            },
+            ...routingOptions,
+        }).then(({ body }) => body);
+}
+
+/**
+ * Gathers leaderboard information; not paginable (hence named 'list' and not 'query'). Technically there is no leader
+ * @example
+ * import { leaderboardAdapter } from 'epicenter';
+ * const leaderboard = await leaderboardAdapter.list('myLeaderboard', scope, {
+ *      filter: [
+ *          'tag.role=doctor',  // look for leaderboard entries tagged with role=doctor
+ *          'score.total>0'     // where the users scored a total higher than 0
+ *      ],
+ *      sort: ['+score.total'], // sort results by 'total' in ascending order,
+ *      first: 0,
+ *      max: 20                 // retrieve only the first 20 entries
+ * });
+ * @param collection                Name of the leaderboard
+ * @param scope                     Scope attached to the leaderboard entry; allows for scoping
+ * @param scope.scopeBoundary       Can be a couple things, commonly group, project, episode, or world
+ * @param scope.scopeKey            Key of the resource defined by the scope boundary
+ * @param searchOptions             Search options for the query
+ * @param [searchOptions.filter]    Filters for searching
+ * @param [searchOptions.sort]      Sorting criteria
+ * @param [searchOptions.first]     The starting index of the list returned
+ * @param [searchOptions.max]       The maximum number of entries in the list
+ * @param [optionals]               Optional arguments; pass network call options overrides here.
+ * @returns promise that resolves to to a list of leaderboard entries
+ */
+export async function list(
+    collection: string,
+    scope: GenericScope,
+    searchOptions: GenericSearchOptions,
+    optionals: RoutingOptions = {}
+): Promise<Leaderboard[]> {
+    const { scopeBoundary, scopeKey } = scope;
+    const { filter = [], sort = [], first, max } = searchOptions;
+    const searchParams = {
+        filter: filter.join(';') || undefined,
+        sort: sort.join(';') || undefined,
+        first, max,
+    };
+
+    return await new Router()
+        .withSearchParams(searchParams)
+        .get(`/leaderboard/${scopeBoundary}/${scopeKey}/${collection}`, optionals)
+        .then(({ body }) => body);
+}
+
+export async function get(
+    collection: string,
+    scope: GenericScope,
+    searchOptions: GenericSearchOptions,
+    optionals: RoutingOptions = {}
+): Promise<Leaderboard[]> {
+    console.warn('DEPRECATION WARNING: leaderboardAdapter.get is deprecated and will be removed with the next release. Use leaderboardAdapter.list instead.');
+    return await list(collection, scope, searchOptions, optionals);
+}