@prisme.ai/sdk 0.0.2

package/Readme.md

@@ -0,0 +1,26 @@
+# Prisme.ai SDk
+
+## Description
+
+This javascript library helps to communicate with Prisme.ai API. It provides methods to reach every endpoints and structure data responses.
+
+## Usage
+
+```
+import api from '@prisme.ai/sdk';
+```
+
+will give you a singleton preset to hit the prisme.ai cloud service.
+
+You can set a different host by instantiating the Api class:
+
+```
+import { Api } from '@prisme.ai/sdk';
+const api = new Api('https://my.custom.host')
+```
+
+You are able to call un authentified methods like signin or signup, but you'll need a valid token to call the other. Just set its property:
+
+```
+api.token = 'the token';
+```

package/dist/_virtual/_tslib.js

@@ -0,0 +1,107 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise */
+
+var extendStatics = function(d, b) {
+    extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+    return extendStatics(d, b);
+};
+
+function __extends(d, b) {
+    if (typeof b !== "function" && b !== null)
+        throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+    extendStatics(d, b);
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
+
+exports.__assign = function() {
+    exports.__assign = Object.assign || function __assign(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+        }
+        return t;
+    };
+    return exports.__assign.apply(this, arguments);
+};
+
+function __rest(s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+}
+
+function __awaiter(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());
+    });
+}
+
+function __generator(thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+}
+
+function __spreadArray(to, from) {
+    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
+        to[j] = from[i];
+    return to;
+}
+
+exports.__awaiter = __awaiter;
+exports.__extends = __extends;
+exports.__generator = __generator;
+exports.__rest = __rest;
+exports.__spreadArray = __spreadArray;

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export * from './lib/api';
+export * from './lib/ApiError';
+export * from './lib/events';
+export * from './lib/fetcher';
+export * from './lib/HTTPError';
+export * from './lib/types';
+export { default } from './lib/api';

package/dist/lib/ApiError.d.ts

@@ -0,0 +1,8 @@
+export declare class ApiError extends Error implements Prismeai.GenericError {
+    code: number;
+    error: Prismeai.GenericError['error'];
+    details: Prismeai.GenericError['details'];
+    constructor({ error, message, details }: Prismeai.GenericError, code: number);
+    toString(): string | undefined;
+}
+export default ApiError;

package/dist/lib/ApiError.test.d.ts

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

package/dist/lib/HTTPError.d.ts

@@ -0,0 +1,6 @@
+export declare class HTTPError extends Error {
+    code: number;
+    constructor(status: string, code: number);
+    toString(): string;
+}
+export default HTTPError;

package/dist/lib/HTTPError.test.d.ts

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

package/dist/lib/api.d.ts

