@hailer/app-sdk 1.0.0-beta

package/lib/modules/insight.js

@@ -0,0 +1,52 @@
+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());
+    });
+};
+import { HailerError } from '../types';
+export class InsightApi {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Get Insight data
+     *
+     * @param insightId the id of the Insight the data is fetched from
+     *
+     * @returns data from the Insight
+     *
+     * @throws {HailerError} if request is incorrect
+     */
+    data(insightId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this.client.requestAsync('v1.insight.data', [insightId]);
+            }
+            catch (error) {
+                throw new HailerError(error);
+            }
+        });
+    }
+    /**
+     * Get Insight data
+     *
+     *
+     * @returns data from the Insight
+     *
+     * @throws {HailerError} if request is incorrect
+     */
+    list() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this.client.requestAsync('v1.insight.list', []);
+            }
+            catch (error) {
+                throw new HailerError(error);
+            }
+        });
+    }
+}

package/lib/modules/network.d.ts

@@ -0,0 +1,14 @@
+import { Client } from '@wishcore/wish-rpc';
+import { Workspace } from '../types';
+export declare class WorkspaceApi {
+    private client;
+    constructor(client: Client);
+    /**
+     * Returns the current network
+     *
+     * @returns the Hailer Workspace information the user is currently in
+     *
+     * @throws {HailerError} if request is incorrect
+     */
+    current(): Promise<Workspace>;
+}

package/lib/modules/network.js

@@ -0,0 +1,33 @@
+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());
+    });
+};
+import { HailerError } from '../types';
+export class WorkspaceApi {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Returns the current network
+     *
+     * @returns the Hailer Workspace information the user is currently in
+     *
+     * @throws {HailerError} if request is incorrect
+     */
+    current() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const res = yield this.client.requestAsync('v1.network.current', []);
+                return res;
+            }
+            catch (error) {
+                throw new HailerError(error);
+            }
+        });
+    }
+}

package/lib/modules/process.d.ts

@@ -0,0 +1,38 @@
+import { Client } from '@wishcore/wish-rpc';
+import { HailerProcess } from '../types';
+/** @deprecated Use Workflow instead */
+export declare class Process {
+    private client;
+    constructor(client: Client);
+    /**
+     * Lists all processes from a workspace
+     *
+     * @returns all Hailer processes in the workspace the app user is currently in
+     *
+     * @throws {HailerError} if request is incorrect
+     */
+    list(): Promise<{
+        [key: string]: HailerProcess;
+    }>;
+    /**
+     * Gets a single process from a workspace
+     *
+     * @param processId the id of the process in question
+     *
+     * @returns the specified Hailer process
+     *
+     * @throws {HailerError} if request is incorrect
+     */
+    get(processId: string): Promise<HailerProcess>;
+    /**
+     * Gets an id of a field in a process by its name
+     *
+     * @param processId the id of the process in question
+     * @param fieldName name of the field
+     *
+     * @returns the field id as string
+     *
+     * @throws {HailerError} if request is incorrect
+     */
+    getFieldIdByName(processId: string, fieldName: string): Promise<string>;
+}

package/lib/modules/process.js

@@ -0,0 +1,75 @@
+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());
+    });
+};
+import { HailerError } from '../types';
+/** @deprecated Use Workflow instead */
+export class Process {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Lists all processes from a workspace
+     *
+     * @returns all Hailer processes in the workspace the app user is currently in
+     *
+     * @throws {HailerError} if request is incorrect
+     */
+    list() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const processes = yield this.client.requestAsync('v1.process.list', []);
+                return processes;
+            }
+            catch (error) {
+                throw new HailerError(error);
+            }
+        });
+    }
+    /**
+     * Gets a single process from a workspace
+     *
+     * @param processId the id of the process in question
+     *
+     * @returns the specified Hailer process
+     *
+     * @throws {HailerError} if request is incorrect
+     */
+    get(processId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const process = yield this.client.requestAsync('v1.process.get', [processId]);
+                return process;
+            }
+            catch (error) {
+                throw new HailerError(error);
+            }
+        });
+    }
+    /**
+     * Gets an id of a field in a process by its name
+     *
+     * @param processId the id of the process in question
+     * @param fieldName name of the field
+     *
+     * @returns the field id as string
+     *
+     * @throws {HailerError} if request is incorrect
+     */
+    getFieldIdByName(processId, fieldName) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return (_b = Object.values(((_a = (yield this.get(processId))) === null || _a === void 0 ? void 0 : _a.fields) || {}).find((field) => field.label.toLowerCase() === fieldName)) === null || _b === void 0 ? void 0 : _b._id;
+            }
+            catch (error) {
+                throw new HailerError(error);
+            }
+        });
+    }
+}

