epicenter-libs 3.11.0

package/dist/types/utils/identification.d.ts

@@ -0,0 +1,47 @@
+import { SessionStore, CookieStore } from './store';
+import { BROWSER_STORAGE_TYPE, ROLE } from './constants';
+export interface UserSession {
+    token: string;
+    userKey: string;
+    groupKey?: string;
+    groupName?: string;
+    groupRole?: string;
+    multipleGroups?: boolean;
+    accountShortName: string;
+    projectShortName?: string;
+    projectKey?: string;
+    displayName: string;
+    objectType: 'user';
+    loginMethod: {
+        objectType: string;
+    };
+}
+export interface AdminSession {
+    adminHandle: string;
+    adminKey: string;
+    expires: boolean;
+    multipleAccounts: boolean;
+    objectType: 'admin';
+    teamAccountRole: ROLE.AUTHOR | ROLE.SUPPORT;
+    teamAccountShortName: string;
+    projectShortName?: string;
+    projectKey?: string;
+    timeoutMinutes: number;
+    token: string;
+}
+export declare type Session = UserSession | AdminSession;
+declare class Identification {
+    type: "COOKIE" | "SESSION";
+    constructor(storeType: keyof typeof BROWSER_STORAGE_TYPE);
+    get session(): Session | undefined;
+    set session(session: Session | undefined);
+    getStore(): typeof SessionStore | typeof CookieStore;
+    getStoreOptions(session?: Session): "" | {
+        path: string;
+        samesite: string;
+        secure: boolean;
+    };
+    consumeSSO(): void;
+}
+declare const identification: Identification;
+export default identification;

package/dist/types/utils/index.d.ts

@@ -0,0 +1,11 @@
+export * from './constants';
+export * from './helpers';
+export * from './store';
+export { default as cookies } from './cookies';
+export { default as EpicenterError } from './error';
+export { default as Fault } from './fault';
+export { default as Result } from './result';
+export { default as config } from './config';
+export { default as identification } from './identification';
+export { default as errorManager } from './error-manager';
+export { default as Router } from './router';

package/dist/types/utils/result.d.ts

@@ -0,0 +1,6 @@
+export default class Result {
+    status: number;
+    headers: Headers;
+    body: any;
+    constructor(body: any, response: Response);
+}

package/dist/types/utils/router.d.ts

