@prisme.ai/sdk 0.0.2

package/lib/fetcher.test.ts

@@ -0,0 +1,200 @@
+import ApiError from './ApiError';
+import Fetcher from './fetcher';
+import HTTPError from './HTTPError';
+
+it('should fetch', async () => {
+  const fetcher = new Fetcher('http/');
+  // @ts-ignore
+  global.fetch = jest.fn(() => ({
+    ok: true,
+    headers: [['foo', 'bar']],
+    json() {
+      return undefined;
+    },
+    clone() {
+      return { ...this };
+    },
+  }));
+  const o = await fetcher.get('url');
+  expect(o.headers).toEqual({ foo: 'bar' });
+  expect(global.fetch).toHaveBeenCalledWith('http/url', {
+    headers: expect.any(Headers),
+    method: 'GET',
+  });
+  const headers = (global.fetch as jest.Mock).mock.calls[0][1].headers;
+  expect(headers.get('Access-Control-Allow-Origin')).toBe('*');
+  expect(headers.get('Content-Type')).toBe('application/json');
+});
+
+it('should fetch with auth', async () => {
+  const fetcher = new Fetcher('http/');
+  // @ts-ignore
+  global.fetch = jest.fn(() => ({
+    ok: true,
+    headers: {},
+    json() {
+      return {};
+    },
+    clone() {
+      return { ...this };
+    },
+  }));
+  fetcher.token = 'token';
+  await fetcher.get('url');
+  expect(global.fetch).toHaveBeenCalledWith('http/url', {
+    headers: expect.any(Headers),
+    method: 'GET',
+  });
+  const headers = (global.fetch as jest.Mock).mock.calls[0][1].headers;
+  expect(headers.get('Access-Control-Allow-Origin')).toBe('*');
+  expect(headers.get('x-prismeai-session-token')).toBe('token');
+});
+
+it('should fail to fetch', async () => {
+  const fetcher = new Fetcher('http/');
+  // @ts-ignore
+  global.fetch = jest.fn(() => ({
+    ok: false,
+    json: () => ({
+      error: 'error',
+      message: 'message',
+    }),
+    status: 400,
+  }));
+  try {
+    await fetcher.get('url');
+  } catch (e) {
+    expect(e).toBeInstanceOf(ApiError);
+    if (e instanceof ApiError) {
+      expect(e.error).toBe('error');
+      expect(e.message).toBe('message');
+    }
+  }
+  expect(global.fetch).toHaveBeenCalledWith('http/url', {
+    headers: expect.any(Headers),
+    method: 'GET',
+  });
+});
+
+it('should fail to fetch with unformatted error', async () => {
+  const fetcher = new Fetcher('http/');
+  // @ts-ignore
+  global.fetch = jest.fn(() => ({
+    ok: false,
+    statusText: 'error',
+    status: 400,
+  }));
+  try {
+    await fetcher.get('url');
+  } catch (e) {
+    expect(e).toBeInstanceOf(HTTPError);
+    if (e instanceof ApiError) {
+      expect(e.message).toBe('error');
+    }
+  }
+  expect(global.fetch).toHaveBeenCalledWith('http/url', {
+    headers: expect.any(Headers),
+    method: 'GET',
+  });
+});
+
+it('should post', async () => {
+  const fetcher = new Fetcher('http/');
+  // @ts-ignore
+  global.fetch = jest.fn(() => ({
+    ok: true,
+    headers: {},
+    json() {
+      return {};
+    },
+    clone() {
+      return { ...this };
+    },
+  }));
+  await fetcher.post('url');
+  expect(global.fetch).toHaveBeenCalledWith('http/url', {
+    headers: expect.any(Headers),
+    method: 'POST',
+  });
+});
+
+it('should post with body', async () => {
+  const fetcher = new Fetcher('http/');
+  // @ts-ignore
+  global.fetch = jest.fn(() => ({
+    ok: true,
+    headers: {},
+    json() {
+      return {};
+    },
+    clone() {
+      return { ...this };
+    },
+  }));
+  await fetcher.post('url', {});
+  expect(global.fetch).toHaveBeenCalledWith('http/url', {
+    headers: expect.any(Headers),
+    method: 'POST',
+    body: '{}',
+  });
+});
+
+it('should patch', async () => {
+  const fetcher = new Fetcher('http/');
+  // @ts-ignore
+  global.fetch = jest.fn(() => ({
+    ok: true,
+    headers: {},
+    json() {
+      return {};
+    },
+    clone() {
+      return { ...this };
+    },
+  }));
+  await fetcher.patch('url', {});
+  expect(global.fetch).toHaveBeenCalledWith('http/url', {
+    headers: expect.any(Headers),
+    method: 'PATCH',
+    body: '{}',
+  });
+});
+
+it('should delete', async () => {
+  const fetcher = new Fetcher('http/');
+  // @ts-ignore
+  global.fetch = jest.fn(() => ({
+    ok: true,
+    headers: {},
+    json() {
+      return {};
+    },
+    clone() {
+      return { ...this };
+    },
+  }));
+  await fetcher.delete('url');
+  expect(global.fetch).toHaveBeenCalledWith('http/url', {
+    headers: expect.any(Headers),
+    method: 'DELETE',
+  });
+});
+
+it('should use formData', async () => {
+  const fetcher = new Fetcher('http/');
+  // @ts-ignore
+  global.fetch = jest.fn(() => ({
+    ok: true,
+    headers: {},
+    json() {
+      return {};
+    },
+    clone() {
+      return { ...this };
+    },
+  }));
+  const formData = new FormData();
+  await fetcher.post('url', formData);
+  const headers = (global.fetch as jest.Mock).mock.calls[0][1].headers;
+  expect(headers.has('Content-Type')).toBe(false);
+});

