@prisme.ai/sdk 1.0.2 → 2.0.1

package/lib/fetcher.test.ts

@@ -1,246 +0,0 @@
-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: new Headers([['foo', 'bar']]),
-    text() {
-      return '';
-    },
-    clone() {
-      return { ...this };
-    },
-  }));
-  const o = 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('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: new Headers(),
-    text() {
-      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-token')).toBe('token');
-});
-
-it('should fetch with api key', async () => {
-  const fetcher = new Fetcher('http/');
-  // @ts-ignore
-  global.fetch = jest.fn(() => ({
-    ok: true,
-    headers: new Headers(),
-    text() {
-      return '';
-    },
-    clone() {
-      return { ...this };
-    },
-  }));
-  fetcher.token = 'token';
-  fetcher.apiKey = 'api-key';
-  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-token')).toBe('token');
-  expect(headers.get('x-prismeai-api-key')).toBe('api-key');
-});
-
-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: new Headers([['content-type', 'application/json']]),
-    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: new Headers([['content-type', 'application/json']]),
-    json() {
-      return {};
-    },
-    clone() {
-      return { ...this };
-    },
-  }));
-  await fetcher.post('url', {});
-  expect(global.fetch).toHaveBeenCalledWith('http/url', {
-    headers: expect.any(Headers),
-    method: 'POST',
-    body: '{}',
-  });
-});
-
-it('should put', async () => {
-  const fetcher = new Fetcher('http/');
-  // @ts-ignore
-  global.fetch = jest.fn(() => ({
-    ok: true,
-    headers: new Headers([['content-type', 'application/json']]),
-    json() {
-      return {};
-    },
-    clone() {
-      return { ...this };
-    },
-  }));
-  await fetcher.put('url', {});
-  expect(global.fetch).toHaveBeenCalledWith('http/url', {
-    headers: expect.any(Headers),
-    method: 'PUT',
-    body: '{}',
-  });
-});
-
-it('should patch', async () => {
-  const fetcher = new Fetcher('http/');
-  // @ts-ignore
-  global.fetch = jest.fn(() => ({
-    ok: true,
-    headers: new Headers([['content-type', 'application/json']]),
-    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: new Headers([['content-type', 'application/json']]),
-    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: new Headers([['content-type', 'application/json']]),
-    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

@@ -1,198 +0,0 @@
-import FormData from 'form-data';
-import ApiError from './ApiError';
-import HTTPError from './HTTPError';
-import { wait } from './utils';
-
-const headersAsObject = (headers: Headers) =>
-  Array.from(headers).reduce(
-    (prev, [k, v]) => ({
-      ...prev,
-      [k]: v,
-    }),
-    {}
-  );
-
-export type Fetched<T> = T & {
-  headers?: Record<string, any>;
-};
-
-function isFormData(data: any): data is FormData {
-  return !!(data.append && typeof data.append === 'function');
-}
-
-const CSRF_TOKEN_HEADER = 'x-prismeai-csrf-token';
-
-export class Fetcher {
-  public host: string;
-  public token: string | null = null;
-  public legacyToken: string | null = null;
-  public overwriteClientId?: string;
-  private clientIdHeader?: string;
-  protected _apiKey: string | null = null;
-  protected _csrfToken: string | null = null;
-  public language: string | undefined;
-  public lastReceivedHeaders?: Record<string, any>;
-
-  constructor(host: string, clientIdHeader?: string) {
-    this.host = host;
-    this.clientIdHeader = clientIdHeader;
-  }
-
-  set apiKey(apiKey: string) {
-    this._apiKey = apiKey;
-  }
-
-  prepareRequest(url: string, options: RequestInit = {}) {
-    const headers = new Headers(options.headers || {});
-
-    if (this.token && !headers.has('Authorization')) {
-      headers.append('Authorization', `Bearer ${this.token}`);
-    } else if (this.legacyToken && !headers.has('Authorization')) {
-      headers.append('x-prismeai-token', this.legacyToken);
-    }
-
-    if (this._apiKey && !headers.has('x-prismeai-apikey')) {
-      headers.append('x-prismeai-api-key', this._apiKey);
-    }
-
-    if (this._csrfToken && options.method && options.method !== 'GET') {
-      headers.append(CSRF_TOKEN_HEADER, this._csrfToken);
-    }
-
-    if (this.language) {
-      headers.append('accept-language', this.language);
-    }
-
-    if (options.body instanceof URLSearchParams) {
-      headers.set('Content-Type', 'application/x-www-form-urlencoded');
-    }
-
-    if (
-      (!options.body || !(options.body instanceof FormData)) &&
-      !headers.has('Content-Type')
-    ) {
-      headers.append('Content-Type', 'application/json');
-    }
-
-    const fullUrl =
-      url.startsWith('http://') || url.startsWith('https://')
-        ? url
-        : `${this.host}${url}`;
-    return global.fetch(fullUrl, {
-      credentials: headers.has('Authorization') ? 'omit' : 'include',
-      ...options,
-      headers,
-    });
-  }
-
-  protected async _fetch<T>(
-    url: string,
-    options: RequestInit = {},
-    maxRetries: number = 3
-  ): Promise<T> {
-    let res: Response;
-    try {
-      res = await this.prepareRequest(url, options);
-    } catch (e: any) {
-      if (maxRetries > 0 && e.message === 'Load failed') {
-        await wait(20);
-        return this._fetch(url, options, --maxRetries);
-      }
-      throw e;
-    }
-    if (options.redirect === 'manual' && res.status === 0) {
-      return { redirected: true } as T;
-    }
-
-    this.lastReceivedHeaders = headersAsObject(res.headers);
-    if (this.clientIdHeader && this.lastReceivedHeaders[this.clientIdHeader]) {
-      this.overwriteClientId = this.lastReceivedHeaders[this.clientIdHeader];
-    }
-    if (this.lastReceivedHeaders[CSRF_TOKEN_HEADER]) {
-      this._csrfToken = this.lastReceivedHeaders[CSRF_TOKEN_HEADER];
-    }
-    if (!res.ok) {
-      if (
-        res.statusText?.length &&
-        res.statusText.includes('ECONNRESET') &&
-        maxRetries > 0
-      ) {
-        console.log(
-          `Retrying request towards ${url} as we received ECONNRESET error : ${res.statusText}`
-        );
-        await wait(20);
-        return this._fetch(url, options, --maxRetries);
-      }
-      let error;
-      try {
-        error = new ApiError(await res.json(), res.status);
-      } catch (e) {
-        error = new HTTPError(res.statusText, res.status);
-      }
-      throw error;
-    }
-
-    const contentType = res.headers.get('content-type');
-    if (contentType && contentType.includes('application/json')) {
-      try {
-        const response = (await res.json()) || {};
-        Object.defineProperty(response, 'headers', {
-          value: headersAsObject(res.headers),
-          configurable: false,
-          enumerable: false,
-          writable: false,
-        });
-        return response as T;
-      } catch (e) {
-        return {} as T;
-      }
-    }
-
-    const text = await res.text();
-
-    try {
-      return JSON.parse(text) as T;
-    } catch {
-      return text as T;
-    }
-  }
-
-  async get<T = any>(url: string) {
-    return this._fetch<T>(url, {
-      method: 'GET',
-    });
-  }
-
-  async post<T>(url: string, body?: Record<string, any>, opts?: RequestInit) {
-    return this._fetch<T>(url, {
-      method: 'POST',
-      body:
-        body && !isFormData(body) && !(body instanceof URLSearchParams)
-          ? JSON.stringify(body)
-          : (body as BodyInit),
-      ...opts,
-    });
-  }
-
-  async put<T>(url: string, body: Record<string, any>) {
-    return this._fetch<T>(url, {
-      method: 'PUT',
-      body: JSON.stringify(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

@@ -1,21 +0,0 @@
-import '@prisme.ai/types';
-
-export interface Workspace extends Prismeai.Workspace {
-  id: string;
-  updatedAt: Date;
-  updatedBy: string;
-  createdAt: Date;
-  createdBy: string;
-}
-
-export interface Event<DateType extends Date | string>
-  extends Omit<Prismeai.PrismeEvent, 'createdAt'> {
-  createdAt: DateType;
-}
-
-export type EventsFilters = Record<string, string> & {
-  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

@@ -1,38 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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;
-  }, {});
-
-export function dataURItoBlob(dataURI: string): [Blob, string] {
-  // convert base64/URLEncoded data component to raw binary data held in a string
-  let byteString;
-  if (dataURI.split(',')[0].indexOf('base64') >= 0)
-    byteString = atob(dataURI.split(',')[1].split(';')[0]);
-  else byteString = unescape(dataURI.split(',')[1]);
-  // separate out the mime component
-  const metadata = dataURI
-    .split(';')
-    .map((v) => v.split(/:/))
-    .filter((pair) => pair.length === 2);
-  const [, mimeString = ''] = metadata.find(([k, v]) => k === 'data') || [];
-  const [, ext] = mimeString.split(/\//);
-  const [, fileName = `file.${ext}`] =
-    metadata.find(([k, v]) => k === 'filename') || [];
-
-  const sanitizedFileName = encodeURIComponent(
-    decodeURIComponent(fileName).replace(/[;,\s]/g, '-')
-  );
-
-  // write the bytes of the string to a typed array
-  let ia = new Uint8Array(byteString.length);
-  for (var i = 0; i < byteString.length; i++) {
-    ia[i] = byteString.charCodeAt(i);
-  }
-
-  return [new Blob([ia], { type: mimeString }), sanitizedFileName];
-}
-
-export function isDataURL(file: any): file is string {
-  return !!(typeof file === 'string' && file.match(/^data\:/));
-}
-
-export async function wait(delay: number = 0) {
-  return new Promise((resolve) => {
-    setTimeout(resolve, delay);
-  });
-}

package/tsconfig.json

@@ -1,21 +0,0 @@
-{
-  "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"]
-}