@@ -0,0 +1,157 @@
+import Result from './result';
+declare type Version = number | undefined;
+declare type Server = string | undefined;
+declare type AccountShortName = string | undefined;
+declare type ProjectShortName = string | undefined;
+declare type Authorization = string | undefined;
+declare type QueryObject = Record<string, unknown>;
+declare type SearchParams = string | string[][] | URLSearchParams | QueryObject;
+export interface RoutingOptions {
+    authorization?: Authorization;
+    server?: Server;
+    accountShortName?: AccountShortName;
+    projectShortName?: ProjectShortName;
+    query?: SearchParams;
+    headers?: Record<string, string>;
+    body?: unknown;
+    includeAuthorization?: boolean;
+    inert?: boolean;
+    paginated?: boolean;
+    parsePage?: (values: any[]) => any[];
+}
+interface RequestOptions extends RoutingOptions {
+    method: string;
+}
+export interface RetryFunction<Output> {
+    (): Promise<Output>;
+    requestArguments?: {
+        url: URL;
+    } & RequestOptions;
+}
+export interface Page<Item> {
+    firstResult: number;
+    maxResults: number;
+    totalResults: number;
+    values: Item[];
+    prev: () => Promise<Item[]>;
+    next: () => Promise<Item[]>;
+    all: (first?: number, allValues?: Item[]) => Promise<Item[]>;
+}
+export interface GenericSearchOptions {
+    filter?: string[];
+    sort?: string[];
+    first?: number;
+    max?: number;
+}
+/**
+ * Used to make the network calls in all API adapters
+ */
+export default class Router {
+    _version: Version;
+    _server: Server;
+    _accountShortName: AccountShortName;
+    _projectShortName: ProjectShortName;
+    _authorization: Authorization;
+    _searchParams: URLSearchParams;
+    /**
+     * The version of the Epicenter APIs being invoked; expected to stay at `3`
+     */
+    get version(): Version;
+    set version(value: Version);
+    /**
+     * The root path used for the call, essentially protocol + hostname
+     * @type {string}
+     */
+    get server(): Server;
+    set server(value: Server);
+    /**
+     * Name of the account; for administrative use, this value should be set to 'epicenter'
+     * @type {string}
+     */
+    get accountShortName(): AccountShortName;
+    set accountShortName(value: AccountShortName);
+    /**
+     * Name of the project; for administrative use, this value should be set to 'manager'
+     * @type {string}
+     */
+    get projectShortName(): ProjectShortName;
+    set projectShortName(value: ProjectShortName);
+    /**
+     * Auth header; looks like `Bearer TOKEN` or `Basic TOKEN`
+     * @type {string}
+     */
+    get authorization(): Authorization;
+    set authorization(value: Authorization);
+    /**
+     * The search parameters for to use when making a network request. This property has should always return an instance of URLSearchParams or undefined. It has unique properties when used with the assignment operator (`=`); see the examples below for more details.
+     * @type {URLSearchParams}
+     *
+     * @example
+     * const router = new Router();
+     * router.searchParams = '?foo=123';
+     * console.log(router.searchParams);                            // always returns an instance object: URLSearchParams {}
+     * console.log(router.searchParams.toString());                 // logs 'foo=123'
+     *
+     * router.searchParams = 'foo=123';                             // can omit the question mark
+     * console.log(router.searchParams.toString());                 // logs 'foo=123'
+     *
+     * router.searchParams = [['foo', '123'], ['bar', '456']];      // can accept arrays
+     * console.log(router.searchParams.toString());                 // logs 'foo=123&bar=456'
+     *
+     * router.searchParams = { foo: '123', bar: '456' };            // can accept objects
+     * console.log(router.searchParams.toString());                 // logs 'foo=123&bar=456'
+     *
+     * router.searchParams = { foo: '123', bar: ['4', '5', '6'] };  // can accept objects with arrayed values
+     * console.log(router.searchParams.toString());                 // logs 'foo=123&bar=4&bar=5&bar=6'
+     *
+     * router.searchParams = new URLSearchParams('foo=123');        // can accept instances of URLSearchParams
+     * console.log(router.searchParams.toString());                 // logs 'foo=123'
+     *
+     * @param {object|array|string|URLSearchParams} query   Value used to set the search parameters
+     */
+    get searchParams(): SearchParams;
+    set searchParams(query: SearchParams);
+    /**
+     * Sets the version. Does nothing if invoked with no input. This is a part of a series of convenience functions for chaining sets on values.
+     * @param {string} [version]    Version to use
+     * @returns {Router}            The Router instance
+     */
+    withVersion(version?: Version): Router;
+    /**
+     * Sets the root path. Does nothing if invoked with no input. This is a part of a series of convenience functions for chaining sets on values.
+     * @param {string} [server] Root path to use
+     * @returns {Router}        The Router instance
+     */
+    withServer(server?: Server): Router;
+    /**
+     * Sets the account. Does nothing if invoked with no input. This is a part of a series of convenience functions for chaining sets on values.
+     * @param {string} [accountShortName]   Account name to use
+     * @returns {Router}                    The Router instance
+     */
+    withAccountShortName(accountShortName?: AccountShortName): Router;
+    /**
+     * Sets the project. Does nothing if invoked with no input. This is a part of a series of convenience functions for chaining sets on values.
+     * @param {string} [projectShortName]   Project name to use
+     * @returns {Router}                    The Router instance
+     */
+    withProjectShortName(projectShortName?: ProjectShortName): Router;
+    /**
+     * Sets the project. Does nothing if invoked with no input. This is a part of a series of convenience functions for chaining sets on values.
+     * @param {string} [projectShortName]   Project name to use
+     * @returns {Router}                    The Router instance
+     */
+    withAuthorization(authorization?: Authorization): Router;
+    /**
+     * Sets the search parameters. Does nothing if invoked with no input. This is a part of a series of convenience functions for chaining sets on values.
+     * @param {string|array|object|URLSearchParams} [searchParams]  Search parameters to use, utilizes the same setter as [searchParams](#Router-searchParams)
+     * @returns {Router}                                            The Router instance
+     */
+    withSearchParams(searchParams?: SearchParams): Router;
+    getURL(uriComponent: string): URL;
+    get(uriComponent: string, options?: RoutingOptions): Promise<Result>;
+    delete(uriComponent: string, options?: RoutingOptions): Promise<Result>;
+    patch(uriComponent: string, options?: RoutingOptions): Promise<Result>;
+    post(uriComponent: string, options?: RoutingOptions): Promise<Result>;
+    put(uriComponent: string, options?: RoutingOptions): Promise<Result>;
+}
+export {};

package/dist/types/utils/store.d.ts

