@bagelink/sdk 1.20.54 → 1.20.58

package/src/index.js

@@ -0,0 +1,715 @@
+import ax from 'axios';
+import { ref } from 'vue';
+import { createSSEStream, createSSEStreamPost } from './openAPITools/streamClient';
+export * from './openAPITools';
+export { default as openAPI } from './openAPITools';
+export { createSSEStream, createSSEStreamPost, StreamController } from './openAPITools/streamClient';
+export { unwrap } from './unwrap';
+/**
+ * Enhanced API response that adds metadata to the response data
+ * - For arrays: acts as array with metadata properties
+ * - For objects: object with metadata properties (no array wrapping!)
+ * @template TData - The response data type
+ */
+export class ApiResponse extends Array {
+    /** Raw axios response */
+    $raw;
+    /** Total number of items (from x-total header) */
+    total;
+    /** Number of items per page (from x-limit header) */
+    limit;
+    /** Number of items skipped (from x-offset header) */
+    offset;
+    /** Current page number (calculated: Math.floor(offset / limit) + 1) */
+    page;
+    /** Total number of pages (calculated: Math.ceil(total / limit)) */
+    totalPages;
+    /** Rate limit remaining (from x-ratelimit-remaining header) */
+    rateLimit;
+    /** Rate limit reset timestamp (from x-ratelimit-reset header) */
+    rateLimitReset;
+    /** All response metadata */
+    $metadata;
+    constructor(data, response) {
+        // Must call super first when extending Array
+        super();
+        // For arrays, add items and metadata
+        if (Array.isArray(data)) {
+            this.push(...data);
+            if (response) {
+                this.$raw = response;
+                this.$metadata = ApiResponse.parseMetadataStatic(response);
+                this.total = this.$metadata.total;
+                this.limit = this.$metadata.limit;
+                this.offset = this.$metadata.offset;
+                this.page = this.$metadata.page;
+                this.totalPages = this.$metadata.totalPages;
+                this.rateLimit = this.$metadata.rateLimit;
+                this.rateLimitReset = this.$metadata.rateLimitReset;
+            }
+        }
+    }
+    /**
+     * Create an ApiResponse from data and response
+     * Factory method to handle both arrays and objects
+     */
+    static create(data, response) {
+        // Primitive payloads cannot carry response metadata. Return them as-is
+        // instead of boxing them into an object that loses the actual value.
+        if (data === null || typeof data !== 'object') {
+            return data;
+        }
+        // For single objects, attach metadata directly
+        if (!Array.isArray(data)) {
+            const obj = Object.assign(Object.create(null), data);
+            obj.$raw = response;
+            obj.$metadata = ApiResponse.parseMetadataStatic(response);
+            obj.total = obj.$metadata.total;
+            obj.limit = obj.$metadata.limit;
+            obj.offset = obj.$metadata.offset;
+            obj.page = obj.$metadata.page;
+            obj.totalPages = obj.$metadata.totalPages;
+            obj.rateLimit = obj.$metadata.rateLimit;
+            obj.rateLimitReset = obj.$metadata.rateLimitReset;
+            obj.getHeader = (name) => response?.headers[name.toLowerCase()];
+            obj.hasPagination = obj.total !== undefined || obj.offset !== undefined;
+            obj.hasNextPage = obj.total !== undefined && obj.limit !== undefined && obj.offset !== undefined
+                ? obj.offset + obj.limit < obj.total
+                : false;
+            obj.hasPrevPage = obj.offset !== undefined ? obj.offset > 0 : false;
+            return obj;
+        }
+        // For arrays, create ApiResponse instance
+        const instance = new ApiResponse(data, response);
+        return instance;
+    }
+    static parseMetadataStatic(response) {
+        const { headers } = response;
+        const metadata = {};
+        const get = (name) => {
+            if (typeof headers.get === 'function')
+                return headers.get(name);
+            const lower = name.toLowerCase();
+            const key = Object.keys(headers).find(k => k.toLowerCase() === lower);
+            return key ? headers[key] : undefined;
+        };
+        if (get('x-total')) {
+            metadata.total = Number(get('x-total'));
+        }
+        if (get('x-limit')) {
+            metadata.limit = Number(get('x-limit'));
+        }
+        if (get('x-offset')) {
+            metadata.offset = Number(get('x-offset'));
+        }
+        if (metadata.total !== undefined && metadata.limit) {
+            metadata.totalPages = Math.ceil(metadata.total / metadata.limit);
+        }
+        if (metadata.offset !== undefined && metadata.limit) {
+            metadata.page = Math.floor(metadata.offset / metadata.limit) + 1;
+        }
+        if (headers['x-ratelimit-remaining'] || headers['x-rate-limit-remaining']) {
+            metadata.rateLimit = Number(headers['x-ratelimit-remaining'] || headers['x-rate-limit-remaining']);
+        }
+        if (headers['x-ratelimit-reset'] || headers['x-rate-limit-reset']) {
+            metadata.rateLimitReset = Number(headers['x-ratelimit-reset'] || headers['x-rate-limit-reset']);
+        }
+        Object.keys(headers).forEach((key) => {
+            if (key.startsWith('x-') && !metadata[key]) {
+                metadata[key] = headers[key];
+            }
+        });
+        return metadata;
+    }
+    getHeader(name) {
+        return this.$raw.headers[name.toLowerCase()];
+    }
+    get hasPagination() {
+        return this.total !== undefined || this.offset !== undefined;
+    }
+    get hasNextPage() {
+        if (this.total === undefined || this.limit === undefined || this.offset === undefined)
+            return false;
+        return this.offset + this.limit < this.total;
+    }
+    get hasPrevPage() {
+        if (this.offset === undefined)
+            return false;
+        return this.offset > 0;
+    }
+}
+/**
+ * Parse FastAPI/Pydantic validation errors into human-readable format
+ */
+export function parseApiError(error) {
+    const axiosError = error;
+    if (!axiosError.response?.data) {
+        return {
+            message: axiosError.message || 'An unexpected error occurred',
+            raw: error
+        };
+    }
+    const { detail } = axiosError.response.data;
+    if (typeof detail === 'string') {
+        return {
+            message: detail,
+            raw: error
+        };
+    }
+    if (Array.isArray(detail)) {
+        const fields = {};
+        const messages = [];
+        for (const err of detail) {
+            const fieldPath = err.loc.slice(1).join('.');
+            const message = err.msg;
+            if (fieldPath) {
+                if (!fields[fieldPath]) {
+                    fields[fieldPath] = [];
+                }
+                fields[fieldPath].push(message);
+            }
+            messages.push(fieldPath ? `${fieldPath}: ${message}` : message);
+        }
+        return {
+            message: messages.join('; '),
+            fields,
+            raw: error
+        };
+    }
+    return {
+        message: 'An error occurred',
+        raw: error
+    };
+}
+/**
+ * Format field errors for display
+ */
+export function formatFieldErrors(fields) {
+    return Object.entries(fields)
+        .map(([field, errors]) => `${field}: ${errors.join(', ')}`)
+        .join('\n');
+}
+function joinURL(baseURL, path) {
+    if (/^https?:\/\//i.test(path))
+        return path;
+    if (!baseURL)
+        return path;
+    return `${baseURL.replace(/\/$/, '')}/${path.replace(/^\//, '')}`;
+}
+async function getTransportHeaders(config, options) {
+    const optionHeaders = typeof options.headers === 'function'
+        ? await options.headers()
+        : (options.headers ?? {});
+    const configuredHeaders = config.axiosConfig?.headers;
+    const headers = typeof configuredHeaders?.toJSON === 'function'
+        ? configuredHeaders.toJSON()
+        : (configuredHeaders ?? {});
+    const token = await config.auth?.getToken?.();
+    return {
+        ...headers,
+        ...(token ? { Authorization: `${config.auth?.tokenPrefix ?? 'Bearer'} ${token}` } : {}),
+        ...optionHeaders,
+    };
+}
+/**
+ * Create an isolated transport. Multiple generated clients can safely use
+ * different base URLs, credentials, auth providers, and interceptors.
+ */
+export function createApiTransport(config = {}) {
+    const configRef = ref(null);
+    const lastResponse = ref(null);
+    const axios = ax.create({
+        baseURL: config.baseURL,
+        withCredentials: config.withCredentials ?? config.axiosConfig?.withCredentials ?? true,
+        paramsSerializer: { indexes: null },
+        ...config.axiosConfig,
+    });
+    const streamOptions = async (options = {}) => {
+        const currentConfig = configRef.value ?? {};
+        return {
+            ...options,
+            withCredentials: options.withCredentials ?? currentConfig.withCredentials,
+            headers: await getTransportHeaders(currentConfig, options),
+        };
+    };
+    const streamURL = (path) => joinURL(configRef.value?.streamBaseURL ?? axios.defaults.baseURL ?? '', path);
+    const transport = {
+        axios,
+        config: configRef,
+        lastResponse,
+        getStreamBaseURL: () => configRef.value?.streamBaseURL ?? axios.defaults.baseURL ?? '',
+        createSSEStream: (path, options = {}) => createSSEStream(streamURL(path), {
+            ...options,
+            headers: async () => (await streamOptions(options)).headers,
+            withCredentials: options.withCredentials ?? configRef.value?.withCredentials,
+        }),
+        createSSEStreamPost: (path, body, options = {}) => createSSEStreamPost(streamURL(path), body, {
+            ...options,
+            headers: async () => (await streamOptions(options)).headers,
+            withCredentials: options.withCredentials ?? configRef.value?.withCredentials,
+        }),
+    };
+    return configureApiTransport(transport, config);
+}
+/**
+ * Reconfigure an existing transport without changing its Axios identity.
+ * This supports legacy generated `axios` exports while keeping bindings isolated.
+ */
+export function configureApiTransport(transport, config = {}) {
+    const previousConfig = transport.config.value ?? {};
+    const resolvedConfig = {
+        ...previousConfig,
+        ...config,
+        axiosConfig: {
+            ...previousConfig.axiosConfig,
+            ...config.axiosConfig,
+        },
+        withCredentials: config.withCredentials
+            ?? config.axiosConfig?.withCredentials
+            ?? previousConfig.withCredentials
+            ?? true,
+    };
+    transport.config.value = resolvedConfig;
+    transport.axios.defaults.baseURL = resolvedConfig.baseURL;
+    transport.axios.defaults.withCredentials = resolvedConfig.withCredentials;
+    if (resolvedConfig.axiosConfig) {
+        Object.assign(transport.axios.defaults, resolvedConfig.axiosConfig);
+    }
+    transport.axios.interceptors.request.clear();
+    transport.axios.interceptors.response.clear();
+    if (resolvedConfig.auth) {
+        transport.axios.interceptors.request.use(async (requestConfig) => {
+            const token = await resolvedConfig.auth.getToken?.();
+            if (token) {
+                requestConfig.headers.Authorization = `${resolvedConfig.auth.tokenPrefix ?? 'Bearer'} ${token}`;
+            }
+            return requestConfig;
+        });
+    }
+    if (resolvedConfig.interceptors?.request) {
+        transport.axios.interceptors.request.use(resolvedConfig.interceptors.request);
+    }
+    transport.axios.interceptors.response.use((response) => {
+        transport.lastResponse.value = response;
+        return resolvedConfig.interceptors?.response?.(response) ?? response;
+    }, async (error) => {
+        if (error.response?.status === 401) {
+            await resolvedConfig.auth?.onUnauthorized?.();
+        }
+        resolvedConfig.onError?.(parseApiError(error), error);
+        throw error;
+    });
+    return transport;
+}
+/**
+ * Composable for managing API request state
+ */
+export function useApiRequest(requestFn, options = {}) {
+    const loading = ref(false);
+    const error = ref(null);
+    const data = ref(null);
+    const execute = async () => {
+        loading.value = true;
+        error.value = null;
+        try {
+            const result = await requestFn();
+            data.value = result;
+            return result;
+        }
+        catch (e) {
+            error.value = parseApiError(e);
+            return null;
+        }
+        finally {
+            loading.value = false;
+        }
+    };
+    const reset = () => {
+        loading.value = false;
+        error.value = null;
+        data.value = null;
+    };
+    if (options.immediate) {
+        execute();
+    }
+    return { loading, error, data, execute, reset };
+}
+/**
+ * Composable for cancellable API requests
+ */
+export function useCancellableRequest(requestFn) {
+    const controller = ref(null);
+    const loading = ref(false);
+    const error = ref(null);
+    const data = ref(null);
+    const execute = async () => {
+        controller.value?.abort();
+        controller.value = new AbortController();
+        loading.value = true;
+        error.value = null;
+        try {
+            const result = await requestFn(controller.value.signal);
+            data.value = result;
+            return result;
+        }
+        catch (e) {
+            if (e.name !== 'AbortError' && e.name !== 'CanceledError') {
+                error.value = parseApiError(e);
+            }
+            return null;
+        }
+        finally {
+            loading.value = false;
+        }
+    };
+    const cancel = () => {
+        controller.value?.abort();
+        loading.value = false;
+    };
+    const reset = () => {
+        cancel();
+        error.value = null;
+        data.value = null;
+    };
+    return { loading, error, data, execute, cancel, reset };
+}
+/**
+ * Wrap API functions to return ApiResponse with data and metadata
+ */
+export function wrapApiForDirectReturn(apiObj) {
+    if (typeof apiObj === 'function') {
+        return async (...args) => {
+            const result = await apiObj(...args);
+            if (result && typeof result === 'object' && 'data' in result && 'status' in result) {
+                return ApiResponse.create(result.data, result);
+            }
+            return result;
+        };
+    }
+    if (typeof apiObj === 'object' && apiObj !== null) {
+        const wrapped = {};
+        for (const key in apiObj) {
+            if (key === 'stream') {
+                wrapped[key] = apiObj[key];
+            }
+            else {
+                wrapped[key] = wrapApiForDirectReturn(apiObj[key]);
+            }
+        }
+        return wrapped;
+    }
+    return apiObj;
+}
+const axios = ax.create({
+    withCredentials: true,
+});
+class DataRequest {
+    data_table;
+    bagel;
+    itemID;
+    _filter = {};
+    constructor(table, bagel) {
+        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(`/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 > 0
+            ? `?filter={${Object.entries(this._filter)
+                .map(([k, v]) => `${k}:${v}`)
+                .join(',')}}`
+            : '';
+        const url = `/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) {
+        this.itemID = id;
+        return this;
+    }
+    async delete() {
+        if (!this.data_table) {
+            throw new Error('Data table not set');
+        }
+        const { data } = await axios.delete(`/data/${this.data_table}/${this.itemID}`);
+        return data;
+    }
+    async put(updatedItem) {
+        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;
+    }
+}
+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 {
+    bagel;
+    constructor(bagel) {
+        this.bagel = bagel;
+    }
+    user = undefined;
+    async validateUser() {
+        try {
+            const { data: usr } = await axios.get('/users/me', {
+                withCredentials: true,
+            });
+            this.user = usr;
+            return usr;
+        }
+        catch {
+            //
+        }
+    }
+    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 || '');
+        console.log('Logging in');
+        try {
+            await axios.post('/auth/cookie/login', formData, {
+                headers: {
+                    'withCredentials': true,
+                    'Content-Type': 'multipart/form-data',
+                },
+            });
+            axios.defaults.withCredentials = true;
+            return this.validateUser();
+        }
+        catch (err) {
+            throw responses(err.response?.data?.detail || 'LOGIN_BAD_CREDENTIALS');
+        }
+    }
+    async logout() {
+        try {
+            await axios.post('/auth/cookie/logout');
+        }
+        catch (err) {
+            this.bagel.onError?.(err);
+            console.log(err);
+        }
+        this.user = undefined;
+    }
+    async acceptInvite(token, user) {
+        await axios.post(`/auth/accept-invite/${token}`, user);
+        await this.login(user);
+    }
+    async register(user, errors) {
+        try {
+            await axios.post('/auth/register', user);
+            return this.login(user);
+        }
+        catch (err) {
+            console.error(err);
+            errors.email = err.response.data.detail;
+            throw err;
+        }
+    }
+}
+export class Bagel {
+    host;
+    fileBaseUrl;
+    fileVersion;
+    onError;
+    constructor({ host, fileBaseUrl, fileVersion, onError }) {
+        this.host = host?.replace(/\/$/, '');
+        this.fileBaseUrl = fileBaseUrl?.replace(/\/$/, '');
+        this.fileVersion = fileVersion || 'files'; // Default to 'files'
+        if (!this.host) {
+            return this;
+        }
+        axios.defaults.baseURL = this.host;
+        this.onError = onError;
+    }
+    read_table = undefined;
+    data(table) {
+        return new DataRequest(table, this);
+    }
+    auth = new BagelAuth(this);
+    _endpointCleaner(endpoint) {
+        const url = `${endpoint.replace(/^\//, '').replaceAll(/\/$/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(`/api/${endpoint}`)
+            .then(({ data }) => data);
+    }
+    async get(endpoint, query) {
+        this._setAuthorization();
+        endpoint = this._endpointCleaner(endpoint);
+        if ((/undefined|null/).test(endpoint)) {
+            throw new Error(`Invalid endpoint: ${endpoint}`);
+        }
+        if (query) {
+            const queryParams = Object.entries(query)
+                .filter(([_, value]) => !!value)
+                .map(([key, value]) => `${key}=${value}`)
+                .join('&');
+            if (queryParams) {
+                endpoint = `${endpoint}?${queryParams}`;
+            }
+        }
+        const url = `/${endpoint}`;
+        return axios
+            .get(url)
+            .then(({ data }) => data)
+            .catch((err) => {
+            this.onError?.(err);
+            throw err;
+        });
+    }
+    async delete(endpoint) {
+        this._setAuthorization();
+        endpoint = this._endpointCleaner(endpoint);
+        return axios
+            .delete(`/${endpoint}`)
+            .then(({ data }) => data)
+            .catch((err) => {
+            this.onError?.(err);
+            throw err;
+        });
+    }
+    async put(endpoint, payload) {
+        endpoint = this._endpointCleaner(endpoint);
+        this._setAuthorization();
+        return axios
+            .put(`/${endpoint}`, payload)
+            .then(({ data }) => data)
+            .catch((err) => {
+            this.onError?.(err);
+            throw err;
+        });
+    }
+    async patch(endpoint, payload = {}) {
+        endpoint = this._endpointCleaner(endpoint);
+        return axios
+            .patch(`/${endpoint}`, payload)
+            .then(({ data }) => data)
+            .catch((err) => {
+            this.onError?.(err);
+            throw err;
+        });
+    }
+    _setAuthorization() {
+        const Authorization = localStorage.getItem('access_token');
+        if (Authorization) {
+            axios.defaults.headers.common.Authorization = `Bearer ${Authorization}`;
+        }
+    }
+    async post(endpoint, payload = {}) {
+        this._setAuthorization();
+        endpoint = this._endpointCleaner(endpoint);
+        return axios
+            .post(`/${endpoint}`, payload)
+            .then(({ data }) => data)
+            .catch((err) => {
+            this.onError?.(err);
+            throw err;
+        });
+    }
+    async uploadFile(file, options) {
+        this._setAuthorization();
+        const formData = new FormData();
+        formData.append('file', file);
+        let url = '/static_files/upload';
+        if (options?.topic) {
+            url = `/static_files/upload?topic=${options.topic}`;
+        }
+        // get an indication of the progress
+        const { data } = await axios.post(url, formData, {
+            headers: {
+                'Content-Type': 'multipart/form-data',
+            },
+            onUploadProgress: options?.onUploadProgress,
+        });
+        return data;
+    }
+}
+export { formatAPIErrorMessage } from './utils';
+/**
+ * Create a cached options getter for select inputs with auto-refresh
+ * @param fetchFn - Function that fetches the data
+ * @param mapFn - Optional mapper to transform items to { label, value }
+ * @returns Async function that returns cached options
+ * @example
+ * const getUsers = createOptionsGetter(
+ *   () => api.users.list(),
+ *   (user) => ({ label: user.name, value: user.id })
+ * )
+ */
+export function createOptionsGetter(fetchFn, mapFn) {
+    let cache = [];
+    let lastFetchedAt = null;
+    const STALE_TIME = 5 * 60 * 1000; // 5 minutes
+    return async () => {
+        const now = Date.now();
+        const isStale = !lastFetchedAt || (now - lastFetchedAt) > STALE_TIME;
+        if (cache.length === 0 || isStale) {
+            const items = await fetchFn();
+            if (mapFn) {
+                cache = items.map(mapFn);
+            }
+            else {
+                // Auto-detect common properties
+                cache = items.map((item) => ({
+                    ...item,
+                    label: item.label ?? item.name ?? item.title ?? item.full_name ?? item.id,
+                    value: item.value ?? item.id,
+                }));
+            }
+            lastFetchedAt = now;
+        }
+        return cache;
+    };
+}