quickbase-js 1.1.0-beta.6 → 1.1.0

package/src/generated-unified/QuickbaseClient.ts

@@ -1,62 +0,0 @@
-// Generated on 2025-03-12T19:20:50.952Z
-import { App, CopyApp200Response, CopyAppRequest, CreateApp200Response, CreateAppRequest, CreateField200Response, CreateFieldRequest, DeleteApp200Response, DeleteAppRequest, DeleteFields200Response, DeleteFieldsRequest, DeleteRecords200Response, DeleteRecordsRequest, DeleteTableResponse, Field, FieldUsage, GetRelationships200Response, GetTempTokenDBID200Response, ReportRunResponse, RunQueryRequest, RunQueryResponse, Table, UpdateTableRequest, Upsert200Response, Upsert207Response, UpsertRequest } from "../generated/models";
-
-export interface QuickbaseClient {
-  createApp: (params: { body: CreateAppRequest }) => Promise<CreateApp200Response>;
-  getApp: (params: { appId: string }) => Promise<App>;
-  deleteApp: (params: { appId: string; body: DeleteAppRequest }) => Promise<DeleteApp200Response>;
-  getAppEvents: (params: { appId: string }) => Promise<any[]>;
-  copyApp: (params: { appId: string; body: CopyAppRequest }) => Promise<CopyApp200Response>;
-  getAppTables: (params: { appId: string }) => Promise<Table[]>;
-  createTable: (params: { appId: string; body: any }) => Promise<Table>;
-  getTable: (params: { tableId: string; appId: string }) => Promise<Table>;
-  updateTable: (params: { tableId: string; appId: string; body: UpdateTableRequest }) => Promise<Table>;
-  deleteTable: (params: { tableId: string; appId: string }) => Promise<DeleteTableResponse>;
-  getRelationships: (params: { tableId: string; skip?: number }) => Promise<GetRelationships200Response>;
-  createRelationship: (params: { tableId: string; generated?: any }) => Promise<{ [key: string]: any }>;
-  updateRelationship: (params: { tableId: string; relationshipId: any; generated?: any }) => Promise<{ [key: string]: any }>;
-  deleteRelationship: (params: { tableId: string; relationshipId: any }) => Promise<{ [key: string]: any }>;
-  getTableReports: (params: { tableId: string }) => Promise<any[]>;
-  getReport: (params: { tableId: string; reportId: string }) => Promise<{ [key: string]: any }>;
-  runReport: (params: { reportId: string; generated: any }) => Promise<ReportRunResponse[]>;
-  getFields: (params: { tableId: string; includeFieldPerms?: boolean }) => Promise<Field[]>;
-  createField: (params: { tableId: string; body: CreateFieldRequest }) => Promise<CreateField200Response>;
-  deleteFields: (params: { tableId: string; body: DeleteFieldsRequest }) => Promise<DeleteFields200Response>;
-  getField: (params: { fieldId: number; tableId: string; includeFieldPerms?: boolean }) => Promise<Field>;
-  getFieldsUsage: (params: { tableId: string; skip?: number; top?: number }) => Promise<FieldUsage[]>;
-  getFieldUsage: (params: { fieldId: number; tableId: string }) => Promise<FieldUsage[]>;
-  runFormula: (params: { generated?: any }) => Promise<{ [key: string]: any }>;
-  upsert: (params: { body: UpsertRequest }) => Promise<Upsert200Response | Upsert207Response>;
-  deleteRecords: (params: { body: DeleteRecordsRequest }) => Promise<DeleteRecords200Response>;
-  runQuery: (params: { body: RunQueryRequest }) => Promise<RunQueryResponse>;
-  getTempTokenDBID: (params: { dbid: string }) => Promise<GetTempTokenDBID200Response>;
-  exchangeSsoToken: (params: { generated?: any }) => Promise<{ [key: string]: any }>;
-  cloneUserToken: (params: { generated?: any }) => Promise<{ [key: string]: any }>;
-  transferUserToken: (params: { generated?: any }) => Promise<{ [key: string]: any }>;
-  deactivateUserToken: (params: {  }) => Promise<{ [key: string]: any }>;
-  deleteUserToken: (params: {  }) => Promise<{ [key: string]: any }>;
-  downloadFile: (params: { tableId: string; recordId: number; fieldId: number; versionNumber: number }) => Promise<any>;
-  deleteFile: (params: { tableId: string; recordId: number; fieldId: number; versionNumber: number }) => Promise<{ [key: string]: any }>;
-  getUsers: (params: { accountId?: any; generated?: { [key: string]: any } }) => Promise<{ [key: string]: any }>;
-  denyUsers: (params: { accountId?: any; generated?: string[] }) => Promise<{ [key: string]: any }>;
-  denyUsersAndGroups: (params: { accountId?: any; shouldDeleteFromGroups: boolean; generated?: string[] }) => Promise<{ [key: string]: any }>;
-  undenyUsers: (params: { accountId?: any; generated?: string[] }) => Promise<{ [key: string]: any }>;
-  addMembersToGroup: (params: { gid: any; generated?: string[] }) => Promise<{ [key: string]: any }>;
-  removeMembersFromGroup: (params: { gid: any; generated?: string[] }) => Promise<{ [key: string]: any }>;
-  addManagersToGroup: (params: { gid: any; generated?: string[] }) => Promise<{ [key: string]: any }>;
-  removeManagersFromGroup: (params: { gid: any; generated?: string[] }) => Promise<{ [key: string]: any }>;
-  addSubgroupsToGroup: (params: { gid: any; generated?: string[] }) => Promise<{ [key: string]: any }>;
-  removeSubgroupsFromGroup: (params: { gid: any; generated?: string[] }) => Promise<{ [key: string]: any }>;
-  audit: (params: { generated?: any }) => Promise<{ [key: string]: any }>;
-  platformAnalyticReads: (params: { day?: string }) => Promise<{ [key: string]: any }>;
-  platformAnalyticEventSummaries: (params: { accountId?: any; generated?: any }) => Promise<any>;
-  exportSolution: (params: { solutionId: string; qBLVersion?: string }) => Promise<any>;
-  updateSolution: (params: { solutionId: string; generated?: any; xQBLErrorsAsSuccess?: boolean }) => Promise<any>;
-  createSolution: (params: { generated?: any; xQBLErrorsAsSuccess?: boolean }) => Promise<any>;
-  exportSolutionToRecord: (params: { solutionId: string; tableId: string; fieldId: number; xQBLErrorsAsSuccess?: boolean; qBLVersion?: string }) => Promise<any>;
-  createSolutionFromRecord: (params: { tableId: string; fieldId: number; recordId: number; xQBLErrorsAsSuccess?: boolean }) => Promise<any>;
-  updateSolutionToRecord: (params: { solutionId: string; tableId: string; fieldId: number; recordId: number; xQBLErrorsAsSuccess?: boolean }) => Promise<any>;
-  changesetSolution: (params: { solutionId: string; generated?: any; xQBLErrorsAsSuccess?: boolean }) => Promise<any>;
-  changesetSolutionFromRecord: (params: { solutionId: string; tableId: string; fieldId: number; recordId: number; xQBLErrorsAsSuccess?: boolean }) => Promise<any>;
-  generateDocument: (params: { templateId: any; tableId: string; recordId?: any; filename: string; accept?: string; format?: string; margin?: string; unit?: string; pageSize?: string; orientation?: string; realm?: string }) => Promise<{ [key: string]: any }>;
-}

