@prisme.ai/sdk 0.0.2

package/dist/sdk/lib/fetcher.js

@@ -0,0 +1,121 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../_virtual/_tslib.js');
+var ApiError = require('./ApiError.js');
+var HTTPError = require('./HTTPError.js');
+
+var headersAsObject = function (headers) {
+    return Array.from(headers).reduce(function (prev, _a) {
+        var _b;
+        var k = _a[0], v = _a[1];
+        return (_tslib.__assign(_tslib.__assign({}, prev), (_b = {}, _b[k] = v, _b)));
+    }, {});
+};
+var Fetcher = /** @class */ (function () {
+    function Fetcher(host) {
+        this.token = null;
+        this.host = host;
+    }
+    Fetcher.prototype._fetch = function (url, options) {
+        if (options === void 0) { options = {}; }
+        return _tslib.__awaiter(this, void 0, void 0, function () {
+            var headers, res, error, _a, clone, response;
+            return _tslib.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        headers = new Headers(options.headers || {});
+                        if (this.token && !headers.has('x-prismeai-session-token')) {
+                            headers.append('x-prismeai-session-token', this.token);
+                        }
+                        if ((!options.body || !(options.body instanceof FormData)) &&
+                            !headers.has('Content-Type')) {
+                            headers.append('Content-Type', 'application/json');
+                        }
+                        headers.append('Access-Control-Allow-Origin', '*');
+                        return [4 /*yield*/, global.fetch("".concat(this.host).concat(url), _tslib.__assign(_tslib.__assign({}, options), { headers: headers }))];
+                    case 1:
+                        res = _b.sent();
+                        if (!!res.ok) return [3 /*break*/, 6];
+                        error = void 0;
+                        _b.label = 2;
+                    case 2:
+                        _b.trys.push([2, 4, , 5]);
+                        _a = ApiError.ApiError.bind;
+                        return [4 /*yield*/, res.json()];
+                    case 3:
+                        error = new (_a.apply(ApiError.ApiError, [void 0, _b.sent(), res.status]))();
+                        return [3 /*break*/, 5];
+                    case 4:
+                        _b.sent();
+                        error = new HTTPError.HTTPError(res.statusText, res.status);
+                        return [3 /*break*/, 5];
+                    case 5: throw error;
+                    case 6:
+                        clone = res.clone();
+                        _b.label = 7;
+                    case 7:
+                        _b.trys.push([7, 9, , 11]);
+                        return [4 /*yield*/, res.json()];
+                    case 8:
+                        response = (_b.sent()) || {};
+                        Object.defineProperty(response, 'headers', {
+                            value: headersAsObject(res.headers),
+                            configurable: false,
+                            enumerable: false,
+                            writable: false,
+                        });
+                        return [2 /*return*/, response];
+                    case 9:
+                        _b.sent();
+                        return [4 /*yield*/, clone.text()];
+                    case 10: return [2 /*return*/, (_b.sent())];
+                    case 11: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Fetcher.prototype.get = function (url) {
+        return _tslib.__awaiter(this, void 0, void 0, function () {
+            return _tslib.__generator(this, function (_a) {
+                return [2 /*return*/, this._fetch(url, {
+                        method: 'GET',
+                    })];
+            });
+        });
+    };
+    Fetcher.prototype.post = function (url, body) {
+        return _tslib.__awaiter(this, void 0, void 0, function () {
+            return _tslib.__generator(this, function (_a) {
+                return [2 /*return*/, this._fetch(url, {
+                        method: 'POST',
+                        body: body && !(body instanceof FormData) ? JSON.stringify(body) : body,
+                    })];
+            });
+        });
+    };
+    Fetcher.prototype.patch = function (url, body) {
+        return _tslib.__awaiter(this, void 0, void 0, function () {
+            return _tslib.__generator(this, function (_a) {
+                return [2 /*return*/, this._fetch(url, {
+                        method: 'PATCH',
+                        body: JSON.stringify(body),
+                    })];
+            });
+        });
+    };
+    Fetcher.prototype.delete = function (url) {
+        return _tslib.__awaiter(this, void 0, void 0, function () {
+            return _tslib.__generator(this, function (_a) {
+                return [2 /*return*/, this._fetch(url, {
+                        method: 'DELETE',
+                    })];
+            });
+        });
+    };
+    return Fetcher;
+}());
+
+exports.Fetcher = Fetcher;
+exports["default"] = Fetcher;

package/dist/sdk/lib/utils.js

@@ -0,0 +1,18 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var removedUndefinedProperties = function (obj, removeEmptyStrings) {
+    if (removeEmptyStrings === void 0) { removeEmptyStrings = false; }
+    return Object.entries(obj).reduce(function (newObject, _a) {
+        var key = _a[0], value = _a[1];
+        if (value !== undefined) {
+            if (!(removeEmptyStrings && value === '')) {
+                newObject[key] = value;
+            }
+        }
+        return newObject;
+    }, {});
+};
+
+exports.removedUndefinedProperties = removedUndefinedProperties;

package/index.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/lib/ApiError.test.ts

@@ -0,0 +1,13 @@
+import ApiError from './ApiError';
+
+it('should construct', () => {
+  const apiError = new ApiError(
+    { error: 'foo', message: 'bar', details: [{}] },
+    400
+  );
+  expect(apiError.code).toBe(400);
+  expect(apiError.message).toBe('bar');
+  expect(apiError.error).toBe('foo');
+  expect(apiError.details).toEqual([{}]);
+  expect(`${apiError}`).toBe('foo');
+});

package/lib/ApiError.ts

@@ -0,0 +1,21 @@
+export class ApiError extends Error implements Prismeai.GenericError {
+  public code: number;
+  public error: Prismeai.GenericError['error'];
+  public details: Prismeai.GenericError['details'];
+
+  constructor(
+    { error, message, details }: Prismeai.GenericError,
+    code: number
+  ) {
+    super(message);
+    this.code = code;
+    this.error = error;
+    this.details = details;
+  }
+
+  toString() {
+    return this.error;
+  }
+}
+
+export default ApiError;

package/lib/HTTPError.test.ts

@@ -0,0 +1,8 @@
+import HTTPError from './HTTPError';
+
+it('should construct', () => {
+  const error = new HTTPError('error', 400);
+  expect(error.code).toBe(400);
+  expect(error.message).toBe('error');
+  expect(`${error}`).toBe('400 error');
+});

package/lib/HTTPError.ts

@@ -0,0 +1,13 @@
+export class HTTPError extends Error {
+  public code: number;
+  constructor(status: string, code: number) {
+    super(status);
+    this.code = code;
+  }
+
+  toString() {
+    return `${this.code} ${this.message}`;
+  }
+}
+
+export default HTTPError;

package/lib/api.test.ts

@@ -0,0 +1,231 @@
+import api, { Api } from './api';
+
+it('should export an instance', () => {
+  expect(api).toBeInstanceOf(Api);
+});
+
+it('should call /me', () => {
+  const api = new Api('/fake/');
+  api.get = jest.fn();
+  api.me();
+  expect(api.get).toHaveBeenCalledWith('/me');
+});
+
+it('should call /signin', () => {
+  const api = new Api('/fake/');
+  api.post = jest.fn();
+  api.signin('user@fake.com', 'password');
+  expect(api.post).toHaveBeenCalledWith('/login', {
+    email: 'user@fake.com',
+    password: 'password',
+  });
+});
+
+it('should call /signup', () => {
+  const api = new Api('/fake/');
+  api.post = jest.fn();
+  api.signup('user@fake.com', 'password', 'firstname', 'lastname');
+  expect(api.post).toHaveBeenCalledWith('/signup', {
+    email: 'user@fake.com',
+    password: 'password',
+    firstName: 'firstname',
+    lastName: 'lastname',
+  });
+});
+
+it('should call /signout', () => {
+  const api = new Api('/fake/');
+  api.post = jest.fn();
+  api.signout();
+  expect(api.post).toHaveBeenCalledWith('/logout');
+  expect(api.token).toBeNull();
+});
+
+it('should call get /workspaces', () => {
+  const api = new Api('/fake/');
+  api.get = jest.fn();
+  api.getWorkspaces();
+  expect(api.get).toHaveBeenCalledWith('/workspaces?limit=300');
+});
+
+it('should call get /workspaces/42', () => {
+  const api = new Api('/fake/');
+  api.get = jest.fn();
+  api.getWorkspace('42');
+  expect(api.get).toHaveBeenCalledWith('/workspaces/42');
+});
+
+it('should call post /workspaces', () => {
+  const api = new Api('/fake/');
+  api.post = jest.fn();
+  api.createWorkspace('foo');
+  expect(api.post).toHaveBeenCalledWith('/workspaces', {
+    name: 'foo',
+  });
+});
+
+it('should call patch /workspaces/42', async () => {
+  const api = new Api('/fake/');
+  api.patch = jest.fn();
+  await api.updateWorkspace({
+    id: '42',
+    name: 'foo',
+    automations: {},
+    createdAt: '',
+    updatedAt: '',
+  });
+  expect(api.patch).toHaveBeenCalledWith('/workspaces/42', {
+    id: '42',
+    name: 'foo',
+    automations: {},
+    createdAt: '',
+    updatedAt: '',
+  });
+});
+
+it('should call post /workspaces/42/automations', () => {
+  const api = new Api('/fake/');
+  api.post = jest.fn();
+  api.createAutomation(
+    {
+      id: '42',
+      name: 'foo',
+      automations: {},
+      createdAt: '',
+      updatedAt: '',
+    },
+    {
+      name: 'foo',
+      do: [],
+    }
+  );
+  expect(api.post).toHaveBeenCalledWith('/workspaces/42/automations', {
+    name: 'foo',
+    do: [],
+  });
+});
+
+it('should call patch /workspaces/42/automations', async () => {
+  const api = new Api('/fake/');
+  api.patch = jest.fn();
+  await api.updateAutomation(
+    {
+      id: '42',
+      name: 'foo',
+      automations: {},
+      createdAt: '',
+      updatedAt: '',
+    },
+    '42-1',
+    {
+      name: 'foo',
+      do: [],
+    }
+  );
+  expect(api.patch).toHaveBeenCalledWith('/workspaces/42/automations/42-1', {
+    name: 'foo',
+    do: [],
+  });
+});
+
+it('should call delete /workspaces/42/automations/42-1', () => {
+  const api = new Api('/fake/');
+  api.delete = jest.fn();
+  api.deleteAutomation(
+    {
+      id: '42',
+      name: 'foo',
+      automations: {},
+      createdAt: '',
+      updatedAt: '',
+    },
+    '42-1'
+  );
+  expect(api.delete).toHaveBeenCalledWith('/workspaces/42/automations/42-1');
+});
+
+it('should call get /workspaces/42/events', async () => {
+  const api = new Api('/fake/');
+  api.get = jest.fn(
+    async (): Promise<any> => ({
+      result: {
+        events: [
+          {
+            id: '1',
+            createdAt: '2021-01-01',
+          },
+        ],
+      },
+    })
+  );
+  expect(await api.getEvents('42')).toEqual([
+    {
+      id: '1',
+      createdAt: new Date('2021-01-01'),
+    },
+  ]);
+});
+
+it('should replace all images data', async () => {
+  const api = new Api('/fake/');
+  api.uploadFiles = jest.fn(async () => [
+    { url: 'http://image1.jpg' } as any,
+    { url: 'http://image2.jpg' } as any,
+    { url: 'http://image3.jpg' } as any,
+    { url: 'http://image4.jpg' } as any,
+    { url: 'http://image5.jpg' } as any,
+  ]);
+  const original = {
+    foo: 'data:image/jpeg;base64…',
+    bar: {
+      pic: 'data:image/jpeg;base64…',
+      pics: [
+        'data:image/jpeg;base64…',
+        'data:image/jpeg;base64…',
+        'data:image/jpeg;base64…',
+      ],
+      nopics: 'http://alreadyUpImage.jpg',
+    },
+    anythingElse: 42,
+  };
+  expect(await api.replaceAllImagesData(original, '42')).toEqual({
+    foo: 'http://image1.jpg',
+    bar: {
+      pic: 'http://image2.jpg',
+      pics: ['http://image3.jpg', 'http://image4.jpg', 'http://image5.jpg'],
+      nopics: 'http://alreadyUpImage.jpg',
+    },
+    anythingElse: 42,
+  });
+  expect(api.uploadFiles).toHaveBeenCalledWith(
+    [
+      'data:image/jpeg;base64…',
+      'data:image/jpeg;base64…',
+      'data:image/jpeg;base64…',
+      'data:image/jpeg;base64…',
+      'data:image/jpeg;base64…',
+    ],
+    '42'
+  );
+  expect(api.uploadFiles).toHaveBeenCalledTimes(1);
+});
+
+it('should upload file', async () => {
+  const api = new Api('/fake/');
+  // @ts-ignore
+  api._fetch = jest.fn(() => [{}]);
+  await api.uploadFiles(
+    'data:image/jpeg;filename:foo.jpg;base64,abcdefg',
+    '42'
+  );
+  // @ts-ignore
+  expect(api._fetch).toHaveBeenCalledWith('/workspaces/42/files', {
+    method: 'POST',
+    body: expect.any(FormData),
+  });
+  const { body }: { body: FormData } =
+    // @ts-ignore
+    api._fetch.mock.calls[0][1];
+  expect(body.getAll('file').length).toBe(1);
+  expect((body.getAll('file')[0] as File).name).toBe('foo.jpg');
+});