@@ -0,0 +1,59 @@
+import Fetcher from './fetcher';
+import { Event, Workspace } from './types';
+import { Events } from './events';
+declare type UserPermissions = Prismeai.UserPermissions;
+export declare class Api extends Fetcher {
+    me(): Promise<any>;
+    signin(email: string, password: string): Promise<Prismeai.User & {
+        token: string;
+    }>;
+    signup(email: string, password: string, firstName: string, lastName: string): Promise<Prismeai.User & {
+        token: string;
+    }>;
+    signout(): Promise<void>;
+    getWorkspaces(): Promise<Workspace[]>;
+    getWorkspace(id: string): Promise<Workspace | null>;
+    createWorkspace(name: string): Promise<Workspace>;
+    updateWorkspace(workspace: Workspace): Promise<Workspace>;
+    deleteWorkspace(workspaceId: Workspace['id']): Promise<Workspace>;
+    createAutomation(workspace: Workspace, automation: Prismeai.Automation): Promise<Prismeai.Automation & {
+        slug: string;
+    }>;
+    updateAutomation(workspace: Workspace, slug: string, automation: Prismeai.Automation): Promise<Prismeai.Automation & {
+        slug: string;
+    }>;
+    deleteAutomation(workspace: Workspace, slug: string): Promise<string>;
+    getPages(workspaceId: NonNullable<Workspace['id']>): Promise<Prismeai.Page[]>;
+    getPage(workspaceId: PrismeaiAPI.GetPage.Parameters.WorkspaceId, pageId: PrismeaiAPI.GetPage.Parameters.Id): Promise<Prismeai.DetailedPage>;
+    getPageBySlug(pageSlug: PrismeaiAPI.GetPageBySlug.Parameters.Slug): Promise<Prismeai.DetailedPage>;
+    createPage(workspaceId: NonNullable<Workspace['id']>, page: Prismeai.Page): Promise<Prismeai.Page>;
+    updatePage(workspaceId: NonNullable<Workspace['id']>, page: Prismeai.Page): Promise<Prismeai.Page>;
+    deletePage(workspaceId: NonNullable<Workspace['id']>, pageId: string): Promise<Pick<Prismeai.Page, 'id'>>;
+    streamEvents(workspaceId: string): Promise<Events>;
+    getEvents(workspaceId: string, options?: {
+        beforeDate?: Date | string;
+    }): Promise<Event<Date>[]>;
+    postEvents(workspaceId: PrismeaiAPI.SendWorkspaceEvent.Parameters.WorkspaceId, events: PrismeaiAPI.SendWorkspaceEvent.RequestBody['events']): Promise<boolean>;
+    getPermissions(subjectType: PrismeaiAPI.GetPermissions.Parameters.SubjectType, subjectId: string): Promise<PrismeaiAPI.GetPermissions.Responses.$200>;
+    addPermissions(subjectType: PrismeaiAPI.GetPermissions.Parameters.SubjectType, subjectId: string, permissions: UserPermissions): Promise<PrismeaiAPI.Share.Responses.$200>;
+    deletePermissions(subjectType: PrismeaiAPI.GetPermissions.Parameters.SubjectType, subjectId: string, userEmail: string): Promise<PrismeaiAPI.RevokePermissions.Responses.$200>;
+    getApps({ query, page, limit, workspaceId, }: {
+        query?: PrismeaiAPI.SearchApps.QueryParameters['text'];
+        page?: PrismeaiAPI.SearchApps.QueryParameters['page'];
+        limit?: PrismeaiAPI.SearchApps.QueryParameters['limit'];
+        workspaceId?: PrismeaiAPI.SearchApps.QueryParameters['workspaceId'];
+    }): Promise<PrismeaiAPI.SearchApps.Responses.$200>;
+    installApp(workspaceId: PrismeaiAPI.InstallAppInstance.PathParameters['workspaceId'], body: PrismeaiAPI.InstallAppInstance.RequestBody): Promise<PrismeaiAPI.InstallAppInstance.Responses.$200>;
+    updateApp(workspaceId: PrismeaiAPI.ConfigureAppInstance.PathParameters['workspaceId'], slug: PrismeaiAPI.ConfigureAppInstance.PathParameters['slug'], body: PrismeaiAPI.ConfigureAppInstance.RequestBody): Promise<PrismeaiAPI.ConfigureAppInstance.Responses.$200>;
+    uninstallApp(workspaceId: PrismeaiAPI.UninstallAppInstance.PathParameters['workspaceId'], slug: PrismeaiAPI.ConfigureAppInstance.PathParameters['slug']): Promise<PrismeaiAPI.UninstallAppInstance.Responses.$200>;
+    publishApp(body: PrismeaiAPI.PublishApp.RequestBody): Promise<PrismeaiAPI.PublishApp.Responses.$200>;
+    listAppInstances(workspaceId: PrismeaiAPI.ListAppInstances.PathParameters['workspaceId']): Promise<PrismeaiAPI.ListAppInstances.Responses.$200>;
+    fetchImports(workspaceId: PrismeaiAPI.ListAppInstances.Parameters.WorkspaceId): Promise<PrismeaiAPI.ListAppInstances.Responses.$200>;
+    getAppConfig<T>(workspaceId: PrismeaiAPI.GetAppInstanceConfig.Parameters.WorkspaceId, slug: PrismeaiAPI.GetAppInstanceConfig.Parameters.Slug): Promise<T>;
+    updateAppConfig(workspaceId: PrismeaiAPI.UpdateAppInstanceConfig.Parameters.WorkspaceId, slug: PrismeaiAPI.UpdateAppInstanceConfig.Parameters.Slug, config: any): Promise<PrismeaiAPI.UpdateAppInstanceConfig.Responses.$200['config']>;
+    uploadFiles(files: string | string[], workspaceId: string): Promise<PrismeaiAPI.UploadFile.Responses.$200>;
+    replaceAllImagesData(original: any, workspaceId: string): Promise<any>;
+    callAutomation(workspaceId: string, automation: string): Promise<any>;
+}
+declare const _default: Api;
+export default _default;

package/dist/lib/api.test.d.ts

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

package/dist/lib/events.d.ts