@@ -0,0 +1,31 @@
+declare type NodeMap = Record<any, any>;
+declare type JavaScriptObject = Record<string, any>;
+declare type EpicenterStore = NodeMap | Storage;
+declare class Store {
+    _store: EpicenterStore;
+    constructor(store: EpicenterStore);
+    clear(): void;
+    get store(): EpicenterStore;
+    set store(store: EpicenterStore);
+}
+export declare class NodeStore extends Store {
+    constructor();
+    getItem(key: string): NodeMap;
+    setItem(key: string, value: JavaScriptObject): NodeMap;
+    removeItem(key: string): boolean;
+}
+export declare class SessionStore extends Store {
+    constructor();
+    getItem(key: string): JavaScriptObject;
+    setItem(key: string, value: JavaScriptObject): void;
+    removeItem(key: string): void;
+}
+export declare class CookieStore {
+    options: {};
+    constructor(options?: {});
+    getItem(key: string): JavaScriptObject;
+    setItem(key: string, value: JavaScriptObject): boolean;
+    removeItem(key: string): boolean;
+    clear(): string[];
+}
+export {};

package/package.json

@@ -0,0 +1,103 @@
+{
+  "name": "epicenter-libs",
+  "version": "3.11.0",
+  "main": "dist/cjs/epicenter.js",
+  "module": "dist/module/epicenter.js",
+  "browser": "dist/browser/epicenter.js",
+  "types": "dist/types/epicenter.d.ts",
+  "files": [
+    "dist/",
+    "src/",
+    "CHANGELOG.md"
+  ],
+  "scripts": {
+    "test": "karma start --browsers ChromeHeadless karma.conf.js",
+    "single-test": "karma start --browsers ChromeHeadless karma.conf.js --single-run",
+    "changelog": "npx conventional-changelog-cli -p angular -i CHANGELOG.md -s",
+    "changelog:all": "npx conventional-changelog -p angular -i CHANGELOG.md -s -r 0",
+    "type-check": "tsc --noEmit",
+    "type-check:watch": "npm run type-check -- --watch",
+    "build:clean": "rimraf dist",
+    "build:types": "tsc --emitDeclarationOnly",
+    "build:js": "rollup -c -m",
+    "build": "npm run build:clean && npm run build:types && npm run build:js",
+    "start": "rollup -c -m inline -w"
+  },
+  "browserslist": [
+    "defaults",
+    "not IE 11",
+    "maintained node versions"
+  ],
+  "commitlint": {
+    "extends": [
+      "@commitlint/config-conventional"
+    ],
+    "rules": {
+      "header-max-length": [
+        2,
+        "always",
+        72
+      ]
+    }
+  },
+  "pre-push": {
+    "run": [
+      "single-test"
+    ]
+  },
+  "husky": {
+    "hooks": {
+      "commit-msg": "commitlint -E HUSKY_GIT_PARAMS"
+    }
+  },
+  "dependencies": {
+    "cometd": "^4.0.9",
+    "cross-fetch": "^3.0.6"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.12.10",
+    "@babel/core": "^7.12.10",
+    "@babel/plugin-proposal-class-properties": "^7.12.1",
+    "@babel/plugin-proposal-nullish-coalescing-operator": "^7.12.1",
+    "@babel/plugin-proposal-numeric-separator": "^7.12.7",
+    "@babel/plugin-proposal-optional-chaining": "^7.12.7",
+    "@babel/plugin-proposal-private-methods": "^7.12.1",
+    "@babel/plugin-transform-runtime": "^7.15.0",
+    "@babel/preset-env": "^7.12.11",
+    "@babel/preset-typescript": "^7.12.7",
+    "@commitlint/cli": "^11.0.0",
+    "@commitlint/config-conventional": "^11.0.0",
+    "@rollup/plugin-alias": "^3.1.2",
+    "@rollup/plugin-babel": "^5.2.3",
+    "@rollup/plugin-commonjs": "^16.0.0",
+    "@rollup/plugin-node-resolve": "^10.0.0",
+    "@rollup/plugin-replace": "^2.3.4",
+    "@types/cometd": "^4.0.8",
+    "@typescript-eslint/eslint-plugin": "^4.14.2",
+    "@typescript-eslint/parser": "^4.14.2",
+    "babel-eslint": "^10.1.0",
+    "babel-loader": "^8.2.2",
+    "chai": "^4.2.0",
+    "conventional-changelog-cli": "^2.1.1",
+    "eslint": "^6.8.0",
+    "husky": "^4.3.8",
+    "karma": "^3.1.4",
+    "karma-chai": "^0.1.0",
+    "karma-chrome-launcher": "^2.2.0",
+    "karma-mocha": "^1.3.0",
+    "karma-mocha-reporter": "^2.2.5",
+    "karma-webpack": "^3.0.5",
+    "mocha": "^5.2.0",
+    "pre-push": "^0.1.1",
+    "rollup": "^2.38.4",
+    "rollup-plugin-filesize": "^9.1.0",
+    "rollup-plugin-progress": "^1.1.2",
+    "rollup-plugin-terser": "^7.0.2",
+    "rollup-plugin-visualizer": "^4.2.0",
+    "sinon": "^7.2.2",
+    "sinon-chai": "^3.5.0",
+    "typedoc": "^0.21.9",
+    "typescript": "^4.1.3",
+    "webpack": "^4.46.0"
+  }
+}

