@bagelink/sdk 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Neveh Allon
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,65 @@
+# @bagelink/vue
+
+Features:
+
+- Build with [unbuild](https://github.com/unjs/unbuild)
+- File-to-file transpilation via [mkdist](https://github.com/unjs/mkdist)
+- Playground with [vite](https://vitejs.dev/)
+
+## Usage
+
+Use component globally
+
+```ts
+// src/main.ts
+import { createApp } from 'vue';
+import { BagelVue } from '@bagel/vue';
+
+import App from './App.vue';
+
+const BagelConfig = {
+  host: import.meta.env.VITE_BASE_URL,
+  // eslint-disable-next-line n/handle-callback-err
+  onError: (err: any) => {
+    // handle error
+    // example:
+    // useToast().error(`${$t('anErrorOccurred')}: ${err?.response?.data?.detail || err.message}`);
+  },
+};
+
+const app = createApp(App);
+app.use(head as Plugin);
+
+app.mount('#app');
+```
+
+Import component
+
+```vue
+<script setup lang="ts">
+import { useBagel } from '@bagel/vue';
+
+const bagel = useBagel();
+</script>
+
+<!-- OR -->
+<script lang="ts">
+export default defineComponent({
+  onMounted() {
+    console.log(this.$bagel.host)
+  },
+});
+</script>
+
+<!-- OR -->
+<template>
+	<div>
+		{{ $bagel.host }}
+	</div>
+</template>
+```
+
+
+## License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,235 @@
+'use strict';
+
+const ax = require('axios');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const ax__default = /*#__PURE__*/_interopDefaultCompat(ax);
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+const axios = ax__default.create({
+  // withCredentials to true to send cookies with requests
+  withCredentials: true
+});
+class DataRequest {
+  constructor(table, bagel) {
+    __publicField(this, "data_table");
+    __publicField(this, "bagel");
+    __publicField(this, "itemID");
+    __publicField(this, "_filter", {});
+    this.data_table = table;
+    this.bagel = bagel;
+    this.itemID = "";
+  }
+  async post(item) {
+    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) {
+    this._filter = filter;
+    return this;
+  }
+  async get() {
+    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 void 0;
+    }
+  }
+  item(id) {
+    this.itemID = id;
+    return this;
+  }
+  async delete() {
+    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) {
+    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) {
+  const res = {
+    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(bagel) {
+    this.bagel = bagel;
+    __publicField(this, "user", null);
+    this.bagel = bagel;
+  }
+  async validateUser() {
+    try {
+      const usr = await this.bagel.get("/users/me");
+      this.user = usr;
+      return usr;
+    } catch (err) {
+      console.log(err);
+      return null;
+    }
+  }
+  async resetPassword(ctx) {
+    return this.bagel.post("auth/reset-password", ctx).catch((err) => {
+      throw responses(err.response?.data?.detail);
+    });
+  }
+  async forgotPassword(email) {
+    try {
+      await this.bagel.post("auth/forgot-password", { email });
+    } catch (err) {
+      throw responses(err?.response?.data?.detail);
+    }
+  }
+  async login(user) {
+    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) {
+      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, user) {
+    await axios.post(`${this.bagel.host}/auth/accept-invite/${token}`, user);
+    await this.login(user);
+  }
+  async register(user, errors) {
+    try {
+      await axios.post(`${this.bagel.host}/auth/register`, user);
+      this.login(user);
+    } catch (err) {
+      console.error(err);
+      errors.email = err.response.data.detail;
+      throw err;
+    }
+  }
+}
+class Bagel {
+  constructor({ host, onError }) {
+    __publicField(this, "host");
+    __publicField(this, "onError");
+    __publicField(this, "read_table", null);
+    __publicField(this, "auth", new BagelAuth(this));
+    this.host = host;
+    this.onError = onError;
+  }
+  data(table) {
+    return new DataRequest(table, this);
+  }
+  _endpointCleaner(endpoint) {
+    const url = `${endpoint.replace(/^\//, "").replace(/\/$/g, "")}`;
+    return url;
+  }
+  async api(endpoint, query) {
+    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);
+  }
+  async get(endpoint, query) {
+    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).catch((err) => {
+      this.onError?.(err);
+      throw err;
+    });
+  }
+  async delete(endpoint) {
+    endpoint = this._endpointCleaner(endpoint);
+    return axios.delete(`${this.host}/${endpoint}`).then(({ data }) => data).catch((err) => {
+      this.onError?.(err);
+      throw err;
+    });
+  }
+  async put(endpoint, payload) {
+    endpoint = this._endpointCleaner(endpoint);
+    return axios.put(`${this.host}/${endpoint}`, payload).then(({ data }) => data).catch((err) => {
+      this.onError?.(err);
+      throw err;
+    });
+  }
+  async patch(endpoint, payload = {}) {
+    endpoint = this._endpointCleaner(endpoint);
+    return axios.patch(`${this.host}/${endpoint}`, payload).then(({ data }) => data).catch((err) => {
+      this.onError?.(err);
+      throw err;
+    });
+  }
+  async post(endpoint, payload = {}) {
+    endpoint = this._endpointCleaner(endpoint);
+    return axios.post(`${this.host}/${endpoint}`, payload).then(({ data }) => data).catch((err) => {
+      this.onError?.(err);
+      throw err;
+    });
+  }
+  async uploadFile(file, options) {
+    const formData = new FormData();
+    formData.append("file", file);
+    const { data } = await axios.post(`${this.host}/files/upload`, formData, {
+      headers: {
+        "Content-Type": "multipart/form-data"
+      },
+      onUploadProgress: options?.onUploadProgress
+    });
+    return data;
+  }
+}
+
+exports.Bagel = Bagel;

package/dist/index.d.cts

@@ -0,0 +1,61 @@
+type Tables = '';
+type TableToTypeMapping = Record<Tables, any>;
+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;
+}
+declare class DataRequest<T extends Tables = Tables> {
+    data_table: T | Tables;
+    bagel: any;
+    itemID: string;
+    _filter: Record<string, any>;
+    constructor(table: T, bagel: Bagel);
+    post(item: Record<string, any>): Promise<Record<string, any>>;
+    filter(filter: Record<string, any>): this;
+    get(): Promise<TableToTypeMapping[T] | TableToTypeMapping[T][] | undefined>;
+    item(id: string): this;
+    delete(): Promise<TableToTypeMapping[T][]>;
+    put(updatedItem: Record<string, any>): Promise<Record<string, any>>;
+}
+declare class BagelAuth {
+    private bagel;
+    constructor(bagel: Bagel);
+    user: User | null;
+    validateUser(): Promise<User | null>;
+    resetPassword(ctx: {
+        token: string;
+        password: string;
+    }): Promise<Record<string, any>>;
+    forgotPassword(email: string): Promise<void>;
+    login(user: User): Promise<User | null>;
+    logout(): Promise<void>;
+    acceptInvite(token: string, user: Record<string, any>): Promise<void>;
+    register(user: Record<string, any>, errors: Record<string, any>): Promise<void>;
+}
+declare class Bagel {
+    host: string;
+    onError?: (err: any) => void;
+    constructor({ host, onError }: Record<string, any>);
+    read_table: Tables | null;
+    data(table: Tables): DataRequest<Tables>;
+    auth: BagelAuth;
+    _endpointCleaner(endpoint: string): string;
+    api(endpoint: string, query?: Record<string, string>): Promise<Record<string, any>>;
+    get<T = Record<string, any>>(endpoint: string, query?: Record<string, any>): Promise<T>;
+    delete(endpoint: string): Promise<Record<string, any>>;
+    put(endpoint: string, payload: any): Promise<Record<string, any>>;
+    patch(endpoint: string, payload?: any): Promise<Record<string, any>>;
+    post(endpoint: string, payload?: any): Promise<Record<string, any>>;
+    uploadFile(file: File, options?: UploadOptions): Promise<any>;
+}
+
+export { Bagel, type TableToTypeMapping, type Tables, type User };

package/dist/index.d.mts

@@ -0,0 +1,61 @@
+type Tables = '';
+type TableToTypeMapping = Record<Tables, any>;
+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;
+}
+declare class DataRequest<T extends Tables = Tables> {
+    data_table: T | Tables;
+    bagel: any;
+    itemID: string;
+    _filter: Record<string, any>;
+    constructor(table: T, bagel: Bagel);
+    post(item: Record<string, any>): Promise<Record<string, any>>;
+    filter(filter: Record<string, any>): this;
+    get(): Promise<TableToTypeMapping[T] | TableToTypeMapping[T][] | undefined>;
+    item(id: string): this;
+    delete(): Promise<TableToTypeMapping[T][]>;
+    put(updatedItem: Record<string, any>): Promise<Record<string, any>>;
+}
+declare class BagelAuth {
+    private bagel;
+    constructor(bagel: Bagel);
+    user: User | null;
+    validateUser(): Promise<User | null>;
+    resetPassword(ctx: {
+        token: string;
+        password: string;
+    }): Promise<Record<string, any>>;
+    forgotPassword(email: string): Promise<void>;
+    login(user: User): Promise<User | null>;
+    logout(): Promise<void>;
+    acceptInvite(token: string, user: Record<string, any>): Promise<void>;
+    register(user: Record<string, any>, errors: Record<string, any>): Promise<void>;
+}
+declare class Bagel {
+    host: string;
+    onError?: (err: any) => void;
+    constructor({ host, onError }: Record<string, any>);
+    read_table: Tables | null;
+    data(table: Tables): DataRequest<Tables>;
+    auth: BagelAuth;
+    _endpointCleaner(endpoint: string): string;
+    api(endpoint: string, query?: Record<string, string>): Promise<Record<string, any>>;
+    get<T = Record<string, any>>(endpoint: string, query?: Record<string, any>): Promise<T>;
+    delete(endpoint: string): Promise<Record<string, any>>;
+    put(endpoint: string, payload: any): Promise<Record<string, any>>;
+    patch(endpoint: string, payload?: any): Promise<Record<string, any>>;
+    post(endpoint: string, payload?: any): Promise<Record<string, any>>;
+    uploadFile(file: File, options?: UploadOptions): Promise<any>;
+}
+
+export { Bagel, type TableToTypeMapping, type Tables, type User };

