@bagelink/sdk 0.0.466 → 0.0.473

package/src/index.ts

@@ -1,101 +1,101 @@
-import ax from 'axios';
+import ax from 'axios'
 
-import openAPI from './openAPITools';
+import openAPI from './openAPITools'
 
-export type Tables = '';
-export type TableToTypeMapping = Record<Tables, any>;
+export type Tables = ''
+export type TableToTypeMapping = Record<Tables, any>
 
-export { openAPI };
+export { openAPI }
 export interface User {
-	id: string;
-	first_name?: string;
-	last_name?: string;
-	email?: string;
-	password?: string;
-	is_verified?: boolean;
-	locale: string;
-	type: string;
+	id: string
+	first_name?: string
+	last_name?: string
+	email?: string
+	password?: string
+	is_verified?: boolean
+	locale: string
+	type: string
 }
 
 interface UploadOptions {
-	// eslint-disable-next-line no-unused-vars
-	onUploadProgress?: (progressEvent: any) => void;
+
+	onUploadProgress?: (progressEvent: any) => void
 }
 
 const axios = ax.create({
 	withCredentials: true,
-});
+})
 
 class DataRequest<T extends Tables = Tables> {
-	data_table: T | Tables;
+	data_table: T | Tables
 
-	bagel: any;
+	bagel: any
 
-	itemID: string;
+	itemID: string
 
-	_filter: Record<string, any> = {};
+	_filter: Record<string, any> = {}
 
 	constructor(table: T, bagel: Bagel) {
-		this.data_table = table;
-		this.bagel = bagel;
-		this.itemID = '';
+		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(`/data/${this.data_table}`, item);
-		return data;
+		if (!this.data_table) throw new Error('Data table not set')
+		const { data } = await axios.post(`/data/${this.data_table}`, item)
+		return data
 	}
 
 	filter(filter: Record<string, any>) {
-		this._filter = filter;
-		return this;
+		this._filter = filter
+		return this
 	}
 
 	async get(): Promise<
 		TableToTypeMapping[T] | TableToTypeMapping[T][] | undefined
-		> {
-		if (!this.data_table) throw new Error('Data table not set');
+	> {
+		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 = `/data/${this.data_table}${
 			this.itemID ? `/${this.itemID}` : ''
-		}${filterStr}`;
+		}${filterStr}`
 		try {
-			const { data } = await axios.get(url);
-			return data;
+			const { data } = await axios.get(url)
+			return data
 		} catch (err) {
-			console.log(err);
-			this.bagel.onError?.(err);
-			return undefined;
+			console.log(err)
+			this.bagel.onError?.(err)
+			return undefined
 		}
 	}
 
 	item(id: string) {
-		this.itemID = id;
-		return this;
+		this.itemID = id
+		return this
 	}
 
 	async delete(): Promise<TableToTypeMapping[T][]> {
-		if (!this.data_table) throw new Error('Data table not set');
+		if (!this.data_table) throw new Error('Data table not set')
 		const { data } = await axios.delete(
 			`/data/${this.data_table}/${this.itemID}`,
-		);
-		return data;
+		)
+		return data
 	}
 
 	async put(updatedItem: Record<string, any>): Promise<Record<string, any>> {
-		const { data_table, itemID } = this;
-		if (!data_table) throw new Error('Data table not set');
-		if (!itemID) throw new Error('Item ID not set');
+		const { data_table, itemID } = 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(
 			`/data/${data_table}/${itemID}`,
 			updatedItem,
-		);
-		return data;
+		)
+		return data
 	}
 }
 
@@ -103,118 +103,117 @@ 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;
+	}
+	return res[key] || key
 }
 
 class BagelAuth {
 	constructor(private bagel: Bagel) {
-		this.bagel = bagel;
+		this.bagel = bagel
 	}
 
-	user: User | null = null;
+	user: User | null = null
 
 	async validateUser(): Promise<User | null> {
 		try {
 			const { data: usr } = await axios.get('/users/me', {
 				withCredentials: true,
-			});
-			this.user = usr;
-			return usr;
+			})
+			this.user = usr
+			return usr
 		} catch (err) {
-			return null;
+			return null
 		}
 	}
 
-	async resetPassword(ctx: { token: string; password: string }) {
+	async resetPassword(ctx: { token: string, password: string }) {
 		return this.bagel.post('auth/reset-password', ctx).catch((err) => {
-			throw responses(err.response?.data?.detail);
-		});
+			throw responses(err.response?.data?.detail)
+		})
 	}
 
 	async forgotPassword(email: string) {
 		try {
-			await this.bagel.post('auth/forgot-password', { email });
+			await this.bagel.post('auth/forgot-password', { email })
 		} catch (err: any) {
-			throw responses(err?.response?.data?.detail);
+			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 || '');
-		console.log('Logging in');
+		const formData = new FormData()
+		formData.append('username', user.email || '')
+		formData.append('password', user.password || '')
+		console.log('Logging in')
 		try {
 			await axios.post('/auth/cookie/login', formData, {
 				headers: {
-					withCredentials: true,
+					'withCredentials': true,
 					'Content-Type': 'multipart/form-data',
 				},
-			});
-			axios.defaults.withCredentials = true;
-			return this.validateUser();
+			})
+			axios.defaults.withCredentials = true
+			return this.validateUser()
 		} catch (err: any) {
-			throw responses(err.response?.data?.detail || 'LOGIN_BAD_CREDENTIALS');
+			throw responses(err.response?.data?.detail || 'LOGIN_BAD_CREDENTIALS')
 		}
 	}
 
 	async logout() {
 		try {
-			await axios.post('/auth/cookie/logout');
+			await axios.post('/auth/cookie/logout')
 		} catch (err) {
-			this.bagel.onError?.(err);
-			console.log(err);
+			this.bagel.onError?.(err)
+			console.log(err)
 		}
-		this.user = null;
+		this.user = null
 	}
 
 	async acceptInvite(token: string, user: Record<string, any>) {
-		await axios.post(`/auth/accept-invite/${token}`, user);
-		await this.login(user as User);
+		await axios.post(`/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>('/auth/register', user);
-			return this.login(user as User);
+			await axios.post<User>('/auth/register', user)
+			return this.login(user as User)
 		} catch (err: any) {
-			console.error(err);
+			console.error(err)
 
-			errors.email = err.response.data.detail;
+			errors.email = err.response.data.detail
 
-			throw err;
+			throw err
 		}
 	}
 }
 export class Bagel {
-	host?: string;
+	host?: string
 
-	// eslint-disable-next-line no-unused-vars
-	onError?: (err: any) => void;
+	onError?: (err: any) => void
 
 	constructor({ host, onError }: Record<string, any>) {
-		this.host = host?.replace(/\/$/, '');
+		this.host = host?.replace(/\/$/, '')
 		if (!this.host) {
 			throw new Error(
 				'you probably need to set VITE_BAGEL_BASE_URL in the .env file',
-			);
+			)
 		}
-		axios.defaults.baseURL = this.host;
-		this.onError = onError;
+		axios.defaults.baseURL = this.host
+		this.onError = onError
 	}
 