package/lib/fetcher.ts

@@ -0,0 +1,97 @@
+import ApiError from './ApiError';
+import HTTPError from './HTTPError';
+
+const headersAsObject = (headers: Headers) =>
+  Array.from(headers).reduce(
+    (prev, [k, v]) => ({
+      ...prev,
+      [k]: v,
+    }),
+    {}
+  );
+
+export class Fetcher {
+  public host: string;
+  public token: string | null = null;
+
+  constructor(host: string) {
+    this.host = host;
+  }
+
+  protected async _fetch<T>(
+    url: string,
+    options: RequestInit = {}
+  ): Promise<T> {
+    const 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', '*');
+
+    const res = await global.fetch(`${this.host}${url}`, {
+      ...options,
+      headers,
+    });
+
+    if (!res.ok) {
+      let error;
+      try {
+        error = new ApiError(await res.json(), res.status);
+      } catch (e) {
+        error = new HTTPError(res.statusText, res.status);
+      }
+      throw error;
+    }
+
+    const clone = res.clone();
+    try {
+      const response = (await res.json()) || {};
+      Object.defineProperty(response, 'headers', {
+        value: headersAsObject(res.headers),
+        configurable: false,
+        enumerable: false,
+        writable: false,
+      });
+      return response;
+    } catch (e) {
+      return ((await clone.text()) as unknown) as T;
+    }
+  }
+
+  async get<T = any>(url: string) {
+    return this._fetch<T>(url, {
+      method: 'GET',
+    });
+  }
+
+  async post<T>(url: string, body?: Record<string, any>) {
+    return this._fetch<T>(url, {
+      method: 'POST',
+      body: body && !(body instanceof FormData) ? JSON.stringify(body) : body,
+    });
+  }
+
+  async patch<T>(url: string, body: Record<string, any>) {
+    return this._fetch<T>(url, {
+      method: 'PATCH',
+      body: JSON.stringify(body),
+    });
+  }
+
+  async delete<T>(url: string) {
+    return this._fetch<T>(url, {
+      method: 'DELETE',
+    });
+  }
+}
+
+export default Fetcher;

package/lib/types.ts

@@ -0,0 +1,17 @@
+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 type EventsFilters = {
+  afterDate?: PrismeaiAPI.EventsLongpolling.Parameters.AfterDate;
+  beforeDate?: PrismeaiAPI.EventsLongpolling.Parameters.BeforeDate;
+  text?: PrismeaiAPI.EventsLongpolling.Parameters.Text;
+  query?: PrismeaiAPI.EventsLongpolling.Parameters.Query;
+};

package/lib/utils.test.ts

@@ -0,0 +1,38 @@
+import { removedUndefinedProperties } from './utils';
+
+it('should remove undefined keys', () => {
+  const myObject = {
+    first: 'one',
+    second: 'second',
+    third: '',
+    fourth: undefined,
+    fifth: 5,
+  };
+
+  const newObject = removedUndefinedProperties(myObject);
+
+  expect(newObject).toStrictEqual({
+    first: 'one',
+    second: 'second',
+    third: '',
+    fifth: 5,
+  });
+});
+
+it('should remove empty strings if specified', () => {
+  const myObject = {
+    first: 'one',
+    second: 'second',
+    third: '',
+    fourth: undefined,
+    fifth: 5,
+  };
+
+  const newObject = removedUndefinedProperties(myObject, true);
+
+  expect(newObject).toStrictEqual({
+    first: 'one',
+    second: 'second',
+    fifth: 5,
+  });
+});

package/lib/utils.ts

@@ -0,0 +1,12 @@
+export const removedUndefinedProperties = (
+  obj: any,
+  removeEmptyStrings: boolean = false
+) =>
+  Object.entries(obj).reduce((newObject: any, [key, value]) => {
+    if (value !== undefined) {
+      if (!(removeEmptyStrings && value === '')) {
+        newObject[key] = value;
+      }
+    }
+    return newObject;
+  }, {});

package/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@prisme.ai/sdk",
+  "version": "0.0.2",
+  "description": "Communicate with Prisme.ai API",
+  "main": "dist/sdk/index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@prisme.ai/types": "^1.0.9",
+    "qs": "^6.10.3",
+    "socket.io-client": "^4.4.1"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "es5",
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "strict": true,
+    "forceConsistentCasingInFileNames": true,
+    "noFallthroughCasesInSwitch": true,
+    "module": "ESNext",
+    "moduleResolution": "node",
+    "resolveJsonModule": true,
+    "isolatedModules": false,
+    "noEmit": true,
+    "declaration": true
+  },
+  "include": ["./index.ts", "lib/**/*", "openapi/*"],
+  "exclude": ["node_modules", "dist"]
+}