package/lib/modules/public/app.d.ts

@@ -0,0 +1,17 @@
+import { Options } from '../../hailer-api';
+import { HailerAppConfig } from '../../types';
+export declare class App {
+    private options;
+    constructor(options: Options);
+    /**
+     * Read data from app API
+     *
+     * @param appId key of a specific insight
+     *
+     * @returns App manifest
+     *
+     * @throws {HailerError} if there is something wrong with the request or insight cannot be found
+     * @throws {TypeError} if Hailer cannot be reached
+     */
+    config(): Promise<HailerAppConfig>;
+}

package/lib/modules/public/app.js

@@ -0,0 +1,45 @@
+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());
+    });
+};
+export class App {
+    constructor(options) {
+        this.options = options;
+    }
+    /**
+     * Read data from app API
+     *
+     * @param appId key of a specific insight
+     *
+     * @returns App manifest
+     *
+     * @throws {HailerError} if there is something wrong with the request or insight cannot be found
+     * @throws {TypeError} if Hailer cannot be reached
+     */
+    config() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const manifestFile = 'manifest.json';
+            const location = window.location.origin + window.location.pathname;
+            let manifestUrl = location + manifestFile;
+            if (location.endsWith('/index.html')) {
+                manifestUrl = location.slice(0, -10) + manifestFile;
+            }
+            const manifestContent = yield (yield fetch(manifestUrl)).text();
+            const manifest = JSON.parse(manifestContent);
+            const appId = manifest.appId;
+            const res = yield fetch(this.options.publicBackendUrl + '/api/v3/app/public', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify([appId])
+            });
+            return yield res.json();
+        });
+    }
+}

package/lib/modules/public/form.d.ts

@@ -0,0 +1,31 @@
+import { Options } from '../../hailer-api';
+import { FormCreateResponse, FormsData, FormsResponse } from '../../types';
+export declare class Form {
+    private options;
+    constructor(options: Options);
+    /**
+     * Read data from forms
+     *
+     * @param formsKey key of a form
+     * @param options Overrides default request options, url defaults to https://api.hailer.com/api/v2/forms
+     *
+     * @returns forms data as object or null if form could not be found
+     *
+     * @throws {HailerError} if there is something wrong with the request or form cannot be found
+     * @throws {TypeError} if Hailer cannot be reached
+     */
+    data(formsKey: string): Promise<FormsResponse>;
+    /**
+     * Submits form to specified process
+     *
+     * @param formsKey key of a form
+     * @param formsData Data to be sent to form endpoint
+     * @param options Overrides default request options, url defaults to https://api.hailer.com/api/v2/forms
+     *
+     * @returns form creation data or null if form could not be created
+     *
+     * @throws {HailerError} if there is something wrong with the request or form cannot be found
+     * @throws {TypeError} if Hailer cannot be reached
+     */
+    submit(formsKey: string, formsData: FormsData): Promise<FormCreateResponse>;
+}

package/lib/modules/public/form.js

@@ -0,0 +1,68 @@
+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());
+    });
+};
+import { HailerError } from '../../types';
+export class Form {
+    constructor(options) {
+        this.options = options;
+    }
+    /**
+     * Read data from forms
+     *
+     * @param formsKey key of a form
+     * @param options Overrides default request options, url defaults to https://api.hailer.com/api/v2/forms
+     *
+     * @returns forms data as object or null if form could not be found
+     *
+     * @throws {HailerError} if there is something wrong with the request or form cannot be found
+     * @throws {TypeError} if Hailer cannot be reached
+     */
+    data(formsKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield fetch(this.options.publicBackendUrl + '/api/v2/forms/process/get', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify([formsKey])
+            });
+            if (!res.ok) {
+                throw new HailerError(yield res.json());
+            }
+            return yield res.json();
+        });
+    }
+    /**
+     * Submits form to specified process
+     *
+     * @param formsKey key of a form
+     * @param formsData Data to be sent to form endpoint
+     * @param options Overrides default request options, url defaults to https://api.hailer.com/api/v2/forms
+     *
+     * @returns form creation data or null if form could not be created
+     *
+     * @throws {HailerError} if there is something wrong with the request or form cannot be found
+     * @throws {TypeError} if Hailer cannot be reached
+     */
+    submit(formsKey, formsData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield fetch(this.options.publicBackendUrl + '/api/v2/forms/activity/create', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify([formsKey, formsData])
+            });
+            if (!res.ok) {
+                throw new HailerError(yield res.json());
+            }
+            return yield res.json();
+        });
+    }
+}

