@bagelink/sdk 0.0.1276 → 0.0.1286

package/dist/index.cjs

@@ -1,628 +1,54 @@
 'use strict';
 
-const axios$1 = require('axios');
-
-function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
-
-const axios__default = /*#__PURE__*/_interopDefaultCompat(axios$1);
-
-function toCamelCase(str) {
-  return str?.replaceAll(/[-._\s]+(.)?/g, (_, c) => c?.toUpperCase() || "").replace(/^./, (str2) => str2.toLowerCase()) || str || "";
-}
-function toPascalCase(str) {
-  return str?.replaceAll(/[-_\s]+(.)?/g, (_, c) => c?.toUpperCase() || "").replace(/^./, (str2) => str2.toUpperCase()) || str || "";
-}
-function formatType(typeName) {
-  typeName = typeName.replaceAll("-", "").replaceAll(/post|put$/gi, "").replaceAll(/^body_/gi, "");
-  return toPascalCase(typeName);
-}
-function resolveReference(ref) {
-  const t = ref.split("/").pop();
-  if (!t) return "any";
-  return formatType(t);
-}
-function schemaToType(schema) {
-  if (!schema) return "any";
-  if (schema.anyOf) {
-    let _t = schema.anyOf.map((s) => schemaToType(s)).filter((p) => p !== "any").join(" | ");
-    if (_t === "" || _t === "null") _t = "any";
-    return _t;
-  }
-  if (schema.allOf) {
-    return schema.allOf.map((s) => schemaToType(s)).filter((p) => p !== "any").join(" & ");
-  }
-  if (schema.$ref) return resolveReference(schema.$ref);
-  switch (schema.type) {
-    case "object":
-      return "{ [key: string]: any }";
-    case "string":
-      return "string";
-    case "integer":
-      return "number";
-    case "number":
-      return "number";
-    case "boolean":
-      return "boolean";
-    case "array":
-      return `${schemaToType(schema.items)}[]`;
-    case "undefined":
-      return "undefined";
-    case "null":
-      return "null";
-    case undefined:
-      return "any";
-    default:
-      console.log("Unknown type", schema.type);
-      return "any";
-  }
-}
-function isOptional(schema) {
-  const type = schemaToType(schema);
-  const splitType = type.split(/\s+\|\s+/);
-  const includesNull = splitType.includes("null");
-  const includesUndefined = splitType.includes("undefined");
-  return includesNull || includesUndefined || schema.default !== undefined;
-}
-function cleanOptionals(str) {
-  return str.split(" | ").filter((t) => t !== "null" && t !== "undefined").join(" | ");
-}
-function formatVarType({
-  varName,
-  schema,
-  required = false,
-  defaultValue
-}) {
-  let type = schemaToType(schema);
-  type = cleanOptionals(type);
-  let defaultStr = "";
-  if (defaultValue) {
-    if (typeof defaultValue === "string") {
-      defaultStr = ` = '${defaultValue}'`;
-    } else if (typeof defaultValue === "object") {
-      defaultStr = ` = ${JSON.stringify(defaultValue)}`;
-    } else {
-      defaultStr = ` = ${defaultValue}`;
-    }
-  }
-  let optionalStr = !required && isOptional(schema) ? "?" : "";
-  if (defaultStr) optionalStr = "";
-  return `${varName}${optionalStr}: ${type}${defaultStr}`;
-}
-function cleanPath(path) {
-  return path.split("/").filter((p) => p && !/\{|\}/.test(p)).join("/");
-}
-
-const allTypes = [];
-const primitiveTypes = [
-  "string",
-  "number",
-  "boolean",
-  "null",
-  "void",
-  "any",
-  "Record<string, any>",
-  "undefined",
-  "{ [key: string]: any }"
-];
-function collectTypeForImportStatement(typeName) {
-  typeName = typeName.trim().replace("[]", "");
-  if (typeName.includes("|")) {
-    typeName.split("|").forEach((singleType) => {
-      collectTypeForImportStatement(singleType);
-    });
-    return;
-  }
-  const isPrimitive = primitiveTypes.includes(typeName);
-  typeName = formatType(typeName);
-  if (!typeName || isPrimitive) return;
-  if (!allTypes.includes(typeName)) allTypes.push(typeName);
-}
-function schemaToTypeWithCollection(schema) {
-  const type = schemaToType(schema);
-  collectTypeForImportStatement(type);
-  return type;
-}
-function getResponseType(response) {
-  const mediaTypeObject = response.content?.["application/json"];
-  if (!mediaTypeObject || !mediaTypeObject.schema) return;
-  const responseType = schemaToTypeWithCollection(mediaTypeObject.schema);
-  return responseType;
-}
-function generateResponseType(responses) {
-  if (!responses) return "";
-  const types = [];
-  for (const [statusCode, response] of Object.entries(responses)) {
-    if (statusCode.startsWith("2")) {
-      const responseType = getResponseType(response);
-      if (responseType && responseType !== "any") {
-        types.push(responseType);
-      }
-    }
-  }
-  return types.join(" | ");
-}
-function generateAxiosFunction(method, formattedPath, allParams, responseTypeStr, parameters, requestBodyPayload) {
-  if (allParams === "undefined") allParams = "";
-  let axiosFunction = `async (${allParams})${responseTypeStr} => {`;
-  if (requestBodyPayload === "formData") {
-    const paramStr = parameters?.config?.params ? `params: {${parameters.config.params}}` : "";
-    axiosFunction += `
-		const formData = new FormData()
-		formData.append('upload', file)
-		return axios.${method}(${formattedPath}, formData, {
-			headers: { 'Content-Type': 'multipart/form-data' },
-			onUploadProgress: options?.onUploadProgress${paramStr ? `,
-            ${paramStr}` : ""}
-		})`;
-  } else {
-    const paramStr = parameters?.config?.params ? `, { params: {${parameters.config.params}} }` : "";
-    const bodyVar = requestBodyPayload ? `${requestBodyPayload}` : "{}";
-    axiosFunction += `return axios.${method}(${formattedPath}${["get", "delete"].includes(method) ? paramStr : `, ${bodyVar}${paramStr}`})`;
-  }
-  axiosFunction += "}";
-  return axiosFunction;
-}
-const pathParamRegex = /\{([^}]+)\}/g;
-function getParamsFromPath(path) {
-  const params = path.match(pathParamRegex)?.map((p) => p.slice(1, -1));
-  return params;
-}
-function formatPathWithParams(path) {
-  const params = getParamsFromPath(path);
-  const formattedPath = params ? `\`${path.replace(pathParamRegex, (v) => `$${toCamelCase(v)}`)}\`` : `'${path}'`;
-  return formattedPath;
-}
-function generateRequestBody(requestBody) {
-  if (!requestBody?.content)
-    return { requestBodyParam: "", requestBodyPayload: "" };
-  const { content } = requestBody;
-  const multipartFormData = content["multipart/form-data"] || {};
-  if (multipartFormData.schema?.$ref?.includes("Body_upload_files")) {
-    return {
-      requestBodyParam: "file: File, options?: UploadOptions & { dirPath?: string, tags?: string[] }",
-      requestBodyPayload: "formData"
-    };
-  }
-  const jsonContent = requestBody.content["application/json"];
-  if (!jsonContent || !jsonContent.schema) {
-    return { requestBodyParam: "", requestBodyPayload: "" };
-  }
-  const bodySchema = jsonContent.schema;
-  const requestBodyType = schemaToType(bodySchema);
-  collectTypeForImportStatement(requestBodyType);
-  const requestBodyPayload = toCamelCase(bodySchema.title) || toCamelCase(requestBodyType) || "requestBody";
-  const requestBodyParam = formatVarType({
-    varName: requestBodyPayload,
-    schema: bodySchema,
-    defaultValue: bodySchema.default
-  });
-  return { requestBodyParam, requestBodyPayload };
-}
-function combineAllParams(parameters, requestBodyParam) {
-  let allParamsArray = [];
-  if (parameters && parameters.params)
-    allParamsArray = parameters.params.split(",").map((p) => p.trim());
-  if (requestBodyParam) allParamsArray.push(requestBodyParam.trim());
-  allParamsArray = allParamsArray.filter((p) => p).sort((a, b) => (a.includes("?") ? 1 : -1) - (b.includes("?") ? 1 : -1));
-  return allParamsArray.join(", ");
-}
-function generateFunctionParameters(params, isFileUpload = false) {
-  if (!params?.length) return {};
-  if (isFileUpload) {
-    return {
-      config: {
-        params: "dir_path: options?.dirPath, tags: options?.tags"
-      },
-      params: ""
-      // Empty string to ensure file is the first parameter
-    };
-  }
-  const functionParams = [];
-  const paramList = [];
-  for (const param of params) {
-    const paramType = schemaToType(param.schema);
-    collectTypeForImportStatement(paramType);
-    const paramName = param.name;
-    const varName = toCamelCase(param.name);
-    if (param.in === "path" || param.in === "query" || param.in === "header") {
-      functionParams.push(
-        formatVarType({
-          varName,
-          schema: param.schema,
-          required: param.required,
-          defaultValue: param.schema.default
-        })
-      );
-    }
-    if (param.in === "query" || param.in === "header") {
-      paramList.push(
-        paramName === varName ? paramName : `'${paramName}': ${varName}`
-      );
-    }
-  }
-  return {
-    params: functionParams.join(", "),
-    config: paramList.length ? { params: paramList.join(", ") } : {}
-  };
-}
-function generateFunctionForOperation(method, path, operation) {
-  if (!operation) return "";
-  const isFileUpload = operation.requestBody?.content["multipart/form-data"]?.schema?.$ref?.includes("Body_upload_files");
-  const parameters = generateFunctionParameters(
-    operation.parameters,
-    isFileUpload
-  );
-  const { requestBodyParam, requestBodyPayload } = generateRequestBody(
-    operation.requestBody
-  );
-  const allParams = isFileUpload ? "file: File, options?: UploadOptions & { dirPath?: string, tags?: string[] }" : combineAllParams(parameters, requestBodyParam);
-  const responseType = generateResponseType(operation.responses);
-  const responseTypeStr = responseType ? `: Promise<AxiosResponse<${responseType}>>` : "";
-  return generateAxiosFunction(
-    method,
-    formatPathWithParams(path),
-    allParams,
-    responseTypeStr,
-    parameters,
-    requestBodyPayload
-  );
-}
-const generateRandomString = () => Math.random().toString(36).slice(7);
-const DOUBLE_QUOTE_REGEX = /"([^"]+)":/g;
-function fileTemplate(tsString, typeForImport, baseURL) {
-  const templateCode = `import ax from 'axios';
-		 import type { AxiosResponse } from 'axios';
-		 import type {${typeForImport.join(", ")}} from './types.d';
-
-	interface UploadOptions {
-		onUploadProgress?: (progressEvent: any) => void
-		dirPath?: string
-		tags?: string[]
-	}
-
-	export const axios = ax.create({baseURL:${baseURL}});
-	${tsString}`;
-  return templateCode.replace(DOUBLE_QUOTE_REGEX, "$1:");
-}
-const functionsInventory = {};
-const pathOperations = [];
-function hasConflict(path, method) {
-  const cleanPathName = path.split("/").filter((p) => p && !/\{|\}/.test(p)).join("/");
-  const matchingPaths = pathOperations.filter(
-    (p) => p.path === cleanPathName && p.method === method
-  );
-  pathOperations.push({ path: cleanPathName, method });
-  return matchingPaths.length > 0;
-}
-function createFunctionPlaceholder(path, method, operation) {
-  const funcID = generateRandomString();
-  functionsInventory[funcID] = generateFunctionForOperation(
-    method,
-    path,
-    operation
-  );
-  return funcID;
-}
-function handlePathSegment(path, operation, existingObj = {}) {
-  const methods = Object.keys(operation);
-  const obj = {};
-  for (const method of methods) {
-    let functionName = method.toLowerCase();
-    if (hasConflict(path, method)) {
-      const params = getParamsFromPath(path);
-      functionName += params ? `By${toPascalCase(params.pop() || "")}` : "All";
-    }
-    obj[functionName] = createFunctionPlaceholder(
-      path,
-      method,
-      operation[method]
-    );
-  }
-  return { ...obj, ...existingObj };
-}
-function generateFunctions(paths, baseUrl) {
-  let tsString = "";
-  const body = {};
-  const allPathsClean = Object.keys(paths).map(cleanPath);
-  for (const [path, operation] of Object.entries(paths)) {
-    const splitPath = path.split("/").filter((p) => p && !/\{|\}/.test(p));
-    splitPath.reduce((acc, key, index, array) => {
-      const objFuncKey = toCamelCase(key);
-      if (!objFuncKey) return acc;
-      const methods = Object.keys(operation);
-      if (index === array.length - 1 && methods.length === 1 && allPathsClean.filter((p) => p === cleanPath(path)).length === 1) {
-        const method = methods[0];
-        const opp = { ...operation }[method];
-        acc[objFuncKey] = createFunctionPlaceholder(path, methods[0], opp);
-      } else if (index === array.length - 1) {
-        acc[objFuncKey] = handlePathSegment(path, operation, acc[objFuncKey]);
-      } else if (!acc[objFuncKey] || typeof acc[objFuncKey] !== "object") {
-        acc[objFuncKey] = {};
-      }
-      return acc[objFuncKey];
-    }, body);
-  }
-  for (const [parent, object] of Object.entries(body)) {
-    tsString += `export const ${parent} = ${JSON.stringify(object, undefined, 2)};
-`;
-  }
-  Object.entries(functionsInventory).forEach(([key, value]) => {
-    tsString = tsString.replace(`"${key}"`, value);
-  });
-  tsString = fileTemplate(tsString, allTypes, baseUrl);
-  return tsString;
-}
-
-function generateTypes(schemas) {
-  return Object.entries(schemas).map(([typeName, schema]) => {
-    typeName = formatType(typeName);
-    if (schema.enum) {
-      return `export type ${typeName} = ${schema.enum.map((item) => `'${item}'`).join(" | ")};
-`;
-    }
-    if (schema.type === "array" && schema.items) {
-      return `export type ${typeName} = ${schemaToType(schema.items)}[];
-`;
-    }
-    if (!schema.properties) {
-      return "";
-    }
-    const properties = Object.entries(schema.properties).map(([key, value]) => {
-      const varType = formatVarType({ varName: key, schema: value });
-      return `		${varType}`;
-    }).join(";\n ");
-    return `export type ${typeName} = {
- ${properties};
- };
-`;
-  }).join("\n");
-}
-
-const basicAuthHeader = { Authorization: "Basic YmFnZWxfdXNlcm5hbWU6Tm90U2VjdXJlQGJhZ2Vs" };
-const index = async (openApiUrl, baseUrl) => {
-  try {
-    const { data: openApi } = await axios__default.get(openApiUrl, { headers: basicAuthHeader });
-    const schemas = openApi.components?.schemas;
-    if (!schemas) throw new Error("No schemas found in OpenAPI document");
-    const types = generateTypes(schemas);
-    const { paths } = openApi;
-    if (!paths) throw new Error("No paths found in OpenAPI document");
-    const code = generateFunctions(paths, baseUrl);
-    return { types, code };
-  } catch (error) {
-    throw new Error(error);
-  }
-};
-
-const axios = axios__default.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 {
-  constructor(bagel) {
-    this.bagel = 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;
-    }
-  }
-}
-class Bagel {
-  host;
-  fileBaseUrl;
-  onError;
-  constructor({ host, fileBaseUrl, onError }) {
-    this.host = host?.replace(/\/$/, "");
-    this.fileBaseUrl = fileBaseUrl?.replace(/\/$/, "");
-    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}`;
-    const { data } = await axios.post(url, formData, {
-      headers: {
-        "Content-Type": "multipart/form-data"
-      },
-      onUploadProgress: options?.onUploadProgress
-    });
-    return data;
-  }
-}
-
-exports.Bagel = Bagel;
-exports.openAPI = index;
+require('axios');
+const index = require('./shared/sdk.UmZR6apR.cjs');
+require('node:fs');
+require('node:path');
+require('node:process');
+require('node:fs/promises');
+require('util');
+require('path');
+require('tty');
+require('os');
+require('fs');
+require('module');
+require('assert');
+require('url');
+require('node:url');
+require('crypto');
+require('events');
+require('node:util');
+require('node:assert');
+require('process');
+require('fs/promises');
+require('v8');
+require('node:perf_hooks');
+require('node:module');
+require('node:crypto');
+require('child_process');
+require('node:child_process');
+require('node:http');
+require('node:https');
+require('net');
+require('http');
+require('stream');
+require('node:os');
+require('node:net');
+require('node:dns');
+require('node:readline');
+require('node:buffer');
+require('node:events');
+require('node:v8');
+require('node:worker_threads');
+require('zlib');
+require('buffer');
+require('https');
+require('tls');
+require('node:querystring');
+require('node:zlib');
+
+
+
+exports.Bagel = index.Bagel;
+exports.formatAPIErrorMessage = index.formatAPIErrorMessage;
+exports.openAPI = index.index;

package/dist/index.d.cts

@@ -4,6 +4,8 @@ interface OpenAPIResponse {
 }
 declare const _default: (openApiUrl: string, baseUrl: string) => Promise<OpenAPIResponse>;
 
+declare function formatAPIErrorMessage(error: any): any;
+
 type Tables = '';
 type TableToTypeMapping = Record<Tables, any>;
 
@@ -106,4 +108,4 @@ declare class Bagel {
     uploadFile<T = any>(file: File, options?: UploadOptions): Promise<T>;
 }
 
-export { Bagel, type TableToTypeMapping, type Tables, type User, _default as openAPI };
+export { Bagel, type TableToTypeMapping, type Tables, type User, formatAPIErrorMessage, _default as openAPI };