package/dist/index.d.ts

@@ -0,0 +1,61 @@
+type Tables = '';
+type TableToTypeMapping = Record<Tables, any>;
+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;
+}
+declare class DataRequest<T extends Tables = Tables> {
+    data_table: T | Tables;
+    bagel: any;
+    itemID: string;
+    _filter: Record<string, any>;
+    constructor(table: T, bagel: Bagel);
+    post(item: Record<string, any>): Promise<Record<string, any>>;
+    filter(filter: Record<string, any>): this;
+    get(): Promise<TableToTypeMapping[T] | TableToTypeMapping[T][] | undefined>;
+    item(id: string): this;
+    delete(): Promise<TableToTypeMapping[T][]>;
+    put(updatedItem: Record<string, any>): Promise<Record<string, any>>;
+}
+declare class BagelAuth {
+    private bagel;
+    constructor(bagel: Bagel);
+    user: User | null;
+    validateUser(): Promise<User | null>;
+    resetPassword(ctx: {
+        token: string;
+        password: string;
+    }): Promise<Record<string, any>>;
+    forgotPassword(email: string): Promise<void>;
+    login(user: User): Promise<User | null>;
+    logout(): Promise<void>;
+    acceptInvite(token: string, user: Record<string, any>): Promise<void>;
+    register(user: Record<string, any>, errors: Record<string, any>): Promise<void>;
+}
+declare class Bagel {
+    host: string;
+    onError?: (err: any) => void;
+    constructor({ host, onError }: Record<string, any>);
+    read_table: Tables | null;
+    data(table: Tables): DataRequest<Tables>;
+    auth: BagelAuth;
+    _endpointCleaner(endpoint: string): string;
+    api(endpoint: string, query?: Record<string, string>): Promise<Record<string, any>>;
+    get<T = Record<string, any>>(endpoint: string, query?: Record<string, any>): Promise<T>;
+    delete(endpoint: string): Promise<Record<string, any>>;
+    put(endpoint: string, payload: any): Promise<Record<string, any>>;
+    patch(endpoint: string, payload?: any): Promise<Record<string, any>>;
+    post(endpoint: string, payload?: any): Promise<Record<string, any>>;
+    uploadFile(file: File, options?: UploadOptions): Promise<any>;
+}
+
+export { Bagel, type TableToTypeMapping, type Tables, type User };