package/lib/modules/public/insight.d.ts

@@ -0,0 +1,30 @@
+import { Options } from '../../hailer-api';
+import { InsightResponse, InsightResponseAsObjects } from '../../types';
+export declare class InsightPublicApi {
+    private options;
+    constructor(options: Options);
+    /**
+     * Read data from insight API
+     *
+     * @param insightKey key of a specific insight
+     * @param options Overrides default request options, url defaults to https://api.hailer.com/api/v3/insight/public
+     *
+     * @returns Insight data as object
+     *
+     * @throws {HailerError} if there is something wrong with the request or insight cannot be found
+     * @throws {TypeError} if Hailer cannot be reached
+     */
+    data(insightKey: string): Promise<InsightResponse>;
+    /**
+     * Read data from insight API and return in an array of JavaScript objects
+     *
+     * @param insightKey key of a specific insight
+     * @param options Overrides default request options, url defaults to https://api.hailer.com/api/v3/insight/public
+     *
+     * @returns Insight data as array of JavaScript objects
+     *
+     * @throws {HailerError} if there is something wrong with the request or insight cannot be found
+     * @throws {TypeError} if Hailer cannot be reached
+     */
+    dataAsObject(insightKey: string): Promise<InsightResponseAsObjects>;
+}

package/lib/modules/public/insight.js

@@ -0,0 +1,69 @@
+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());
+    });
+};
+import { HailerError } from '../../types';
+export class InsightPublicApi {
+    constructor(options) {
+        this.options = options;
+    }
+    /**
+     * Read data from insight API
+     *
+     * @param insightKey key of a specific insight
+     * @param options Overrides default request options, url defaults to https://api.hailer.com/api/v3/insight/public
+     *
+     * @returns Insight data as object
+     *
+     * @throws {HailerError} if there is something wrong with the request or insight cannot be found
+     * @throws {TypeError} if Hailer cannot be reached
+     */
+    data(insightKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield fetch(this.options.publicBackendUrl + '/api/v3/insight/public', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify([insightKey])
+            });
+            if (!res.ok) {
+                throw new HailerError(yield res.json());
+            }
+            return yield res.json();
+        });
+    }
+    /**
+     * Read data from insight API and return in an array of JavaScript objects
+     *
+     * @param insightKey key of a specific insight
+     * @param options Overrides default request options, url defaults to https://api.hailer.com/api/v3/insight/public
+     *
+     * @returns Insight data as array of JavaScript objects
+     *
+     * @throws {HailerError} if there is something wrong with the request or insight cannot be found
+     * @throws {TypeError} if Hailer cannot be reached
+     */
+    dataAsObject(insightKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.data(insightKey);
+            const input = res.data;
+            const data = [];
+            input.rows.forEach((row) => {
+                // The object keys are constructed dynamically, so any is necessary
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const object = {};
+                input.headers.forEach((header, headerIndex) => {
+                    object[header] = row[headerIndex];
+                });
+                data.push(object);
+            });
+            return data;
+        });
+    }
+}

package/lib/modules/public.d.ts

@@ -0,0 +1,16 @@
+import { Options } from '../hailer-api';
+import { App } from './public/app';
+import { Form } from './public/form';
+import { InsightPublicApi } from './public/insight';
+/**
+ * This class is used to access Hailer public API even when the app is outside of Hailer
+ */
+export declare class HailerPublicApi {
+    /** Allows accessing public insight methods. Used for reading data from Hailer even when app is outside of Hailer */
+    insight: InsightPublicApi;
+    /** Allows accessing public forms methods. Used for sending data to Hailer even when app is outside of Hailer */
+    form: Form;
+    /** Access public App information */
+    app: App;
+    constructor(options: Options);
+}

