@hailer/app-sdk 1.0.2 → 2.0.0-beta-1

package/lib/hailer-api.d.ts

@@ -1,17 +1,14 @@
 import { UserApi } from './modules/user';
 import { ActivityApi } from './modules/activity';
 import { WorkspaceApi } from './modules/workspace';
-import { HailerApiInfo, HailerSettings, HailerSignal } from './types';
+import { ApiInfo, Settings, Signal } from './types';
 import { Ui } from './modules/ui';
-import { Process } from './modules/process';
 import { HailerPublicApi } from './modules/public';
 import { WorkflowApi } from './modules/workflow';
 import { AppApi } from './modules/app';
 import { InsightApi } from './modules/insight';
 import { PermissionApi } from './modules/permission';
 import { ProductApi } from './modules/product';
-import { ProductVersionApi } from './modules/product-version';
-import { ProductInstalledApi } from './modules/product-installed';
 export interface Options {
     /** When connected is called the host is ready to receive calls */
     connected?: () => void;
@@ -22,23 +19,13 @@ export interface Options {
     /** Callback called on app init and when permissions have changed */
     permissions?: () => void;
     /** Callback called on app init and when settings have changed */
-    settings?: (data: HailerSettings) => void;
+    settings?: (data: Settings) => void;
     /** Callback called on app init and when config has changed */
     config?: (config: any) => void;
     /** Will be called each time a subscribed signal is emitted from Hailer frontend. To subscribe to signals, add them to options.subscribedSignals[] */
-    signals?: (signal: HailerSignal) => void;
+    signals?: (signal: Signal) => void;
     /** Urls the sdk is allowed to connect to. Defaults to all Hailer instances*/
     allowedUrls?: string[];
-    /**
-     * Optional signal filter, passes all signals by default
-     *
-     * Example:
-     *
-     *     subscribedSignals: ['activity.create', 'activity.update']
-     */
-    subscribedSignals?: string[];
-    /** Api version to be used in the app by default */
-    apiVersion?: 1;
     /** Public backend Api url. Defaults to https://api.hailer.com */
     publicBackendUrl?: string;
 }
@@ -49,12 +36,9 @@ export declare class HailerApi {
     activity: ActivityApi;
     insight: InsightApi;
     workspace: WorkspaceApi;
-    process: Process;
     workflow: WorkflowApi;
     permission: PermissionApi;
     product: ProductApi;
-    productVersion: ProductVersionApi;
-    productInstalled: ProductInstalledApi;
     /** All public endpoints, which can be accessed while not logged in to Hailer. */
     public: HailerPublicApi;
     /** User interface commands */
@@ -65,10 +49,7 @@ export declare class HailerApi {
     /** If set it indicates that app is locked to a specific workspaceId */
     private workspaceId?;
     private client;
-    private apiVersion;
-    private settings?;
     private config?;
-    private subscribedSignals?;
     private timer?;
     /**
      * Hailer API state
@@ -87,6 +68,5 @@ export declare class HailerApi {
      */
     constructor(options?: Options);
     private createEventListener;
-    info(): HailerApiInfo;
-    request(op: string, args: any[]): Promise<any>;
+    info(): ApiInfo;
 }

package/lib/modules/activity.d.ts

@@ -1,5 +1,5 @@
 import { Client } from '@wishcore/wish-rpc';
-import { ActivityCreateOptions, ActivityListOptions, Activity } from '../types';
+import { ActivityCreateOptions, ActivityListOptions, Activity, ActivityFieldUpdateValue, ActivityUpdateOptions, ActivityFieldValue } from '../types';
 import { Kanban } from './activity/kanban';
 export declare class ActivityApi {
     private client;
@@ -33,30 +33,17 @@ export declare class ActivityApi {
     /**
      * Creates activities
      *
-     * @param processId The process where the activity is created
-     * @param activities new activities as objects
-     * @param activities.name name of the activity
-     * @param activities.fields fields of the activity
-     * @param options ActivityCreateOptions
-     *
      * @throws {HailerError} if request is incorrect
      */
-    create(processId: string, activities: {
-        name: string;
+    create(workflowId: string | undefined, activities: {
+        name?: string;
         fields?: {
-            [id: string]: string | number;
+            [id: string]: ActivityFieldValue;
         };
     }[], options?: ActivityCreateOptions): Promise<Activity[]>;
     /**
      * Updates activites
      *
-     * Each activity has the following parameters
-     * @param activities updated activity objects of an activity to edit
-     * @param activities.name New name of the activity
-     * @param activities.fields change values of fields, null removes current value
-     * @param activities.phaseId New phase of the activity
-     * @param options
-     *
      * @returns The number of updated activities
      *
      * @throws {HailerError} if request is incorrect
@@ -65,10 +52,10 @@ export declare class ActivityApi {
         _id: string;
         name?: string;
         fields?: {
-            [id: string]: string | number | null;
+            [id: string]: ActivityFieldUpdateValue;
         };
         phaseId?: string;
-    }[], options: any): Promise<number>;
+    }[], options?: ActivityUpdateOptions): Promise<number>;
     /**
      * Removes activities
      *

package/lib/modules/app.d.ts

@@ -1,12 +1,76 @@
 import { Client } from '@wishcore/wish-rpc';
-import { HailerAppConfig } from '../types';
+import { Config, ProductVersion, Version } from '../types';
 /**
  * This class is used to access Hailer public API even when the app is outside of Hailer
  */
 export declare class AppApi {
     private client;
+    product: {
+        /** Check if product is installed */
+        isProductInstalled(id: string): Promise<boolean>;
+        /** Get version */
+        get(id: string): Promise<ProductVersion | undefined>;
+        /** Install app from Hailer market */
+        install(id: string): Promise<boolean>;
+        /** Get installed version */
+        getInstalledVersion(id: string): Promise<Version>;
+        /** Get manifest content from Hailer market */
+        getManifest(id: string): Promise<any>;
+    };
     constructor(client: Client);
     config: {
-        update: (appId: string | undefined, config: HailerAppConfig) => Promise<void>;
+        update: (config: Config, option?: {
+            appId?: string;
+        }) => Promise<void>;
     };
+    /**
+     * Check if product is installed
+     *
+     * @param id Id of product in Hailer market
+     *
+     * @returns true if ok else false
+     *
+     * @throws {HailerError} if request is incorrect
+     */
+    private isProductInstalled;
+    /**
+     * Get version
+     *
+     * @param id targetId
+     *
+     * @returns true if ok else false
+     *
+     * @throws {HailerError} if request is incorrect
+     */
+    private get;
+    /**
+     * Install app from Hailer market
+     *
+     * @param id Id of product in Hailer market
+     *
+     * @returns true, if installed else error
+     *
+     * @throws {HailerError} if request is incorrect
+     */
+    private install;
+    /**
+     * Get installed version from Hailer market
+     *
+     * @param id Id of product in Hailer market
+     *
+     * @returns true, if installed else error
+     *
+     * @throws {HailerError} if request is incorrect
+     */
+    private getInstalledVersion;
+    /**
+     * Get manifest content from Hailer market
+     *
+     * @param id target Id
+     *
+     * @returns Manifest content
+     *
+     * @throws {HailerError} if request is incorrect
+     */
+    private getManifest;
 }

package/lib/modules/insight.d.ts

@@ -27,7 +27,6 @@ export declare class InsightApi {
     /**
      * Get Insight data
      *
-     *
      * @returns data from the Insight
      *
      * @throws {HailerError} if request is incorrect

package/lib/modules/permission.d.ts

@@ -1,9 +1,10 @@
 import { Client } from '@wishcore/wish-rpc';
+import { PermissionMap } from '../types';
 /**
  * This class is used to access Hailer public API even when the app is outside of Hailer
  */
 export declare class PermissionApi {
     private client;
     constructor(client: Client);
-    map: () => Promise<void>;
+    map: () => Promise<PermissionMap>;
 }

package/lib/modules/product.d.ts

@@ -87,16 +87,6 @@ export declare class ProductApi {
      * @throws {HailerError} if request is incorrect
      */
     remove(id: string): Promise<boolean>;
-    /**
-     * Install something from Hailer market
-     *
-     * @param id Id of product in Hailer market
-     *
-     * @returns true, if installed else error
-     *
-     * @throws {HailerError} if request is incorrect
-     */
-    install(id: string): Promise<boolean>;
     /**
      * Set product as public or not (visible) in Hailer market
      *

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

@@ -1,5 +1,5 @@
 import { Options } from '../../hailer-api';
-import { HailerAppConfig } from '../../types';
+import { Config } from '../../types';
 export declare class App {
     private options;
     constructor(options: Options);
@@ -13,5 +13,5 @@ export declare class App {
      * @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>;
+    config(): Promise<Config>;
 }

package/lib/modules/public.d.ts

@@ -3,7 +3,6 @@ import { App } from './public/app';
 import { Form } from './public/form';
 import { InsightPublicApi } from './public/insight';
 import { ProductPublicApi } from './public/product';
-import { ProductVersionPublicApi } from './public/product-version';
 /**
  * This class is used to access Hailer public API even when the app is outside of Hailer
  */
@@ -16,7 +15,5 @@ export declare class HailerPublicApi {
     app: App;
     /** Access public Product information */
     product: ProductPublicApi;
-    /** Access public Version information */
-    productVersion: ProductVersionPublicApi;
     constructor(options: Options);
 }

package/lib/modules/team.d.ts

@@ -0,0 +1,17 @@
+import { Client } from '@wishcore/wish-rpc';
+import { TeamMap } from '../types';
+export declare class TeamApi {
+    private client;
+    constructor(client: Client);
+    /**
+     * Lists all Hailer teams from a workspace
+     *
+     *
+     * @returns list of Hailer teams in the workspace the app user is currently in
+     *
+     * @throws {HailerError} if request is incorrect
+     */
+    list(): Promise<{
+        [workspaceId: string]: TeamMap;
+    }>;
+}

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

@@ -21,6 +21,13 @@ export declare class Activity {
                 end: number;
             };
         };
+        location?: {
+            type: 'area' | 'point' | 'polyline';
+            data: {
+                lng: number;
+                lat: number;
+            }[];
+        };
     }): Promise<{
         _id: string;
         name: string;

package/lib/modules/user.d.ts

@@ -30,7 +30,5 @@ export declare class UserApi {
      *
      * @throws {HailerError} if request is incorrect
      */
-    list(): Promise<{
-        [key: string]: User;
-    }>;
+    list(): Promise<User[]>;
 }

package/lib/modules/workflow.d.ts

@@ -1,5 +1,5 @@
 import { Client } from '@wishcore/wish-rpc';
-import { Workflow } from '../types';
+import { IdsMap, Workflow } from '../types';
 export declare class WorkflowApi {
     private client;
     constructor(client: Client);
@@ -11,6 +11,16 @@ export declare class WorkflowApi {
      * @throws {HailerError} if request is incorrect
      */
     list(): Promise<Workflow[]>;
+    /**
+     * Gets a single process from a workspace
+     *
+     * @param workflowId the id of the process in question
+     *
+     * @returns the specified Hailer process
+     *
+     * @throws {HailerError} if request is incorrect
+     */
+    get(workflowId: string): Promise<Workflow>;
     /**
      * Gets a single process from a workspace
      *
@@ -20,5 +30,7 @@ export declare class WorkflowApi {
      *
      * @throws {HailerError} if request is incorrect
      */
-    get(processId: string): Promise<Workflow>;
+    install(workflowSpec: any, option?: {
+        workspaceId?: string;
+    }): Promise<IdsMap>;
 }

package/lib/modules/workspace.d.ts

@@ -1,7 +1,26 @@
 import { Client } from '@wishcore/wish-rpc';
-import { Workspace } from '../types';
+import { ProductVersion, Workspace } from '../types';
 export declare class WorkspaceApi {
     private client;
+    product: {
+        /** Publish template in Hailer market */
+        publishTemplate: (template: {
+            workspaceId?: string;
+            versionId?: string;
+            version: string;
+            versionDescription: string;
+            title: string;
+            description: string;
+        }) => Promise<ProductVersion>;
+        /** Check if product is installed */
+        isProductInstalled(id: string): Promise<boolean>;
+        /** Get version */
+        get(id: string): Promise<ProductVersion | undefined>;
+        /** Install template from Hailer market */
+        install(id: string): Promise<boolean>;
+        /** Get manifest content from Hailer market */
+        getManifest(id: string): Promise<any>;
+    };
     constructor(client: Client);
     /**
      * Returns the current network
@@ -19,4 +38,59 @@ export declare class WorkspaceApi {
      * * @throws {HailerError} if request is incorrect
      */
     list(): Promise<Workspace[]>;
+    /**
+     * Publish template in Hailer market
+     *
+     * @param workspaceId Id of workspace
+     * @param versionId link to version (empty if first publish)
+     * @param version Version number
+     * @param versionDescription Version description
+     * @param title
+     * @param description
+     *
+     * @returns Created version in Hailer market
+     *
+     * @throws {HailerError} if request is incorrect
+     */
+    private publishTemplate;
+    /**
+     * Check if product is installed
+     *
+     * @param id Id of product in Hailer market
+     *
+     * @returns true if ok else false
+     *
+     * @throws {HailerError} if request is incorrect
+     */
+    private isProductInstalled;
+    /**
+     * Get version
+     *
+     * @param id targetId
+     *
+     * @returns true if ok else false
+     *
+     * @throws {HailerError} if request is incorrect
+     */
+    private get;
+    /**
+     * Install template from Hailer market
+     *
+     * @param id Id of product in Hailer market
+     *
+     * @returns true, if installed else error
+     *
+     * @throws {HailerError} if request is incorrect
+     */
+    private install;
+    /**
+     * Get manifest content from Hailer market
+     *
+     * @param id target Id
+     *
+     * @returns Manifest content
+     *
+     * @throws {HailerError} if request is incorrect
+     */
+    private getManifest;
 }

package/lib/tools/publish.cjs

@@ -175,10 +175,10 @@ if (!process.env.EMAIL && !process.env.LOCAL) {
                 try {
                     response = JSON.parse(body);
                     // Market code
-                    if (response.manifest && response.manifest.versionId) {
-                        infoMarket = 'Note! Use versionId in public/manifest.json file when creating the product in market!';
-                        // Write versionId to manifest.json
-                        manifest.versionId = response.manifest.versionId;
+                    if (response.manifest && response.manifest.targetId) {
+                        infoMarket = 'Note! Use targetId in public/manifest.json file when creating the product in market!';
+                        // Write targetId to manifest.json
+                        manifest.targetId = response.manifest.targetId;
                         // Convert the modified object back to JSON
                         const updatedManifestContent = JSON.stringify(manifest, null, 2);
                         // Write the updated JSON content back to manifest.json

package/lib/tools/replace-private.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/tools/replace-private.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = require("fs");
+const path_1 = require("path");
+const srcFolder = (0, path_1.join)(__dirname, '../src');
+const publicSrcFolder = (0, path_1.join)(__dirname, '../public-src');
+const replacePrivateComments = (fileContent) => {
+    // Replaces all occurences of /* @ private */ with private
+    return fileContent.replace(/\/\* @private \*\//g, 'private');
+};
+const copyAndReplaceFiles = (src, dest) => {
+    (0, fs_1.mkdirSync)(dest, { recursive: true });
+    console.log('Created folder: ', dest);
+    (0, fs_1.readdirSync)(src).forEach((file) => {
+        const srcFile = (0, path_1.join)(src, file);
+        const destFile = (0, path_1.join)(dest, file);
+        if ((0, fs_1.lstatSync)(srcFile).isDirectory()) {
+            copyAndReplaceFiles(srcFile, destFile);
+        }
+        else if (srcFile.endsWith('.ts')) {
+            const updatedContent = replacePrivateComments((0, fs_1.readFileSync)(srcFile, 'utf8'));
+            (0, fs_1.writeFileSync)(destFile, updatedContent, 'utf8');
+        }
+        else {
+            (0, fs_1.copyFileSync)(srcFile, destFile);
+        }
+    });
+};
+if ((0, fs_1.existsSync)(publicSrcFolder)) {
+    (0, fs_1.rmdirSync)(publicSrcFolder, { recursive: true });
+}
+copyAndReplaceFiles(srcFolder, publicSrcFolder);
+console.log('Public source files generated in /public-src/');