package/dist/index.mjs

@@ -0,0 +1,229 @@
+import ax from 'axios';
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+const axios = ax.create({
+  // withCredentials to true to send cookies with requests
+  withCredentials: true
+});
+class DataRequest {
+  constructor(table, bagel) {
+    __publicField(this, "data_table");
+    __publicField(this, "bagel");
+    __publicField(this, "itemID");
+    __publicField(this, "_filter", {});
+    this.data_table = table;
+    this.bagel = bagel;
+    this.itemID = "";
+  }
+  async post(item) {
+    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) {
+    this._filter = filter;
+    return this;
+  }
+  async get() {
+    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 void 0;
+    }
+  }
+  item(id) {
+    this.itemID = id;
+    return this;
+  }
+  async delete() {
+    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) {
+    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) {
+  const res = {
+    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(bagel) {
+    this.bagel = bagel;
+    __publicField(this, "user", null);
+    this.bagel = bagel;
+  }
+  async validateUser() {
+    try {
+      const usr = await this.bagel.get("/users/me");
+      this.user = usr;
+      return usr;
+    } catch (err) {
+      console.log(err);
+      return null;
+    }
+  }
+  async resetPassword(ctx) {
+    return this.bagel.post("auth/reset-password", ctx).catch((err) => {
+      throw responses(err.response?.data?.detail);
+    });
+  }
+  async forgotPassword(email) {
+    try {
+      await this.bagel.post("auth/forgot-password", { email });
+    } catch (err) {
+      throw responses(err?.response?.data?.detail);
+    }
+  }
+  async login(user) {
+    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) {
+      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, user) {
+    await axios.post(`${this.bagel.host}/auth/accept-invite/${token}`, user);
+    await this.login(user);
+  }
+  async register(user, errors) {
+    try {
+      await axios.post(`${this.bagel.host}/auth/register`, user);
+      this.login(user);
+    } catch (err) {
+      console.error(err);
+      errors.email = err.response.data.detail;
+      throw err;
+    }
+  }
+}
+class Bagel {
+  constructor({ host, onError }) {
+    __publicField(this, "host");
+    __publicField(this, "onError");
+    __publicField(this, "read_table", null);
+    __publicField(this, "auth", new BagelAuth(this));
+    this.host = host;
+    this.onError = onError;
+  }
+  data(table) {
+    return new DataRequest(table, this);
+  }
+  _endpointCleaner(endpoint) {
+    const url = `${endpoint.replace(/^\//, "").replace(/\/$/g, "")}`;
+    return url;
+  }
+  async api(endpoint, query) {
+    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);
+  }
+  async get(endpoint, query) {
+    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).catch((err) => {
+      this.onError?.(err);
+      throw err;
+    });
+  }
+  async delete(endpoint) {
+    endpoint = this._endpointCleaner(endpoint);
+    return axios.delete(`${this.host}/${endpoint}`).then(({ data }) => data).catch((err) => {
+      this.onError?.(err);
+      throw err;
+    });
+  }
+  async put(endpoint, payload) {
+    endpoint = this._endpointCleaner(endpoint);
+    return axios.put(`${this.host}/${endpoint}`, payload).then(({ data }) => data).catch((err) => {
+      this.onError?.(err);
+      throw err;
+    });
+  }
+  async patch(endpoint, payload = {}) {
+    endpoint = this._endpointCleaner(endpoint);
+    return axios.patch(`${this.host}/${endpoint}`, payload).then(({ data }) => data).catch((err) => {
+      this.onError?.(err);
+      throw err;
+    });
+  }
+  async post(endpoint, payload = {}) {
+    endpoint = this._endpointCleaner(endpoint);
+    return axios.post(`${this.host}/${endpoint}`, payload).then(({ data }) => data).catch((err) => {
+      this.onError?.(err);
+      throw err;
+    });
+  }
+  async uploadFile(file, options) {
+    const formData = new FormData();
+    formData.append("file", file);
+    const { data } = await axios.post(`${this.host}/files/upload`, formData, {
+      headers: {
+        "Content-Type": "multipart/form-data"
+      },
+      onUploadProgress: options?.onUploadProgress
+    });
+    return data;
+  }
+}
+
+export { Bagel };

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@bagelink/sdk",
+  "type": "module",
+  "version": "0.0.1",
+  "description": "Bagel core sdk packages",
+  "author": {
+    "name": "Neveh Allon",
+    "email": "neveh@bagelstudio.co.il",
+    "url": "https://github.com/nevehallon"
+  },
+  "license": "MIT",
+  "homepage": "https://github.com/bageldb/bagelink/tree/master/packages/sdk#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bageldb/bagelink.git",
+    "directory": "packages/sdk"
+  },
+  "bugs": "https://github.com/bageldb/bagelink/issues",
+  "keywords": [],
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.cjs",
+      "import": "./dist/index.mjs"
+    }
+  },
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "typesVersions": {
+    "*": {
+      "*": [
+        "./dist/*",
+        "./dist/index.d.ts"
+      ]
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "axios": "^1.6.1"
+  },
+  "scripts": {
+    "dev": "unbuild --stub",
+    "build": "unbuild",
+    "start": "tsx src/index.ts",
+    "watch": "tsx watch src/index.ts"
+  }
+}