-	read_table: Tables | null = null;
+	read_table: Tables | null = null
 
 	data(table: Tables): DataRequest<Tables> {
-		return new DataRequest(table, this);
+		return new DataRequest(table, this)
 	}
 
-	auth = new BagelAuth(this);
+	auth = new BagelAuth(this)
 
 	_endpointCleaner(endpoint: string) {
-		const url = `${endpoint.replace(/^\//, '').replace(/\/$/g, '')}`;
-		return url;
+		const url = `${endpoint.replace(/^\//, '').replace(/\/$/g, '')}`
+		return url
 	}
 
 	async api(
@@ -224,81 +223,81 @@ export class Bagel {
 		if (query) {
 			const queryParams = Object.entries(query)
 				.map(([key, value]) => `${key}=${value}`)
-				.join('&');
-			endpoint = `${endpoint}?${queryParams}`;
+				.join('&')
+			endpoint = `${endpoint}?${queryParams}`
 		}
 		return axios
 			.get(`/api/${endpoint}`)
-			.then(({ data }: { data: any }) => data);
+			.then(({ data }: { data: any }) => data)
 	}
 
 	async get<T = Record<string, any>>(
 		endpoint: string,
 		query?: Record<string, any>,
 	): Promise<T> {
-		this._setAuthorization();
-		endpoint = this._endpointCleaner(endpoint);
-		if (endpoint.match(/undefined|null/)) throw new Error('Invalid endpoint');
+		this._setAuthorization()
+		endpoint = this._endpointCleaner(endpoint)
+		if (endpoint.match(/undefined|null/)) throw new Error('Invalid endpoint')
 		if (query) {
 			const queryParams = Object.entries(query)
-				// eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars
+				// eslint-disable-next-line @typescript-eslint/no-unused-vars
 				.filter(([_, value]) => !!value)
 				.map(([key, value]) => `${key}=${value}`)
-				.join('&');
-			if (queryParams) endpoint = `${endpoint}?${queryParams}`;
+				.join('&')
+			if (queryParams) endpoint = `${endpoint}?${queryParams}`
 		}
-		const url = `/${endpoint}`;
+		const url = `/${endpoint}`
 		return axios
 			.get(url)
 			.then(({ data }: { data: any }) => data)
 			.catch((err: any) => {
-				this.onError?.(err);
-				throw err;
-			});
+				this.onError?.(err)
+				throw err
+			})
 	}
 
 	async delete(endpoint: string): Promise<Record<string, any>> {
-		this._setAuthorization();
-		endpoint = this._endpointCleaner(endpoint);
+		this._setAuthorization()
+		endpoint = this._endpointCleaner(endpoint)
 		return axios
 			.delete(`/${endpoint}`)
 			.then(({ data }: { data: any }) => data)
 			.catch((err: any) => {
-				this.onError?.(err);
-				throw err;
-			});
+				this.onError?.(err)
+				throw err
+			})
 	}
 
 	async put(endpoint: string, payload: any): Promise<Record<string, any>> {
-		endpoint = this._endpointCleaner(endpoint);
-		this._setAuthorization();
+		endpoint = this._endpointCleaner(endpoint)
+		this._setAuthorization()
 		return axios
 			.put(`/${endpoint}`, payload)
 			.then(({ data }: { data: any }) => data)
 			.catch((err: any) => {
-				this.onError?.(err);
-				throw err;
-			});
+				this.onError?.(err)
+				throw err
+			})
 	}
 
 	async patch(
 		endpoint: string,
 		payload: any = {},
 	): Promise<Record<string, any>> {
-		endpoint = this._endpointCleaner(endpoint);
+		endpoint = this._endpointCleaner(endpoint)
 		return axios
 			.patch(`/${endpoint}`, payload)
 			.then(({ data }: { data: any }) => data)
 			.catch((err: any) => {
-				this.onError?.(err);
-				throw err;
-			});
+				this.onError?.(err)
+				throw err
+			})
 	}
 
 	_setAuthorization() {
-		const Authorization = localStorage.getItem('access_token');
+		const Authorization = localStorage.getItem('access_token')
 		if (Authorization) {
-			axios.defaults.headers.common.Authorization = `Bearer ${Authorization}`;
+			axios.defaults.headers.common.Authorization = `Bearer ${Authorization}`
 		}
 	}
 
@@ -306,21 +305,21 @@ export class Bagel {
 		endpoint: string,
 		payload: any = {},
 	): Promise<Record<string, any>> {
-		this._setAuthorization();
-		endpoint = this._endpointCleaner(endpoint);
+		this._setAuthorization()
+		endpoint = this._endpointCleaner(endpoint)
 		return axios
 			.post(`/${endpoint}`, payload)
 			.then(({ data }: { data: any }) => data)
 			.catch((err: any) => {
-				this.onError?.(err);
-				throw err;
-			});
+				this.onError?.(err)
+				throw err
+			})
 	}
 
 	async uploadFile<T = any>(file: File, options?: UploadOptions): Promise<T> {
-		this._setAuthorization();
-		const formData = new FormData();
-		formData.append('file', file);
+		this._setAuthorization()
+		const formData = new FormData()
+		formData.append('file', file)
 		// get an indication of the progress
 
 		const { data } = await axios.post<T>('/static_files/upload', formData, {
@@ -328,7 +327,7 @@ export class Bagel {
 				'Content-Type': 'multipart/form-data',
 			},
 			onUploadProgress: options?.onUploadProgress,
-		});
-		return data;
+		})
+		return data
 	}
 }