package/lib/modules/public.js

@@ -0,0 +1,13 @@
+import { App } from './public/app';
+import { Form } from './public/form';
+import { InsightPublicApi } from './public/insight';
+/**
+ * This class is used to access Hailer public API even when the app is outside of Hailer
+ */
+export class HailerPublicApi {
+    constructor(options) {
+        this.insight = new InsightPublicApi(options);
+        this.form = new Form(options);
+        this.app = new App(options);
+    }
+}

package/lib/modules/ui/activity.d.ts

@@ -0,0 +1,28 @@
+import { Client } from '@wishcore/wish-rpc';
+export type ActivityTabTypes = 'detail' | 'discussion' | 'files' | 'location' | 'linkedFrom' | 'options';
+export declare class Activity {
+    private client;
+    constructor(client: Client);
+    /** Opens an activity in Hailer sidebar */
+    open(
+    /** Hailer Activity Id */
+    activityId: string, options?: {
+        /** Which tab to open in activity aside */
+        tab?: ActivityTabTypes;
+    }): Promise<void>;
+    /** Opens activity creation view in Hailer sidebar */
+    create(processId: string, options?: {
+        /** Activity name/title */
+        name?: string;
+        /** Prepopulate fields */
+        fields?: {
+            [fieldId: string]: number | string | {
+                start: number;
+                end: number;
+            };
+        };
+    }): Promise<{
+        _id: string;
+        name: string;
+    } | null>;
+}

package/lib/modules/ui/activity.js

@@ -0,0 +1,28 @@
+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());
+    });
+};
+export class Activity {
+    constructor(client) {
+        this.client = client;
+    }
+    /** Opens an activity in Hailer sidebar */
+    open(
+    /** Hailer Activity Id */
+    activityId, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.client.requestAsync('v1.ui.activity.open', [activityId, ...options ? [options] : []]);
+        });
+    }
+    /** Opens activity creation view in Hailer sidebar */
+    create(processId, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.client.requestAsync('v1.ui.activity.create', [processId, ...options ? [options] : []]);
+        });
+    }
+}

package/lib/modules/ui/files.d.ts

@@ -0,0 +1,18 @@
+import { Client } from '@wishcore/wish-rpc';
+export declare class Files {
+    private client;
+    constructor(client: Client);
+    /**
+    * Uploads a file to Hailer
+    *
+    * @param file file to be uploaded
+    * @param publicFile is the file accessible outside of Hailer
+    * @param options if file is public
+    *
+    * @returns File ID in Hailer as string
+    */
+    uploadFile(file: File, filename: string, options: {
+        isPublic?: boolean;
+    }): Promise<string>;
+    private toBase64;
+}

package/lib/modules/ui/files.js

@@ -0,0 +1,36 @@
+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());
+    });
+};
+export class Files {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+    * Uploads a file to Hailer
+    *
+    * @param file file to be uploaded
+    * @param publicFile is the file accessible outside of Hailer
+    * @param options if file is public
+    *
+    * @returns File ID in Hailer as string
+    */
+    uploadFile(file, filename, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.client.requestAsync('v1.ui.file.upload', [yield this.toBase64(file), filename, !!(options === null || options === void 0 ? void 0 : options.isPublic)]);
+        });
+    }
+    toBase64(file) {
+        return new Promise((resolve, reject) => {
+            const reader = new FileReader();
+            reader.readAsDataURL(file);
+            reader.onload = () => { var _a; return resolve((_a = reader.result) !== null && _a !== void 0 ? _a : ''); };
+            reader.onerror = reject;
+        });
+    }
+}

package/lib/modules/ui/snackbar.d.ts

@@ -0,0 +1,18 @@
+import { Client } from '@wishcore/wish-rpc';
+export declare class Snackbar {
+    private client;
+    constructor(client: Client);
+    /**
+     * Opens a snackbar in Hailer
+     * @param text the text displayed on the snackbar
+     * @param buttonLabel the label for the button on the snackbar, for example 'OK'
+     * @param duration the time the snackbar is visible in ms
+     */
+    open(
+    /** The text displayed on the snackbar */
+    text: string, 
+    /** The label for the button on the snackbar, for example 'OK' */
+    buttonLabel: string, 
+    /** The time the snackbar is visible in ms */
+    duration?: number): Promise<void>;
+}