@hailer/app-sdk 1.0.0

package/lib/modules/ui/snackbar.js

@@ -0,0 +1,32 @@
+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 Snackbar {
+    constructor(client) {
+        this.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
+     * @param options object containing apiVersion option
+     */
+    open(
+    /** The text displayed on the snackbar */
+    text, 
+    /** The label for the button on the snackbar, for example 'OK' */
+    buttonLabel, 
+    /** The time the snackbar is visible in ms */
+    duration) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.client.requestAsync('v1.ui.snackbar.open', [text, buttonLabel, duration]);
+        });
+    }
+}

package/lib/modules/ui.d.ts

@@ -0,0 +1,11 @@
+import { Client } from '@wishcore/wish-rpc';
+import { Activity } from './ui/activity';
+import { Snackbar } from './ui/snackbar';
+import { Files } from './ui/files';
+export declare class Ui {
+    private client;
+    activity: Activity;
+    snackbar: Snackbar;
+    files: Files;
+    constructor(client: Client);
+}

package/lib/modules/ui.js

@@ -0,0 +1,11 @@
+import { Activity } from './ui/activity';
+import { Snackbar } from './ui/snackbar';
+import { Files } from './ui/files';
+export class Ui {
+    constructor(client) {
+        this.client = client;
+        this.activity = new Activity(client);
+        this.snackbar = new Snackbar(client);
+        this.files = new Files(client);
+    }
+}

package/lib/modules/user.d.ts

@@ -0,0 +1,39 @@
+import { Client } from '@wishcore/wish-rpc';
+import { HailerUser } from '../types';
+export declare class User {
+    private client;
+    constructor(client: Client);
+    /**
+     * Returns the specified user
+     *
+     * @param userId id of the Hailer user
+     * @param options object containing apiVersion option
+     *
+     * @returns Hailer user information
+     *
+     * @throws {HailerError} if request is incorrect
+     */
+    get(userId: string): Promise<HailerUser>;
+    /**
+     * Returns the current user
+     *
+     * @param options object containing apiVersion option
+     *
+     * @returns the current Hailer user information
+     *
+     * @throws {HailerError} if request is incorrect
+     */
+    current(): Promise<HailerUser>;
+    /**
+     * Lists all Hailer users from a workspace
+     *
+     * @param options object containing apiVersion option
+     *
+     * @returns list of Hailer users in the workspace the app user is currently in
+     *
+     * @throws {HailerError} if request is incorrect
+     */
+    list(): Promise<{
+        [key: string]: HailerUser;
+    }>;
+}

package/lib/modules/user.js

@@ -0,0 +1,76 @@
+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 User {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Returns the specified user
+     *
+     * @param userId id of the Hailer user
+     * @param options object containing apiVersion option
+     *
+     * @returns Hailer user information
+     *
+     * @throws {HailerError} if request is incorrect
+     */
+    get(userId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const res = yield this.client.requestAsync('v1.user.get', [userId]);
+                return res;
+            }
+            catch (error) {
+                throw new HailerError(error);
+            }
+        });
+    }
+    /**
+     * Returns the current user
+     *
+     * @param options object containing apiVersion option
+     *
+     * @returns the current Hailer user information
+     *
+     * @throws {HailerError} if request is incorrect
+     */
+    current() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const res = yield this.client.requestAsync('v1.user.current', []);
+                return res;
+            }
+            catch (error) {
+                throw new HailerError(error);
+            }
+        });
+    }
+    /**
+     * Lists all Hailer users from a workspace
+     *
+     * @param options object containing apiVersion option
+     *
+     * @returns list of Hailer users 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 users = yield this.client.requestAsync('v1.user.list', []);
+                return users;
+            }
+            catch (error) {
+                throw new HailerError(error);
+            }
+        });
+    }
+}

package/lib/modules/workflow.d.ts

@@ -0,0 +1,25 @@
+import { Client } from '@wishcore/wish-rpc';
+import { HailerProcess } from '../types';
+export declare class Workflow {
+    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<HailerProcess[]>;
+    /**
+     * Gets a single process from a workspace
+     *
+     * @param processId the id of the process in question
+     * @param options object containing apiVersion option
+     *
+     * @returns the specified Hailer process
+     *
+     * @throws {HailerError} if request is incorrect
+     */
+    get(processId: string): Promise<HailerProcess>;
+}

package/lib/modules/workflow.js

@@ -0,0 +1,54 @@
+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 Workflow {
+    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.workflow.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
+     * @param options object containing apiVersion option
+     *
+     * @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.workflow.get', [processId]);
+                return process;
+            }
+            catch (error) {
+                throw new HailerError(error);
+            }
+        });
+    }
+}