@@ -0,0 +1,14 @@
+import { Socket } from 'socket.io-client';
+export declare class Events {
+    protected client: Socket;
+    workspaceId: string;
+    constructor(workspaceId: string, token: string, apiHost?: string);
+    get socket(): Socket<import("@socket.io/component-emitter").DefaultEventsMap, import("@socket.io/component-emitter").DefaultEventsMap>;
+    destroy(): void;
+    all(listener: (eventName: string, eventData: Prismeai.PrismeEvent) => void): () => Socket<import("@socket.io/component-emitter").DefaultEventsMap, import("@socket.io/component-emitter").DefaultEventsMap>;
+    on(ev: string, listener: (eventName: string, eventData: Prismeai.PrismeEvent) => void): () => Socket<import("@socket.io/component-emitter").DefaultEventsMap, import("@socket.io/component-emitter").DefaultEventsMap>;
+    emit(event: string, payload?: any): void;
+    once(ev: string, listener: (eventName: string, eventData: Prismeai.PrismeEvent) => void): void;
+    close(): void;
+}
+export default Events;

package/dist/lib/events.test.d.ts

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

package/dist/lib/fetcher.d.ts

@@ -0,0 +1,11 @@
+export declare class Fetcher {
+    host: string;
+    token: string | null;
+    constructor(host: string);
+    protected _fetch<T>(url: string, options?: RequestInit): Promise<T>;
+    get<T = any>(url: string): Promise<T>;
+    post<T>(url: string, body?: Record<string, any>): Promise<T>;
+    patch<T>(url: string, body: Record<string, any>): Promise<T>;
+    delete<T>(url: string): Promise<T>;
+}
+export default Fetcher;

package/dist/lib/fetcher.test.d.ts

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

package/dist/lib/types.d.ts

@@ -0,0 +1,13 @@
+import '@prisme.ai/types';
+export interface Workspace extends Prismeai.Workspace {
+    id: string;
+}
+export interface Event<DateType extends Date | string> extends Omit<Prismeai.PrismeEvent, 'createdAt'> {
+    createdAt: DateType;
+}
+export declare type EventsFilters = {
+    afterDate?: PrismeaiAPI.EventsLongpolling.Parameters.AfterDate;
+    beforeDate?: PrismeaiAPI.EventsLongpolling.Parameters.BeforeDate;
+    text?: PrismeaiAPI.EventsLongpolling.Parameters.Text;
+    query?: PrismeaiAPI.EventsLongpolling.Parameters.Query;
+};

package/dist/lib/utils.d.ts

@@ -0,0 +1 @@
+export declare const removedUndefinedProperties: (obj: any, removeEmptyStrings?: boolean) => any;

package/dist/lib/utils.test.d.ts

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

package/dist/sdk/index.js

@@ -0,0 +1,19 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var api = require('./lib/api.js');
+var ApiError = require('./lib/ApiError.js');
+var events = require('./lib/events.js');
+var fetcher = require('./lib/fetcher.js');
+var HTTPError = require('./lib/HTTPError.js');
+require('@prisme.ai/types');
+
+
+
+exports.Api = api.Api;
+exports["default"] = api["default"];
+exports.ApiError = ApiError.ApiError;
+exports.Events = events.Events;
+exports.Fetcher = fetcher.Fetcher;
+exports.HTTPError = HTTPError.HTTPError;

package/dist/sdk/lib/ApiError.js

@@ -0,0 +1,24 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../_virtual/_tslib.js');
+
+var ApiError = /** @class */ (function (_super) {
+    _tslib.__extends(ApiError, _super);
+    function ApiError(_a, code) {
+        var error = _a.error, message = _a.message, details = _a.details;
+        var _this = _super.call(this, message) || this;
+        _this.code = code;
+        _this.error = error;
+        _this.details = details;
+        return _this;
+    }
+    ApiError.prototype.toString = function () {
+        return this.error;
+    };
+    return ApiError;
+}(Error));
+
+exports.ApiError = ApiError;
+exports["default"] = ApiError;

package/dist/sdk/lib/HTTPError.js

@@ -0,0 +1,21 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../_virtual/_tslib.js');
+
+var HTTPError = /** @class */ (function (_super) {
+    _tslib.__extends(HTTPError, _super);
+    function HTTPError(status, code) {
+        var _this = _super.call(this, status) || this;
+        _this.code = code;
+        return _this;
+    }
+    HTTPError.prototype.toString = function () {
+        return "".concat(this.code, " ").concat(this.message);
+    };
+    return HTTPError;
+}(Error));
+
+exports.HTTPError = HTTPError;
+exports["default"] = HTTPError;