package/src/adapters/account.ts

@@ -0,0 +1,104 @@
+import type { RoutingOptions } from 'utils/router';
+import Router from 'utils/router';
+
+
+interface AccountReadView {
+    name: string;
+    objectType: string;
+}
+
+interface AccountCreateView {
+    adminKey: string;
+    name: string;
+    shortName: string;
+    sharedSecret?: string;
+    workerPartition?: string;
+    active?: boolean;
+}
+
+interface PersonalAccountCreateView extends AccountCreateView {
+    objectType: 'personal';
+}
+
+interface TeamAccountCreateView extends AccountCreateView {
+    objectType: 'team';
+    billingInterval: string;
+    subscriptionPlan: string;
+}
+
+interface AccountUpdateView {
+    name?: string;
+    workerPartition?: string;
+    active?: boolean;
+}
+
+interface PersonalAccountUpdateView extends AccountUpdateView {
+    objectType: 'personal';
+}
+
+interface TeamAccountUpdateView extends AccountUpdateView {
+    objectType: 'team';
+    billingInterval?: string;
+}
+
+export async function getAccount(accountShortName: string): Promise<AccountReadView> {
+    return await new Router()
+        .withAccountShortName(accountShortName)
+        .get('/account')
+        .then(({body}) => body);
+}
+
+export async function createAccount(view: PersonalAccountCreateView | TeamAccountCreateView): Promise<AccountReadView> {
+
+    return await new Router()
+        .withAccountShortName('epicenter')
+        .withProjectShortName('manager')
+        .post('/account', {
+            body: view,
+        }).then(({body}) => body);
+}
+
+export async function updateAccount(
+    view: PersonalAccountUpdateView | TeamAccountUpdateView,
+    optionals: RoutingOptions = {},
+): Promise<AccountReadView> {
+    return await new Router()
+        .patch('/account', {
+            body: view,
+            ...optionals,
+        }).then(({body}) => body);
+}
+
+export async function removeAccount(
+    accountShortName: string
+): Promise<void> {
+    return await new Router()
+        .withAccountShortName(accountShortName)
+        .delete('/account')
+        .then(({body}) => body);
+}
+
+export async function teamForAdmin(
+    adminKey: string,
+    optionals: {
+        includeAllMembers?: boolean,
+        filter?: string,
+        first?: number,
+        max?: number,
+    } & RoutingOptions = {},
+): Promise<AccountReadView[]> {
+    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);
+}

package/src/adapters/admin.ts

@@ -0,0 +1,53 @@
+import type { RoutingOptions } from '../utils/router';
+import Router from '../utils/router';
+
+export interface Secret {
+    password: string;
+}
+
+export interface AdminCreateView {
+    [key: string]: unknown,
+    handle: string;
+    email: string;
+    givenName?: string;
+    familyName?: string;
+    verified: true;
+    active?: true;
+}
+
+interface Admin {
+    lastUpdated: string,
+    lastLogin: string,
+    created: string,
+    familyName: string,
+    givenName: string,
+    verified: boolean,
+    handle: string,
+    active: boolean,
+    adminKey: string,
+    email: string,
+    objectType: 'external' | 'native',
+}
+
+export interface NativeAdminCreateView extends AdminCreateView {
+    objectType: 'native';
+    secret: Secret;
+}
+
+export async function createAdmin(view: AdminCreateView): Promise<Admin> {
+
+    return await new Router()
+        .withAccountShortName('epicenter')
+        .withProjectShortName('manager')
+        .post('/admin', {
+            body: view,
+        }).then(({body}) => body);
+}
+
+export async function getWithHandle(handle: string, optionals: RoutingOptions = {}) {
+    return await new Router()
+        .withAccountShortName('epicenter')
+        .withProjectShortName('manager')
+        .get(`/admin/with/${handle}`, optionals)
+        .then(({body}) => body);
+}