package/lib/types.d.ts

@@ -0,0 +1,326 @@
+export interface HailerUser {
+    firstname: string;
+    lastname: string;
+    email: string;
+    lastSeen: number;
+    status?: string;
+    managedUser?: boolean;
+    removed?: number;
+}
+export interface HailerWorkspace {
+    _id: string;
+    name: string;
+    members: string[];
+    settings: {
+        isolatedTeams?: boolean;
+        defaultView: string;
+        functionFieldVersion?: 1 | 2;
+        color?: string;
+        allowPublicCopy?: boolean;
+    };
+    license: object;
+    invoicing?: any;
+    propertyFields?: {
+        [section: string]: {
+            [field: string]: any;
+        };
+    };
+}
+export interface HailerActivity {
+    _id: string;
+    process: string;
+    teamAccount: TeamAccount;
+    created: number;
+    uid: string;
+    cid: string;
+    discussion: string;
+    currentPhase: string;
+    active?: boolean;
+    history?: any[];
+    name?: string;
+    followers?: string[];
+    completePhases?: string[];
+    location?: {
+        type: 'point' | 'area' | 'polyline';
+        label: string | null;
+        data: {
+            lat: number;
+            lng: number;
+        }[];
+    };
+    fields?: any;
+    files?: any[];
+    updated?: number;
+    updatedBy?: string;
+    priority?: number;
+    sequence?: number;
+}
+export interface TeamAccount {
+    account: string;
+    team: string;
+}
+export interface Link {
+    id: string;
+    linkId: string;
+    type: LinkType;
+    created: string;
+}
+export type LinkType = 'user-mention' | 'reaction' | 'tag' | 'apple-id' | 'feed.lastseen' | 'google-folder-id';
+export interface FormsData {
+    files: string[];
+    history: {
+        0: {
+            [fieldId: string]: {
+                value: any;
+            };
+        };
+    };
+    name: string;
+    location?: boolean;
+    uid?: string;
+}
+export interface FormsResponse {
+    name: string;
+    description?: string;
+    enableUnlinkedMode: boolean;
+    enableAttachments: boolean;
+    enableMapLocation: boolean;
+    locationRequired: 1;
+    phases: {
+        _id: string;
+        followers: [];
+        name: string;
+        description: string;
+        uid: string;
+        created: number;
+        fields: string[];
+        announcementFields: [];
+        announcementRecipients: [];
+        announcementFieldsOrder: [];
+        isEndpoint: boolean;
+    }[];
+    phasesOrder: string[];
+    fields: {
+        [id: string]: {
+            data: [];
+            label: string;
+            required: boolean;
+            type: string;
+            inviteToDiscussionOnChange: boolean;
+            _id: string;
+            created: number;
+            updated: number;
+            uid: string;
+            functionEnabled: boolean;
+        };
+    };
+    enableMessenger: boolean;
+    publicForm: {
+        enableMessaging: boolean;
+    };
+    fieldsOrder: [];
+}
+export interface FormCreateResponse {
+    key: string;
+    creator: string;
+    followers: string;
+    active: boolean;
+    enableMessaging: boolean;
+    allowRead: boolean;
+}
+export interface InsightResponse {
+    insight: {
+        name: string;
+    };
+    data: InsightResponseData;
+}
+export interface InsightResponseData {
+    headers: string[];
+    rows: [];
+    time: number;
+}
+export interface HailerAppConfig {
+    fields?: {
+        [fieldName: string]: {
+            type: string;
+            value?: string | number | boolean;
+        };
+    };
+}
+export interface HailerProcess {
+    _id: string;
+    cid: string;
+    name: string;
+    description?: string;
+    fields: {
+        [fieldId: string]: any;
+    };
+    phases: {
+        [phase_id: string]: HailerPhase;
+    };
+}
+export interface HailerPhase {
+    _id: string;
+    name: string;
+    description?: string;
+}
+export type PermissionType = 'admin' | 'own' | 'ownteam' | 'any' | 'edit';
+export interface MemberDoc {
+    id: string;
+    info: {
+        [key: string]: string | number | boolean | null;
+    };
+    permissions: PermissionType[];
+}
+export interface InsightWorkflowSource {
+    name: string;
+    workflowId: string;
+    fields: {
+        name: string;
+        fieldId?: string;
+        /** Used for phaseLastMove meta */
+        phaseId?: string;
+        /** Activity information, like _id, created, phaseId etc. */
+        meta?: string;
+    }[];
+}
+export interface InsightDoc {
+    name: string;
+    sources: InsightWorkflowSource[];
+    cid: string;
+    /** User id of creator */
+    uid: string;
+    members: MemberDoc[];
+    updated: number;
+    public: boolean;
+    /** Key for accessing Insight when set to public */
+    publicKey?: string;
+    /** sandboxed javascript with access to all activities in given workflows */
+    function?: string;
+    /** To be used with SQLite if we want to.... */
+    query?: string;
+}
+export interface InsightData {
+    headers: string[];
+    rows: (string | number | null)[][];
+    time: number;
+}
+export interface InsightResponseAsObjectItem {
+    [key: string]: any;
+}
+export type InsightResponseAsObjects = InsightResponseAsObjectItem[];
+export interface KanbanListResponse {
+    map: {
+        [phaseId: string]: {
+            activities: {
+                _id: string;
+                followers: string[];
+                name: string;
+                fields: {
+                    [key: string]: any;
+                };
+                files: string[];
+                primaryDateField: number;
+                priority: number;
+            }[];
+            meta: {
+                count: number;
+                totalPrimaryNumericValue: number;
+                primaryNumericFieldUnit: string | null;
+            };
+        };
+    };
+}
+export interface KanbanLoadResponse {
+    activity: {
+        _id: string;
+        followers: string[];
+        name: string;
+        fields: {
+            [key: string]: any;
+        };
+        files: string[];
+        primaryDateField: number | null;
+        priority: number;
+        linkedFromCount: number;
+    };
+    process: string;
+    phase: string;
+}
+export interface ActivityListOptions {
+    sortBy?: 'name' | 'created' | 'updated' | 'following' | 'owner' | 'team' | 'completedOn' | 'priority';
+    sortOrder?: 'asc' | 'desc';
+    limit?: number;
+    skip?: number;
+    includeUsers?: boolean;
+    includeTeams?: boolean;
+    includeHistory?: boolean;
+    filters?: any;
+}
+export interface ActivityCreateOptions {
+    teamId?: string;
+    fileIds?: string[];
+    followerIds?: string[];
+    location?: {
+        label?: string;
+        type: 'area' | 'point' | 'polyline';
+        data: [{
+            lat: number;
+            lng: number;
+        }];
+    };
+    discussionId?: string;
+    phaseId?: string;
+    returnDocument?: boolean;
+}
+export interface ActivityKanbanListOptions {
+    filter: {
+        user?: {
+            uid: string;
+            field: string;
+        };
+        account?: string;
+        team?: string;
+        dates?: {
+            field: string;
+            start: number;
+            end: number;
+        };
+    };
+    search?: string;
+    limit?: number;
+    skip?: number;
+    phase?: string;
+    includeUsers?: boolean;
+    includeTeams?: boolean;
+}
+export type ApiVersion = 1;
+export interface HailerSettings {
+    theme: 'light' | 'dark';
+    preferredLanguages: string[];
+}
+export interface HailerError {
+    code: number;
+    msg: string;
+    debug: object;
+}
+export interface HailerApiInfo {
+    /** Url of the Hailer instance hosting the API */
+    hostUrl?: string;
+    config?: HailerAppConfig;
+    outside: boolean | null;
+}
+export declare class HailerError extends Error {
+    code: number;
+    msg: string;
+    debug: object;
+    constructor(error: {
+        code: number;
+        msg: string;
+        debug: object;
+    });
+}
+export interface HailerSignal {
+    sig: string;
+    meta: any;
+}

