@bagelink/sdk 0.0.19 → 0.0.22

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@bagelink/sdk",
   "type": "module",
-  "version": "0.0.19",
+  "version": "0.0.22",
   "description": "Bagel core sdk packages",
   "author": {
     "name": "Neveh Allon",
@@ -19,8 +19,7 @@
   "keywords": [],
   "sideEffects": false,
   "exports": {
-    "./package.json": "./package.json",
-    "./src/index": "./src/index.ts",
+    "./src": "./src/index.ts",
     ".": {
       "types": "./dist/index.d.ts",
       "require": "./dist/index.cjs",
@@ -39,7 +38,8 @@
     }
   },
   "files": [
-    "dist"
+    "dist",
+    "src"
   ],
   "publishConfig": {
     "access": "public"

package/src/index.ts

@@ -0,0 +1,318 @@
+import ax from 'axios';
+
+export type Tables = '';
+export type TableToTypeMapping = Record<Tables, any>;
+
+export interface User {
+  id: string
+  first_name?: string
+  last_name?: string
+  email?: string
+  password?: string
+  is_verified?: boolean
+  locale: string
+  type: string
+}
+
+interface UploadOptions {
+  onUploadProgress?: (progressEvent: any) => void
+}
+
+const axios = ax.create({
+  // withCredentials to true to send cookies with requests
+  withCredentials: true,
+});
+
+class DataRequest<T extends Tables = Tables> {
+  data_table: T | Tables;
+  bagel: any;
+  itemID: string;
+  _filter: Record<string, any> = {};
+  constructor(table: T, bagel: Bagel) {
+    this.data_table = table;
+    this.bagel = bagel;
+    this.itemID = '';
+  }
+
+  async post(item: Record<string, any>): Promise<Record<string, any>> {
+    if (!this.data_table)
+      throw new Error('Data table not set');
+    const { data } = await axios.post(
+			`${this.bagel.host}/data/${this.data_table}`,
+			item,
+    );
+    return data;
+  }
+
+  filter(filter: Record<string, any>) {
+    this._filter = filter;
+    return this;
+  }
+
+  async get(): Promise<
+		TableToTypeMapping[T] | TableToTypeMapping[T][] | undefined
+		> {
+    if (!this.data_table)
+      throw new Error('Data table not set');
+    const filterStr = Object.keys(this._filter).length
+      ? `?filter={${Object.entries(this._filter)
+				.map(([k, v]) => `${k}:${v}`)
+				.join(',')}}`
+      : '';
+    const url = `${this.bagel.host}/data/${this.data_table}${this.itemID ? `/${this.itemID}` : ''
+		}${filterStr}`;
+    try {
+      const { data } = await axios.get(url);
+      return data;
+    }
+    catch (err) {
+      console.log(err);
+      this.bagel.onError?.(err);
+      return undefined;
+    }
+  }
+
+  item(id: string) {
+    this.itemID = id;
+    return this;
+  }
+
+  async delete(): Promise<TableToTypeMapping[T][]> {
+    if (!this.data_table)
+      throw new Error('Data table not set');
+    const { data } = await axios.delete(
+			`${this.bagel.host}/data/${this.data_table}/${this.itemID}`,
+    );
+    return data;
+  }
+
+  async put(updatedItem: Record<string, any>): Promise<Record<string, any>> {
+    const { data_table, itemID, bagel } = this;
+    if (!data_table)
+      throw new Error('Data table not set');
+    if (!itemID)
+      throw new Error('Item ID not set');
+    const { data } = await axios.put(
+			`${bagel.host}/data/${data_table}/${itemID}`,
+			updatedItem,
+    );
+    return data;
+  }
+}
+
+function responses(key: string) {
+  const res: Record<string, string> = {
+    LOGIN_BAD_CREDENTIALS: 'Invalid username or password',
+    RESET_PASSWORD_BAD_TOKEN: 'This reset password link is invalid or expired.',
+  };
+  return res[key] || key;
+}
+
+class BagelAuth {
+  constructor(private bagel: Bagel) {
+    this.bagel = bagel;
+  }
+
+  user: User | null = null;
+  async validateUser(): Promise<User | null> {
+    try {
+      const usr = (await this.bagel.get('/users/me')) as User;
+      this.user = usr;
+      return usr;
+    }
+    catch (err) {
+      // this.bagel.onError?.(err);
+      console.log(err);
+      return null;
+    }
+  }
+
+  async resetPassword(ctx: { token: string; password: string }) {
+    return this.bagel.post('auth/reset-password', ctx).catch((err) => {
+      throw responses(err.response?.data?.detail);
+    });
+  }
+
+  async forgotPassword(email: string) {
+    try {
+      await this.bagel.post('auth/forgot-password', { email });
+    }
+    catch (err: any) {
+      throw responses(err?.response?.data?.detail);
+    }
+  }
+
+  async login(user: User): Promise<User | null> {
+    const formData = new FormData();
+    formData.append('username', user?.email || '');
+    formData.append('password', user?.password || '');
+    try {
+      await axios.post(`${this.bagel.host}/auth/cookie/login`, formData, {
+        headers: {
+          'Content-Type': 'multipart/form-data',
+          'withCredentials': true,
+        },
+      });
+      return this.validateUser();
+    }
+    catch (err: any) {
+      throw responses(err.response?.data?.detail || 'LOGIN_BAD_CREDENTIALS');
+    }
+  }
+
+  async logout() {
+    try {
+      await axios.post(`${this.bagel.host}/auth/cookie/logout`);
+    }
+    catch (err) {
+      this.bagel.onError?.(err);
+      console.log(err);
+    }
+    this.user = null;
+  }
+
+  async acceptInvite(token: string, user: Record<string, any>) {
+    await axios.post(`${this.bagel.host}/auth/accept-invite/${token}`, user);
+    await this.login(user as User);
+  }
+
+  async register(
+    user: Record<string, any>,
+    errors: Record<string, any>,
+  ) {
+    try {
+      await axios.post<User>(`${this.bagel.host}/auth/register`, user);
+      this.login(user as User);
+    }
+    catch (err: any) {
+      console.error(err);
+
+      errors.email = err.response.data.detail;
+
+      throw err;
+    }
+  }
+}
+
+
+export class Bagel {
+  host: string;
+  onError?: (err: any) => void;
+  constructor({ host, onError }: Record<string, any>) {
+    this.host = host;
+    this.onError = onError;
+  }
+
+  read_table: Tables | null = null;
+  data(table: Tables): DataRequest<Tables> {
+    return new DataRequest(table, this);
+  }
+
+  auth = new BagelAuth(this);
+  _endpointCleaner(endpoint: string) {
+    const url = `${endpoint.replace(/^\//, '').replace(/\/$/g, '')}`;
+    return url;
+  }
+
+  async api(
+    endpoint: string,
+    query?: Record<string, string>,
+  ): Promise<Record<string, any>> {
+    if (query) {
+      const queryParams = Object.entries(query)
+        .map(([key, value]) => `${key}=${value}`)
+        .join('&');
+      endpoint = `${endpoint}?${queryParams}`;
+    }
+    return axios.get(`${this.host}/api/${endpoint}`).then(({ data }: { data: any }) => data);
+  }
+
+  async get<T = Record<string, any>>(
+    endpoint: string,
+    query?: Record<string, any>,
+  ): Promise<T> {
+    endpoint = this._endpointCleaner(endpoint);
+    if (endpoint.match(/undefined|null/))
+      throw new Error('Invalid endpoint');
+    if (query) {
+      const queryParams = Object.entries(query)
+        .filter(([_, value]) => !!value)
+        .map(([key, value]) => `${key}=${value}`)
+        .join('&');
+      if (queryParams)
+        endpoint = `${endpoint}?${queryParams}`;
+    }
+    const url = `${this.host}/${endpoint}`;
+    return axios
+      .get(url)
+      .then(({ data }: { data: any }) => data)
+      .catch((err: any) => {
+        this.onError?.(err);
+        throw err;
+      });
+  }
+
+  async delete(endpoint: string): Promise<Record<string, any>> {
+    endpoint = this._endpointCleaner(endpoint);
+    return axios
+      .delete(`${this.host}/${endpoint}`)
+      .then(({ data }: { data: any }) => data)
+      .catch((err: any) => {
+        this.onError?.(err);
+        throw err;
+      });
+  }
+
+  async put(endpoint: string, payload: any): Promise<Record<string, any>> {
+    endpoint = this._endpointCleaner(endpoint);
+    return axios
+      .put(`${this.host}/${endpoint}`, payload)
+      .then(({ data }: { data: any }) => data)
+      .catch((err: any) => {
+        this.onError?.(err);
+        throw err;
+      });
+  }
+
+  async patch(
+    endpoint: string,
+		payload: any = {},
+  ): Promise<Record<string, any>> {
+    endpoint = this._endpointCleaner(endpoint);
+    return axios
+      .patch(`${this.host}/${endpoint}`, payload)
+      .then(({ data }: { data: any }) => data)
+      .catch((err: any) => {
+        this.onError?.(err);
+        throw err;
+      });
+  }
+
+  async post(
+    endpoint: string,
+		payload: any = {},
+  ): Promise<Record<string, any>> {
+    endpoint = this._endpointCleaner(endpoint);
+    return axios
+      .post(`${this.host}/${endpoint}`, payload)
+      .then(({ data }: { data: any }) => data)
+      .catch((err: any) => {
+        this.onError?.(err);
+        throw err;
+      });
+  }
+
+  async uploadFile(file: File, options?: UploadOptions) {
+    const formData = new FormData();
+    formData.append('file', file);
+    // get an indication of the progress
+
+    const { data } = await axios.post(`${this.host}/files/upload`, formData, {
+      headers: {
+        'Content-Type': 'multipart/form-data',
+      },
+      onUploadProgress: options?.onUploadProgress,
+    });
+    return data;
+  }
+}