package/src/index.ts

@@ -1 +0,0 @@
-export * from "./quickbaseClient.ts";

package/src/quickbaseClient.ts

@@ -1,313 +0,0 @@
-// src/quickbaseClient.ts
-import { QuickbaseClient as IQuickbaseClient } from "./generated-unified/QuickbaseClient.ts";
-import {
-  Configuration,
-  HTTPHeaders,
-  ResponseError,
-} from "./generated/runtime.ts";
-import * as apis from "./generated/apis/index.ts";
-import { TokenCache } from "./tokenCache.ts";
-
-// Re-export all model types from generated/models
-export * from "./generated/models";
-
-const simplifyName = (name: string): string =>
-  name
-    .replace(/ById$/, "")
-    .replace(/Api$/, "")
-    .replace(/^(\w)/, (_, c) => c.toLowerCase());
-
-export interface QuickbaseClient extends IQuickbaseClient {}
-
-export interface QuickbaseConfig {
-  realm: string;
-  userToken?: string;
-  tempToken?: string;
-  useTempTokens?: boolean;
-  debug?: boolean;
-  fetchApi?: typeof fetch;
-}
-
-export interface TempTokenParams {
-  appId?: string;
-  tableId?: string;
-  dbid?: string;
-}
-
-type ApiMethod<K extends keyof QuickbaseClient> = (
-  requestParameters: Parameters<QuickbaseClient[K]>[0],
-  initOverrides?: RequestInit
-) => Promise<ReturnType<QuickbaseClient[K]>>;
-
-interface MethodInfo<K extends keyof QuickbaseClient> {
-  api: any;
-  method: ApiMethod<K>;
-  paramMap: string[];
-}
-
-type MethodMap = { [K in keyof QuickbaseClient]: MethodInfo<K> };
-
-const getParamNames = (fn: (...args: any[]) => any): string[] =>
-  fn
-    .toString()
-    .slice(fn.toString().indexOf("(") + 1, fn.toString().indexOf(")"))
-    .split(",")
-    .map((p) => p.trim().split("=")[0].trim())
-    .filter((p) => p && !p.match(/^\{/) && p !== "options");
-
-const extractDbid = (
-  params: Partial<TempTokenParams>,
-  errorMessage: string
-): string => {
-  const dbid = params.dbid || params.tableId || params.appId;
-  if (!dbid) {
-    throw new Error(errorMessage);
-  }
-  return dbid;
-};
-
-export function quickbase(config: QuickbaseConfig): QuickbaseClient {
-  const {
-    realm,
-    userToken,
-    tempToken: initialTempToken,
-    useTempTokens,
-    fetchApi,
-    debug,
-  } = config;
-  const baseUrl = `https://api.quickbase.com/v1`;
-
-  const tokenCache = new TokenCache();
-
-  const baseHeaders: HTTPHeaders = {
-    "QB-Realm-Hostname": `${realm}.quickbase.com`,
-    "Content-Type": "application/json",
-  };
-
-  if (initialTempToken) {
-    baseHeaders["Authorization"] = `QB-TEMP-TOKEN ${initialTempToken}`;
-  } else if (userToken && !useTempTokens) {
-    baseHeaders["Authorization"] = `QB-USER-TOKEN ${userToken}`;
-  }
-
-  const defaultFetch: typeof fetch | undefined =
-    typeof globalThis.window !== "undefined"
-      ? globalThis.window.fetch.bind(globalThis.window)
-      : undefined;
-  const configuration = new Configuration({
-    basePath: baseUrl,
-    headers: { ...baseHeaders },
-    fetchApi: fetchApi || defaultFetch,
-    credentials: "omit", // Default to "omit" for all requests
-  });
-
-  if (!configuration.fetchApi && typeof globalThis.window === "undefined") {
-    throw new Error(
-      "fetchApi must be provided in non-browser environments (e.g., Node.js)"
-    );
-  }
-
-  const apiInstances = Object.fromEntries(
-    Object.entries(apis)
-      .filter(([name]) => name.endsWith("Api"))
-      .map(([name, ApiClass]) => [
-        name.replace("Api", "").toLowerCase(),
-        new ApiClass(configuration),
-      ])
-  );
-
-  const methodMap = buildMethodMap();
-
-  function buildMethodMap(): MethodMap {
-    const methodMap: Partial<MethodMap> = {};
-    const isValidMethod = (name: string) =>
-      !name.startsWith("_") &&
-      name !== "constructor" &&
-      !["Middleware", "Pre", "Post", "Raw"].some((s) => name.includes(s));
-
-    for (const [apiName, api] of Object.entries(apiInstances)) {
-      Object.getOwnPropertyNames(Object.getPrototypeOf(api))
-        .filter(
-          (name) =>
-            isValidMethod(name) &&
-            typeof api[name as keyof typeof api] === "function"
-        )
-        .forEach((rawMethodName) => {
-          const simplifiedName = simplifyName(
-            rawMethodName
-          ) as keyof QuickbaseClient;
-          const method = api[rawMethodName as keyof typeof api];
-          const boundMethod = method.bind(api as any) as unknown;
-          if (typeof boundMethod === "function" && boundMethod.length <= 2) {
-            methodMap[simplifiedName] = {
-              api,
-              method: boundMethod as ApiMethod<typeof simplifiedName>,
-              paramMap: getParamNames(method),
-            };
-          }
-        });
-    }
-    return methodMap as MethodMap;
-  }
-
-  const fetchTempToken = async (dbid: string): Promise<string> => {
-    const effectiveFetch = fetchApi || defaultFetch;
-    if (!effectiveFetch) {
-      throw new Error(
-        "No fetch implementation available for fetching temp token"
-      );
-    }
-
-    const response = await effectiveFetch(
-      `https://api.quickbase.com/v1/auth/temporary/${dbid}`,
-      {
-        method: "GET",
-        headers: { ...baseHeaders },
-        credentials: "include", // Explicitly include credentials for token fetch
-      }
-    );
-
-    if (!response.ok) {
-      const errorBody: { message?: string } = await response.json();
-      throw new Error(
-        `API Error: ${errorBody.message || "Unknown error"} (Status: ${
-          response.status
-        })`
-      );
-    }
-
-    const tokenResult = await response.json();
-    const token = tokenResult.temporaryAuthorization;
-    if (!token) {
-      throw new Error("No temporary token returned from API");
-    }
-    tokenCache.set(dbid, token);
-    if (debug) {
-      console.log(
-        `Fetched and cached new token for dbid: ${dbid}`,
-        token,
-        `Expires at: ${new Date(
-          Date.now() + (4 * 60 + 50) * 1000
-        ).toISOString()}`
-      );
-    }
-    return token;
-  };
-
-  async function invokeMethod<K extends keyof QuickbaseClient>(
-    methodName: K,
-    params: Parameters<QuickbaseClient[K]>[0] & Partial<TempTokenParams>,
-    retryCount: number = 0
-  ): Promise<ReturnType<QuickbaseClient[K]>> {
-    const methodInfo = methodMap[methodName];
-    if (!methodInfo) {
-      throw new Error(`Method ${methodName} not found`);
-    }
-
-    const requestParameters =
-      methodInfo.paramMap.length === 1 &&
-      methodInfo.paramMap[0] === "requestParameters"
-        ? { requestParameters: params }
-        : params;
-    let requestOptions: RequestInit = {
-      credentials: "omit", // Explicitly set to "omit" for API calls
-    };
-
-    const selectedToken =
-      initialTempToken || (userToken && !useTempTokens ? userToken : undefined);
-
-    if (methodName === "getTempTokenDBID" && useTempTokens) {
-      const dbid = extractDbid(params, "No dbid provided for getTempTokenDBID");
-      const cachedToken = tokenCache.get(dbid);
-      if (cachedToken) {
-        return { temporaryAuthorization: cachedToken } as ReturnType<
-          QuickbaseClient[K]
-        >;
-      }
-    }
-
-    let authorizationToken = selectedToken;
-    if (useTempTokens && !authorizationToken) {
-      const dbid = extractDbid(
-        params,
-        `No dbid found in params for ${methodName} to fetch temp token`
-      );
-      const cachedToken = tokenCache.get(dbid);
-      authorizationToken = cachedToken || (await fetchTempToken(dbid));
-      if (methodName === "getTempTokenDBID") {
-        return { temporaryAuthorization: authorizationToken } as ReturnType<
-          QuickbaseClient[K]
-        >;
-      }
-      requestOptions.headers = {
-        ...baseHeaders,
-        Authorization: `QB-TEMP-TOKEN ${authorizationToken}`,
-      };
-    } else if (authorizationToken) {
-      requestOptions.headers = {
-        ...baseHeaders,
-        Authorization: `QB-USER-TOKEN ${authorizationToken}`,
-      };
-    }
-
-    try {
-      return await methodInfo.method(requestParameters, requestOptions);
-    } catch (error) {
-      if (
-        error instanceof ResponseError &&
-        error.response.status === 401 &&
-        retryCount < 1 &&
-        useTempTokens
-      ) {
-        if (debug) {
-          console.log(
-            `Authorization error for ${methodName}, refreshing token:`,
-            error.message
-          );
-        }
-        const dbid = extractDbid(
-          params,
-          `No dbid to refresh token after authorization error`
-        );
-        authorizationToken = await fetchTempToken(dbid);
-        requestOptions.headers = {
-          ...baseHeaders,
-          Authorization: `QB-TEMP-TOKEN ${authorizationToken}`,
-        };
-        if (debug) {
-          console.log(`Retrying ${methodName} with new token`);
-        }
-        return invokeMethod(methodName, params, retryCount + 1);
-      }
-      if (error instanceof ResponseError) {
-        let errorMessage = error.message;
-        try {
-          const errorBody: { message?: string } = await error.response.json();
-          if (debug) {
-            console.log(`Error response body for ${methodName}:`, errorBody);
-          }
-          errorMessage = errorBody.message || errorMessage;
-        } catch (e) {
-          // Silent fail on parse error
-        }
-        throw new Error(
-          `API Error: ${errorMessage} (Status: ${error.response.status})`
-        );
-      }
-      throw error;
-    }
-  }
-
-  const proxy = new Proxy<QuickbaseClient>({} as QuickbaseClient, {
-    get: (_, prop: string): ((params: any) => Promise<any>) | undefined => {
-      if (prop in methodMap) {
-        const methodName = prop as keyof QuickbaseClient;
-        return (params: Parameters<QuickbaseClient[typeof methodName]>[0]) =>
-          invokeMethod(methodName, params);
-      }
-      return undefined;
-    },
-  });
-
-  return proxy;
-}

package/src/tokenCache.ts

@@ -1,51 +0,0 @@
-interface CachedToken {
-  token: string;
-  expiresAt: number; // Timestamp in milliseconds
-}
-
-export class TokenCache {
-  private cache: Map<string, CachedToken>;
-  private readonly lifespan: number; // Token lifespan in milliseconds
-
-  constructor(lifespan: number = 4 * 60 * 1000 + 50 * 1000) {
-    // Default 4:50
-    this.cache = new Map<string, CachedToken>();
-    this.lifespan = lifespan;
-  }
-
-  get(dbid: string): string | undefined {
-    const entry = this.cache.get(dbid);
-    const now = Date.now();
-    if (entry && entry.expiresAt > now) {
-      return entry.token;
-    }
-    return undefined; // Expired or not found
-  }
-
-  // New method to get full entry
-  getEntry(dbid: string): CachedToken | undefined {
-    const entry = this.cache.get(dbid);
-    const now = Date.now();
-    if (entry && entry.expiresAt > now) {
-      return entry;
-    }
-    return undefined; // Expired or not found
-  }
-
-  set(dbid: string, token: string): void {
-    const now = Date.now();
-    this.cache.set(dbid, {
-      token,
-      expiresAt: now + this.lifespan,
-    });
-  }
-
-  dump(): [string, CachedToken][] {
-    return Array.from(this.cache.entries());
-  }
-
-  // New method to clear the cache
-  clear(): void {
-    this.cache.clear();
-  }
-}

package/test-artifacts/.last-run.json

@@ -1,6 +0,0 @@
-{
-  "status": "failed",
-  "failedTests": [
-    "07fa1d68e36f7ff08da6-e567a262e6a662a8edf4"
-  ]
-}

package/test-esm.js

@@ -1 +0,0 @@
-import { quickbase } from './dist/esm/quickbase.js'; const qb = quickbase({ realm: 'example', userToken: 'your-token' }); console.log(qb);