package/lib/types.js

@@ -0,0 +1,9 @@
+export class HailerError extends Error {
+    constructor(error) {
+        super();
+        this.code = error.code;
+        this.msg = error.msg;
+        this.debug = error.debug;
+        Object.setPrototypeOf(this, HailerError.prototype);
+    }
+}

package/package.json

@@ -0,0 +1,28 @@
+{
+    "name": "@hailer/app-sdk",
+    "version": "1.0.0",
+    "description": "SDK for building Hailer Apps",
+    "author": "",
+    "license": "ISC",
+    "main": "./lib/index.js",
+    "types": "./lib/index.d.ts",
+    "files": [
+        "./lib/**/*"
+    ],
+    "scripts": {
+        "build": "tsc",
+        "docs": "typedoc --entryPointStrategy expand ./src && open-cli ./docs/index.html"
+    },
+    "dependencies": {
+        "@wishcore/wish-rpc": "0.6.11"
+    },
+    "devDependencies": {
+        "@types/node": "^18.15.10",
+        "@typescript-eslint/eslint-plugin": "^5.60.0",
+        "@typescript-eslint/parser": "^5.60.0",
+        "eslint": "^8.43.0",
+        "open-cli": "^7.2.0",
+        "typedoc": "^0.24.8",
+        "typescript": "^5.1.3"
+    }
+}