@bagelink/sdk 0.0.807 → 0.0.809

package/bin/index.ts

@@ -19,7 +19,7 @@ export async function loadTypes() {
 	await formatAndWriteCode(typesPath, types)
 
 	const apiPath = join(bagelinkDir, 'api.ts')
-	await formatAndWriteCode(apiPath, code)
+	await formatAndWriteCode(apiPath, `// eslint-disable no-null \n${code}`)
 
 	await handleAuthCode(withAuth, bagelinkDir)
 
@@ -29,6 +29,6 @@ export async function loadTypes() {
 }
 
 loadTypes().catch((error: unknown) => {
-	proc.exitCode = 1
 	console.error(error)
+	proc.exit(1)
 })

package/bin/utils.ts

@@ -1,15 +1,11 @@
 import fs from 'node:fs'
 
-import { createRequire } from 'node:module'
 import { join } from 'node:path'
+import * as proc from 'node:process'
 import { ESLint } from 'eslint'
 import * as prettier from 'prettier'
 import { loadEnv } from 'vite'
 
-const _require = createRequire(import.meta.url)
-
-const proc = _require('process') as typeof import('process')
-
 const cwd = proc.cwd()
 const env = loadEnv('', cwd)
 
@@ -70,7 +66,7 @@ export async function handleAuthCode(_withAuth: boolean, _bagelinkDir: string) {
 	if (_withAuth) {
 		const authCode = fs.readFileSync(
 			join(__dirname, 'authClientCode.ts'),
-			'utf-8'
+			'utf8'
 		).replace(
 			'// @ts-expect-error - required for axios to work',
 			''

package/dist/index.cjs

@@ -6,10 +6,10 @@ function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'defau
 
 const axios__default = /*#__PURE__*/_interopDefaultCompat(axios$1);
 
-const toCamelCase = (str) => str?.replace(/[-._\s]+(.)?/g, (_, c) => c?.toUpperCase() || "").replace(/^./, (str2) => str2.toLowerCase()) || str;
-const toPascalCase = (str) => str?.replace(/[-_\s]+(.)?/g, (_, c) => c?.toUpperCase() || "").replace(/^./, (str2) => str2.toUpperCase()) || str;
+const toCamelCase = (str) => str?.replaceAll(/[-._\s]+(.)?/g, (_, c) => c?.toUpperCase() || "").replace(/^./, (str2) => str2.toLowerCase()) || str;
+const toPascalCase = (str) => str?.replaceAll(/[-_\s]+(.)?/g, (_, c) => c?.toUpperCase() || "").replace(/^./, (str2) => str2.toUpperCase()) || str;
 function formatType(typeName) {
-  typeName = typeName.replace(/-/g, "").replace(/(post|put)$/gi, "").replace(/^body_/gi, "");
+  typeName = typeName.replaceAll("-", "").replaceAll(/(post|put)$/gi, "").replaceAll(/^body_/gi, "");
   return toPascalCase(typeName);
 }
 function resolveReference(ref) {
@@ -29,7 +29,7 @@ function schemaToType(schema) {
     return resolveReference(schema.$ref);
   switch (schema.type) {
     case "object":
-      return "Record<string, any>";
+      return "{ [key: string]: any }";
     case "string":
       return "string";
     case "integer":
@@ -40,6 +40,8 @@ function schemaToType(schema) {
       return "boolean";
     case "array":
       return `${schemaToType(schema.items)}[]`;
+    case "undefined":
+      return "undefined";
     case "null":
       return "null";
     default:
@@ -48,12 +50,15 @@ function schemaToType(schema) {
 }
 function isOptional(schema) {
   const type = schemaToType(schema);
-  return type.split(/\s+\|\s+/).includes("null") || schema.default !== void 0;
+  const splitType = type.split(/\s+\|\s+/);
+  const includesNull = splitType.includes("null");
+  const includesUndefined = splitType.includes("undefined");
+  return includesNull || includesUndefined || schema.default !== void 0;
 }
-const cleanNulls = (str) => str.split(" | ").filter((t) => t !== "null").join(" | ");
-function formatVarType(varName, schema, required = false, defaultValue = null) {
+const cleanOptionals = (str) => str.split(" | ").filter((t) => t !== "null" && t !== "undefined").join(" | ");
+function formatVarType(varName, schema, required = false, defaultValue) {
   let type = schemaToType(schema);
-  type = cleanNulls(type);
+  type = cleanOptionals(type);
   let defaultStr = defaultValue ? ` = ${defaultValue}` : "";
   if (defaultStr && type === "string")
     defaultStr = ` = '${defaultValue}'`;
@@ -65,10 +70,11 @@ function formatVarType(varName, schema, required = false, defaultValue = null) {
   return `${varName}${optionalStr}: ${type}${defaultStr}`;
 }
 function cleanPath(path) {
-  return path.split("/").filter((p) => p && !p.match(/\{|\}/)).join("/");
+  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("|")) {
@@ -79,7 +85,6 @@ function collectTypeForImportStatement(typeName) {
     );
     return;
   }
-  const primitiveTypes = ["string", "number", "boolean", "null", "void", "any", "Record<string, any>"];
   const isPrimitive = primitiveTypes.includes(typeName);
   typeName = formatType(typeName);
   if (!typeName || isPrimitive)
@@ -90,7 +95,7 @@ function collectTypeForImportStatement(typeName) {
 function getResponseType(response) {
   const mediaTypeObject = response.content?.["application/json"];
   if (!mediaTypeObject || !mediaTypeObject.schema)
-    return null;
+    return;
   const responseType = schemaToType(mediaTypeObject.schema);
   collectTypeForImportStatement(responseType);
   return responseType;
@@ -190,7 +195,7 @@ function generateFunctionForOperation(method, path, operation) {
   const responseTypeStr = responseType ? `: Promise<AxiosResponse<${responseType}>>` : "";
   return generateAxiosFunction(method, formattedPath, allParams, responseTypeStr, parameters, requestBodyPayload);
 }
-const generateRandomString = () => Math.random().toString(36).substring(7);
+const generateRandomString = () => Math.random().toString(36).slice(7);
 function fileTemplate(tsString, typeForImport, baseURL) {
   const templateCode = `import ax from 'axios';
 		 import type { AxiosResponse } from 'axios';
@@ -204,7 +209,7 @@ function fileTemplate(tsString, typeForImport, baseURL) {
 const functionsInventory = {};
 const pathOperations = [];
 function hasConflict(path, method) {
-  const cleanPathName = path.split("/").filter((p) => p && !p.match(/\{|\}/)).join("/");
+  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;
@@ -214,7 +219,7 @@ function createFunctionPlaceholder(path, method, operation) {
   functionsInventory[funcID] = generateFunctionForOperation(method, path, operation);
   return funcID;
 }
-function handlePathSegment(path, operation, existingObj = null) {
+function handlePathSegment(path, operation, existingObj = {}) {
   const methods = Object.keys(operation);
   const obj = {};
   for (const method of methods) {
@@ -232,7 +237,7 @@ function generateFunctions(paths, baseUrl) {
   const body = {};
   const allPathsClean = Object.keys(paths).map(cleanPath);
   for (const [path, operation] of Object.entries(paths)) {
-    const splitPath = path.split("/").filter((p) => p && !p.match(/\{|\}/));
+    const splitPath = path.split("/").filter((p) => p && !/\{|\}/.test(p));
     splitPath.reduce((acc, key, index, array) => {
       const objFuncKey = toCamelCase(key);
       if (!objFuncKey)
@@ -251,7 +256,7 @@ function generateFunctions(paths, baseUrl) {
     }, body);
   }
   for (const [parent, object] of Object.entries(body)) {
-    tsString += `export const ${parent} = ${JSON.stringify(object, null, 2)};
+    tsString += `export const ${parent} = ${JSON.stringify(object, void 0, 2)};
 `;
   }
   Object.entries(functionsInventory).forEach(([key, value]) => {
@@ -330,7 +335,7 @@ class DataRequest {
   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 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);
@@ -376,7 +381,7 @@ function responses(key) {
 class BagelAuth {
   constructor(bagel) {
     this.bagel = bagel;
-    __publicField(this, "user", null);
+    __publicField(this, "user");
     this.bagel = bagel;
   }
   async validateUser() {
@@ -386,8 +391,7 @@ class BagelAuth {
       });
       this.user = usr;
       return usr;
-    } catch (err) {
-      return null;
+    } catch {
     }
   }
   async resetPassword(ctx) {
@@ -427,7 +431,7 @@ class BagelAuth {
       this.bagel.onError?.(err);
       console.log(err);
     }
-    this.user = null;
+    this.user = void 0;
   }
   async acceptInvite(token, user) {
     await axios.post(`/auth/accept-invite/${token}`, user);
@@ -448,7 +452,7 @@ class Bagel {
   constructor({ host, onError }) {
     __publicField(this, "host");
     __publicField(this, "onError");
-    __publicField(this, "read_table", null);
+    __publicField(this, "read_table");
     __publicField(this, "auth", new BagelAuth(this));
     this.host = host?.replace(/\/$/, "");
     if (!this.host) {
@@ -463,7 +467,7 @@ class Bagel {
     return new DataRequest(table, this);
   }
   _endpointCleaner(endpoint) {
-    const url = `${endpoint.replace(/^\//, "").replace(/\/$/g, "")}`;
+    const url = `${endpoint.replace(/^\//, "").replaceAll(/\/$/g, "")}`;
     return url;
   }
   async api(endpoint, query) {
@@ -476,7 +480,7 @@ class Bagel {
   async get(endpoint, query) {
     this._setAuthorization();
     endpoint = this._endpointCleaner(endpoint);
-    if (endpoint.match(/undefined|null/))
+    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("&");

package/dist/index.d.cts

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

package/dist/index.d.mts

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

package/dist/index.d.ts

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

package/dist/index.mjs

@@ -1,9 +1,9 @@
 import axios$1 from 'axios';
 
-const toCamelCase = (str) => str?.replace(/[-._\s]+(.)?/g, (_, c) => c?.toUpperCase() || "").replace(/^./, (str2) => str2.toLowerCase()) || str;
-const toPascalCase = (str) => str?.replace(/[-_\s]+(.)?/g, (_, c) => c?.toUpperCase() || "").replace(/^./, (str2) => str2.toUpperCase()) || str;
+const toCamelCase = (str) => str?.replaceAll(/[-._\s]+(.)?/g, (_, c) => c?.toUpperCase() || "").replace(/^./, (str2) => str2.toLowerCase()) || str;
+const toPascalCase = (str) => str?.replaceAll(/[-_\s]+(.)?/g, (_, c) => c?.toUpperCase() || "").replace(/^./, (str2) => str2.toUpperCase()) || str;
 function formatType(typeName) {
-  typeName = typeName.replace(/-/g, "").replace(/(post|put)$/gi, "").replace(/^body_/gi, "");
+  typeName = typeName.replaceAll("-", "").replaceAll(/(post|put)$/gi, "").replaceAll(/^body_/gi, "");
   return toPascalCase(typeName);
 }
 function resolveReference(ref) {
@@ -23,7 +23,7 @@ function schemaToType(schema) {
     return resolveReference(schema.$ref);
   switch (schema.type) {
     case "object":
-      return "Record<string, any>";
+      return "{ [key: string]: any }";
     case "string":
       return "string";
     case "integer":
@@ -34,6 +34,8 @@ function schemaToType(schema) {
       return "boolean";
     case "array":
       return `${schemaToType(schema.items)}[]`;
+    case "undefined":
+      return "undefined";
     case "null":
       return "null";
     default:
@@ -42,12 +44,15 @@ function schemaToType(schema) {
 }
 function isOptional(schema) {
   const type = schemaToType(schema);
-  return type.split(/\s+\|\s+/).includes("null") || schema.default !== void 0;
+  const splitType = type.split(/\s+\|\s+/);
+  const includesNull = splitType.includes("null");
+  const includesUndefined = splitType.includes("undefined");
+  return includesNull || includesUndefined || schema.default !== void 0;
 }
-const cleanNulls = (str) => str.split(" | ").filter((t) => t !== "null").join(" | ");
-function formatVarType(varName, schema, required = false, defaultValue = null) {
+const cleanOptionals = (str) => str.split(" | ").filter((t) => t !== "null" && t !== "undefined").join(" | ");
+function formatVarType(varName, schema, required = false, defaultValue) {
   let type = schemaToType(schema);
-  type = cleanNulls(type);
+  type = cleanOptionals(type);
   let defaultStr = defaultValue ? ` = ${defaultValue}` : "";
   if (defaultStr && type === "string")
     defaultStr = ` = '${defaultValue}'`;
@@ -59,10 +64,11 @@ function formatVarType(varName, schema, required = false, defaultValue = null) {
   return `${varName}${optionalStr}: ${type}${defaultStr}`;
 }
 function cleanPath(path) {
-  return path.split("/").filter((p) => p && !p.match(/\{|\}/)).join("/");
+  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("|")) {
@@ -73,7 +79,6 @@ function collectTypeForImportStatement(typeName) {
     );
     return;
   }
-  const primitiveTypes = ["string", "number", "boolean", "null", "void", "any", "Record<string, any>"];
   const isPrimitive = primitiveTypes.includes(typeName);
   typeName = formatType(typeName);
   if (!typeName || isPrimitive)
@@ -84,7 +89,7 @@ function collectTypeForImportStatement(typeName) {
 function getResponseType(response) {
   const mediaTypeObject = response.content?.["application/json"];
   if (!mediaTypeObject || !mediaTypeObject.schema)
-    return null;
+    return;
   const responseType = schemaToType(mediaTypeObject.schema);
   collectTypeForImportStatement(responseType);
   return responseType;
@@ -184,7 +189,7 @@ function generateFunctionForOperation(method, path, operation) {
   const responseTypeStr = responseType ? `: Promise<AxiosResponse<${responseType}>>` : "";
   return generateAxiosFunction(method, formattedPath, allParams, responseTypeStr, parameters, requestBodyPayload);
 }
-const generateRandomString = () => Math.random().toString(36).substring(7);
+const generateRandomString = () => Math.random().toString(36).slice(7);
 function fileTemplate(tsString, typeForImport, baseURL) {
   const templateCode = `import ax from 'axios';
 		 import type { AxiosResponse } from 'axios';
@@ -198,7 +203,7 @@ function fileTemplate(tsString, typeForImport, baseURL) {
 const functionsInventory = {};
 const pathOperations = [];
 function hasConflict(path, method) {
-  const cleanPathName = path.split("/").filter((p) => p && !p.match(/\{|\}/)).join("/");
+  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;
@@ -208,7 +213,7 @@ function createFunctionPlaceholder(path, method, operation) {
   functionsInventory[funcID] = generateFunctionForOperation(method, path, operation);
   return funcID;
 }
-function handlePathSegment(path, operation, existingObj = null) {
+function handlePathSegment(path, operation, existingObj = {}) {
   const methods = Object.keys(operation);
   const obj = {};
   for (const method of methods) {
@@ -226,7 +231,7 @@ function generateFunctions(paths, baseUrl) {
   const body = {};
   const allPathsClean = Object.keys(paths).map(cleanPath);
   for (const [path, operation] of Object.entries(paths)) {
-    const splitPath = path.split("/").filter((p) => p && !p.match(/\{|\}/));
+    const splitPath = path.split("/").filter((p) => p && !/\{|\}/.test(p));
     splitPath.reduce((acc, key, index, array) => {
       const objFuncKey = toCamelCase(key);
       if (!objFuncKey)
@@ -245,7 +250,7 @@ function generateFunctions(paths, baseUrl) {
     }, body);
   }
   for (const [parent, object] of Object.entries(body)) {
-    tsString += `export const ${parent} = ${JSON.stringify(object, null, 2)};
+    tsString += `export const ${parent} = ${JSON.stringify(object, void 0, 2)};
 `;
   }
   Object.entries(functionsInventory).forEach(([key, value]) => {
@@ -324,7 +329,7 @@ class DataRequest {
   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 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);
@@ -370,7 +375,7 @@ function responses(key) {
 class BagelAuth {
   constructor(bagel) {
     this.bagel = bagel;
-    __publicField(this, "user", null);
+    __publicField(this, "user");
     this.bagel = bagel;
   }
   async validateUser() {
@@ -380,8 +385,7 @@ class BagelAuth {
       });
       this.user = usr;
       return usr;
-    } catch (err) {
-      return null;
+    } catch {
     }
   }
   async resetPassword(ctx) {
@@ -421,7 +425,7 @@ class BagelAuth {
       this.bagel.onError?.(err);
       console.log(err);
     }
-    this.user = null;
+    this.user = void 0;
   }
   async acceptInvite(token, user) {
     await axios.post(`/auth/accept-invite/${token}`, user);
@@ -442,7 +446,7 @@ class Bagel {
   constructor({ host, onError }) {
     __publicField(this, "host");
     __publicField(this, "onError");
-    __publicField(this, "read_table", null);
+    __publicField(this, "read_table");
     __publicField(this, "auth", new BagelAuth(this));
     this.host = host?.replace(/\/$/, "");
     if (!this.host) {
@@ -457,7 +461,7 @@ class Bagel {
     return new DataRequest(table, this);
   }
   _endpointCleaner(endpoint) {
-    const url = `${endpoint.replace(/^\//, "").replace(/\/$/g, "")}`;
+    const url = `${endpoint.replace(/^\//, "").replaceAll(/\/$/g, "")}`;
     return url;
   }
   async api(endpoint, query) {
@@ -470,7 +474,7 @@ class Bagel {
   async get(endpoint, query) {
     this._setAuthorization();
     endpoint = this._endpointCleaner(endpoint);
-    if (endpoint.match(/undefined|null/))
+    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("&");

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@bagelink/sdk",
   "type": "module",
-  "version": "0.0.807",
+  "version": "0.0.809",
   "description": "Bagel core sdk packages",
   "author": {
     "name": "Neveh Allon",

package/src/index.ts

@@ -33,7 +33,7 @@ class DataRequest<T extends Tables = Tables> {
 
 	itemID: string
 
-	_filter: Record<string, any> = {}
+	_filter: { [key: string]: any } = {}
 
 	constructor(table: T, bagel: Bagel) {
 		this.data_table = table
@@ -41,13 +41,13 @@ class DataRequest<T extends Tables = Tables> {
 		this.itemID = ''
 	}
 
-	async post(item: Record<string, any>): Promise<Record<string, any>> {
+	async post(item: { [key: string]: any }): Promise<{ [key: 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
 	}
 
-	filter(filter: Record<string, any>) {
+	filter(filter: { [key: string]: any }) {
 		this._filter = filter
 		return this
 	}
@@ -56,7 +56,7 @@ class DataRequest<T extends Tables = Tables> {
 		TableToTypeMapping[T] | TableToTypeMapping[T][] | undefined
 	> {
 		if (!this.data_table) throw new Error('Data table not set')
-		const filterStr = Object.keys(this._filter).length
+		const filterStr = Object.keys(this._filter).length > 0
 			? `?filter={${Object.entries(this._filter)
 				.map(([k, v]) => `${k}:${v}`)
 				.join(',')}}`
@@ -87,7 +87,7 @@ class DataRequest<T extends Tables = Tables> {
 		return data
 	}
 
-	async put(updatedItem: Record<string, any>): Promise<Record<string, any>> {
+	async put(updatedItem: { [key: string]: any }): Promise<{ [key: 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')
@@ -100,7 +100,7 @@ class DataRequest<T extends Tables = Tables> {
 }
 
 function responses(key: string) {
-	const res: Record<string, string> = {
+	const res: { [key: string]: string } = {
 		LOGIN_BAD_CREDENTIALS: 'Invalid username or password',
 		RESET_PASSWORD_BAD_TOKEN: 'This reset password link is invalid or expired.',
 	}
@@ -112,17 +112,17 @@ class BagelAuth {
 		this.bagel = bagel
 	}
 
-	user: User | null = null
+	user: User | undefined = undefined
 
-	async validateUser(): Promise<User | null> {
+	async validateUser(): Promise<User | undefined> {
 		try {
 			const { data: usr } = await axios.get('/users/me', {
 				withCredentials: true,
 			})
 			this.user = usr
 			return usr
-		} catch (err) {
-			return null
+		} catch {
+			//
 		}
 	}
 
@@ -140,7 +140,7 @@ class BagelAuth {
 		}
 	}
 
-	async login(user: User): Promise<User | null> {
+	async login(user: User): Promise<User | undefined> {
 		const formData = new FormData()
 		formData.append('username', user.email || '')
 		formData.append('password', user.password || '')
@@ -166,15 +166,15 @@ class BagelAuth {
 			this.bagel.onError?.(err)
 			console.log(err)
 		}
-		this.user = null
+		this.user = undefined
 	}
 
-	async acceptInvite(token: string, user: Record<string, any>) {
+	async acceptInvite(token: string, user: { [key: string]: any }) {
 		await axios.post(`/auth/accept-invite/${token}`, user)
 		await this.login(user as User)
 	}
 
-	async register(user: Record<string, any>, errors: Record<string, any>) {
+	async register(user: { [key: string]: any }, errors: { [key: string]: any }) {
 		try {
 			await axios.post<User>('/auth/register', user)
 			return this.login(user as User)
@@ -192,7 +192,7 @@ export class Bagel {
 
 	onError?: (err: any) => void
 
-	constructor({ host, onError }: Record<string, any>) {
+	constructor({ host, onError }: { [key: string]: any }) {
 		this.host = host?.replace(/\/$/, '')
 		if (!this.host) {
 			throw new Error(
@@ -203,7 +203,7 @@ export class Bagel {
 		this.onError = onError
 	}
 
-	read_table: Tables | null = null
+	read_table: Tables | undefined = undefined
 
 	data(table: Tables): DataRequest<Tables> {
 		return new DataRequest(table, this)
@@ -212,14 +212,14 @@ export class Bagel {
 	auth = new BagelAuth(this)
 
 	_endpointCleaner(endpoint: string) {
-		const url = `${endpoint.replace(/^\//, '').replace(/\/$/g, '')}`
+		const url = `${endpoint.replace(/^\//, '').replaceAll(/\/$/g, '')}`
 		return url
 	}
 
 	async api(
 		endpoint: string,
-		query?: Record<string, string>,
-	): Promise<Record<string, any>> {
+		query?: { [key: string]: string },
+	): Promise<{ [key: string]: any }> {
 		if (query) {
 			const queryParams = Object.entries(query)
 				.map(([key, value]) => `${key}=${value}`)
@@ -231,13 +231,14 @@ export class Bagel {
 			.then(({ data }: { data: any }) => data)
 	}
 
-	async get<T = Record<string, any>>(
+	async get<T = { [key: string]: any }>(
 		endpoint: string,
-		query?: Record<string, any>,
+		query?: { [key: string]: any },
 	): Promise<T> {
 		this._setAuthorization()
 		endpoint = this._endpointCleaner(endpoint)
-		if (endpoint.match(/undefined|null/)) throw new Error(`Invalid endpoint: ${endpoint}`)
+		if ((/undefined|null/).test(endpoint)) throw new Error(`Invalid endpoint: ${endpoint}`)
+
 		if (query) {
 			const queryParams = Object.entries(query)
 				.filter(([_, value]) => !!value)
@@ -255,7 +256,7 @@ export class Bagel {
 			})
 	}
 
-	async delete(endpoint: string): Promise<Record<string, any>> {
+	async delete(endpoint: string): Promise<{ [key: string]: any }> {
 		this._setAuthorization()
 		endpoint = this._endpointCleaner(endpoint)
 		return axios
@@ -267,7 +268,7 @@ export class Bagel {
 			})
 	}
 
-	async put(endpoint: string, payload: any): Promise<Record<string, any>> {
+	async put(endpoint: string, payload: any): Promise<{ [key: string]: any }> {
 		endpoint = this._endpointCleaner(endpoint)
 		this._setAuthorization()
 		return axios
@@ -282,7 +283,7 @@ export class Bagel {
 	async patch(
 		endpoint: string,
 		payload: any = {},
-	): Promise<Record<string, any>> {
+	): Promise<{ [key: string]: any }> {
 		endpoint = this._endpointCleaner(endpoint)
 		return axios
 			.patch(`/${endpoint}`, payload)
@@ -303,7 +304,7 @@ export class Bagel {
 	async post(
 		endpoint: string,
 		payload: any = {},
-	): Promise<Record<string, any>> {
+	): Promise<{ [key: string]: any }> {
 		this._setAuthorization()
 		endpoint = this._endpointCleaner(endpoint)
 		return axios

package/src/openAPITools/functionGenerator.ts

@@ -18,6 +18,8 @@ import {
 
 const allTypes: string[] = []
 
+const primitiveTypes = ['string', 'number', 'boolean', 'null', 'void', 'any', 'Record<string, any>', 'undefined', '{ [key: string]: any }']
+
 function collectTypeForImportStatement(typeName: string) {
 	typeName = typeName.trim().replace('[]', '')
 	if (typeName.includes('|')) {
@@ -26,16 +28,15 @@ function collectTypeForImportStatement(typeName: string) {
 		)
 		return
 	}
-	const primitiveTypes = ['string', 'number', 'boolean', 'null', 'void', 'any', 'Record<string, any>']
 	const isPrimitive = primitiveTypes.includes(typeName)
 	typeName = formatType(typeName)
 	if (!typeName || isPrimitive) return
 	if (!allTypes.includes(typeName)) allTypes.push(typeName)
 }
 
-function getResponseType(response: ResponseObject): string | null {
+function getResponseType(response: ResponseObject): string | undefined {
 	const mediaTypeObject = response.content?.['application/json']
-	if (!mediaTypeObject || !mediaTypeObject.schema) return null
+	if (!mediaTypeObject || !mediaTypeObject.schema) return
 	const responseType = schemaToType(mediaTypeObject.schema)
 	collectTypeForImportStatement(responseType)
 	return responseType
@@ -101,7 +102,7 @@ function formatPathWithParams(path: string) {
 	return formattedPath
 }
 
-function generateRequestBody(requestBody?: RequestBodyObject): Record<string, string> {
+function generateRequestBody(requestBody?: RequestBodyObject): { [key: string]: string } {
 	const bodySchema = requestBody?.content['application/json']?.schema
 	if (!bodySchema) return { requestBodyParam: '', requestBodyPayload: '' }
 	const requestBodyType = schemaToType(bodySchema)
@@ -170,7 +171,7 @@ function generateFunctionForOperation(method: string, path: string, operation: O
 	return generateAxiosFunction(method, formattedPath, allParams, responseTypeStr, parameters, requestBodyPayload)
 }
 
-const generateRandomString = () => Math.random().toString(36).substring(7)
+const generateRandomString = () => Math.random().toString(36).slice(7)
 
 function fileTemplate(tsString: string, typeForImport: string[], baseURL: string) {
 	const templateCode = (
@@ -185,11 +186,11 @@ function fileTemplate(tsString: string, typeForImport: string[], baseURL: string
 	return templateCode.replace(doubleQuoteRegex, '$1:')
 }
 
-const functionsInventory: Record<string, any> = {}
+const functionsInventory: { [key: string]: any } = {}
 const pathOperations: any[] = []
 
 function hasConflict(path: string, method: string) {
-	const cleanPathName = path.split('/').filter(p => p && !p.match(/\{|\}/)).join('/')
+	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
@@ -205,10 +206,10 @@ function createFunctionPlaceholder(path: string, method: string, operation: any)
 function handlePathSegment(
 	path: string,
 	operation: any,
-	existingObj: Record<string, any> | null = null,
+	existingObj: { [key: string]: any } = {},
 ) {
 	const methods = Object.keys(operation)
-	const obj: Record<string, any> = {}
+	const obj: { [key: string]: any } = {}
 	for (const method of methods) {
 		let functionName = method.toLowerCase()
 		if (hasConflict(path, method)) {
@@ -222,10 +223,10 @@ function handlePathSegment(
 
 export function generateFunctions(paths: PathsObject, baseUrl: string) {
 	let tsString = ''
-	const body: Record<string, any> = {}
+	const body: { [key: string]: any } = {}
 	const allPathsClean = Object.keys(paths).map(cleanPath)
 	for (const [path, operation] of Object.entries(paths)) {
-		const splitPath = path.split('/').filter(p => p && !p.match(/\{|\}/))
+		const splitPath = path.split('/').filter(p => p && !(/\{|\}/).test(p))
 		splitPath.reduce((acc, key: string, index: number, array: string[]) => {
 			const objFuncKey = toCamelCase(key)
 			if (!objFuncKey) return acc
@@ -248,7 +249,7 @@ export function generateFunctions(paths: PathsObject, baseUrl: string) {
 		}, body)
 	}
 	for (const [parent, object] of Object.entries(body)) {
-		tsString += `export const ${parent} = ${JSON.stringify(object, null, 2)};\n`
+		tsString += `export const ${parent} = ${JSON.stringify(object, undefined, 2)};\n`
 	}
 	Object.entries(functionsInventory).forEach(([key, value]) => {
 		tsString = tsString.replace(`"${key}"`, value)

package/src/openAPITools/utils.ts

@@ -1,11 +1,11 @@
 import type { SchemaObject } from './openApiTypes'
 
-export const toCamelCase = (str?: string) => str?.replace(/[-._\s]+(.)?/g, (_, c) => c?.toUpperCase() || '').replace(/^./, str => str.toLowerCase()) || str
-export const toPascalCase = (str?: string) => str?.replace(/[-_\s]+(.)?/g, (_, c) => c?.toUpperCase() || '').replace(/^./, str => str.toUpperCase()) || str
+export const toCamelCase = (str?: string) => str?.replaceAll(/[-._\s]+(.)?/g, (_, c) => c?.toUpperCase() || '').replace(/^./, str => str.toLowerCase()) || str
+export const toPascalCase = (str?: string) => str?.replaceAll(/[-_\s]+(.)?/g, (_, c) => c?.toUpperCase() || '').replace(/^./, str => str.toUpperCase()) || str
 
 export function formatType(typeName: string): string {
 	// eslint-disable-next-line regexp/no-unused-capturing-group
-	typeName = typeName.replace(/-/g, '').replace(/(post|put)$/gi, '').replace(/^body_/gi, '')
+	typeName = typeName.replaceAll('-', '').replaceAll(/(post|put)$/gi, '').replaceAll(/^body_/gi, '')
 	return toPascalCase(typeName)!
 }
 
@@ -22,7 +22,7 @@ export function schemaToType(schema?: SchemaObject): string {
 	if (schema.$ref) return resolveReference(schema.$ref)
 	switch (schema.type) {
 		case 'object':
-			return 'Record<string, any>'
+			return '{ [key: string]: any }'
 		case 'string':
 			return 'string'
 		case 'integer':
@@ -33,6 +33,8 @@ export function schemaToType(schema?: SchemaObject): string {
 			return 'boolean'
 		case 'array':
 			return `${schemaToType(schema.items)}[]`
+		case 'undefined':
+			return 'undefined'
 		case 'null':
 			return 'null'
 		default:
@@ -43,14 +45,18 @@ export function schemaToType(schema?: SchemaObject): string {
 export function isOptional(schema: SchemaObject) {
 	/// / !schema?.required?.includes(schema.title || '')
 	const type = schemaToType(schema)
-	return type.split(/\s+\|\s+/).includes('null') || schema.default !== undefined
+	const splitType = type.split(/\s+\|\s+/)
+	const includesNull = splitType.includes('null')
+	const includesUndefined = splitType.includes('undefined')
+
+	return includesNull || includesUndefined || schema.default !== undefined
 }
 
-export const cleanNulls = (str: string) => str.split(' | ').filter(t => t !== 'null').join(' | ')
+export const cleanOptionals = (str: string) => str.split(' | ').filter(t => t !== 'null' && t !== 'undefined').join(' | ')
 
-export function formatVarType(varName: string, schema: any, required = false, defaultValue: any = null) {
+export function formatVarType(varName: string, schema: any, required = false, defaultValue?: unknown) {
 	let type = schemaToType(schema)
-	type = cleanNulls(type)
+	type = cleanOptionals(type)
 
 	let defaultStr = defaultValue ? ` = ${defaultValue}` : ''
 
@@ -64,5 +70,5 @@ export function formatVarType(varName: string, schema: any, required = false, de
 }
 
 export function cleanPath(path: string) {
-	return path.split('/').filter(p => p && !p.match(/\{|\}/)).join('/')
+	return path.split('/').filter(p => p && !(/\{|\}/).test(p)).join('/')
 }