fireberry-api-client 1.0.2-beta.1.0 → 1.0.2-beta.1.2

package/dist/index.cjs

@@ -174,20 +174,6 @@ function createNetworkError(error) {
   });
 }
 
-// src/utils/helpers.ts
-function wait(ms) {
-  return new Promise((resolve) => {
-    setTimeout(resolve, ms);
-  });
-}
-function chunkArray(array, size) {
-  const result = [];
-  for (let i = 0; i < array.length; i += size) {
-    result.push(array.slice(i, i + size));
-  }
-  return result;
-}
-
 // src/constants/objectIds.ts
 var OBJECT_ID_MAP = {
   1: "accountid",
@@ -1073,6 +1059,584 @@ var QueryBuilder = class {
   }
 };
 
+// src/utils/helpers.ts
+function wait(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+function chunkArray(array, size) {
+  const result = [];
+  for (let i = 0; i < array.length; i += size) {
+    result.push(array.slice(i, i + size));
+  }
+  return result;
+}
+
+// src/transport/http.ts
+var HTTPTransport = class {
+  config;
+  constructor(config) {
+    this.config = {
+      apiKey: config.apiKey,
+      baseUrl: config.baseUrl || "https://api.fireberry.com",
+      timeout: config.timeout || 3e4,
+      retryOn429: config.retryOn429 ?? true,
+      maxRetries: config.maxRetries || 120,
+      retryDelay: config.retryDelay || 1e3
+    };
+  }
+  getType() {
+    return "http";
+  }
+  async request(options) {
+    const { method, endpoint, query: queryParams, body, headers: customHeaders, signal } = options;
+    let url = `${this.config.baseUrl}${endpoint}`;
+    if (queryParams && Object.keys(queryParams).length > 0) {
+      const params = new URLSearchParams();
+      for (const [key, value] of Object.entries(queryParams)) {
+        if (value !== void 0 && value !== null) {
+          params.set(key, String(value));
+        }
+      }
+      url += `?${params.toString()}`;
+    }
+    const headers = {
+      Accept: "application/json",
+      tokenid: this.config.apiKey,
+      ...customHeaders
+    };
+    if (body) {
+      headers["Content-Type"] = "application/json";
+    }
+    const fetchOptions = {
+      method,
+      headers,
+      signal
+    };
+    if (body) {
+      fetchOptions.body = JSON.stringify(body);
+    }
+    return this.executeWithRetry(url, fetchOptions);
+  }
+  async query(options) {
+    const {
+      objectType,
+      fields,
+      query,
+      sortBy = "modifiedon",
+      sortType = "desc",
+      limit,
+      page = 1,
+      pageSize = 500,
+      showRealValue = true,
+      autoPage = true,
+      signal
+    } = options;
+    let fieldsStr;
+    if (Array.isArray(fields)) {
+      fieldsStr = fields.join(",");
+    } else if (typeof fields === "string") {
+      fieldsStr = fields;
+    } else {
+      fieldsStr = "*";
+    }
+    if (autoPage) {
+      return this.queryAllPages({
+        objectType,
+        fields: fieldsStr,
+        query,
+        sortBy,
+        sortType,
+        showRealValue,
+        limit,
+        signal
+      });
+    }
+    const body = {
+      objecttype: objectType,
+      fields: fieldsStr,
+      query: query || "",
+      sort_by: sortBy,
+      sort_type: sortType,
+      page_size: Math.min(pageSize, limit || 500),
+      page_number: page,
+      show_real_value: showRealValue ? 1 : 0
+    };
+    const response = await this.request({
+      method: "POST",
+      endpoint: "/api/query",
+      body,
+      signal
+    });
+    const records = response.data?.Data || [];
+    return {
+      records,
+      total: records.length,
+      success: true
+    };
+  }
+  async createRecord(objectType, data, signal) {
+    const response = await this.request({
+      method: "POST",
+      endpoint: `/api/v2/record/${objectType}`,
+      body: data,
+      signal
+    });
+    return response.record;
+  }
+  async updateRecord(objectType, recordId, data, signal) {
+    const response = await this.request({
+      method: "PUT",
+      endpoint: `/api/v2/record/${objectType}/${recordId}`,
+      body: data,
+      signal
+    });
+    return response.record;
+  }
+  async deleteRecord(objectType, recordId, signal) {
+    await this.request({
+      method: "DELETE",
+      endpoint: `/api/record/${objectType}/${recordId}`,
+      signal
+    });
+    return {
+      success: true,
+      id: recordId
+    };
+  }
+  async batchCreate(objectType, records, signal) {
+    const response = await this.request({
+      method: "POST",
+      endpoint: `/api/v3/record/${objectType}/batch/create`,
+      body: { data: records },
+      signal
+    });
+    const data = response.data || [];
+    const dataArray = Array.isArray(data) ? data : [data];
+    return {
+      success: true,
+      data: dataArray,
+      count: dataArray.length
+    };
+  }
+  async batchUpdate(objectType, records, signal) {
+    const response = await this.request({
+      method: "POST",
+      endpoint: `/api/v3/record/${objectType}/batch/update`,
+      body: { data: records },
+      signal
+    });
+    const data = response.data || [];
+    const dataArray = Array.isArray(data) ? data : [data];
+    return {
+      success: true,
+      data: dataArray,
+      count: dataArray.length
+    };
+  }
+  async batchDelete(objectType, recordIds, signal) {
+    await this.request({
+      method: "POST",
+      endpoint: `/api/v3/record/${objectType}/batch/delete`,
+      body: { data: recordIds },
+      signal
+    });
+    return {
+      success: true,
+      ids: recordIds,
+      count: recordIds.length
+    };
+  }
+  /**
+   * Fetches all pages of a query
+   */
+  async queryAllPages(options) {
+    const { objectType, fields, query, sortBy, sortType, showRealValue, limit, signal } = options;
+    const maxPageSize = 500;
+    const allRecords = [];
+    let currentPage = 1;
+    let hasMore = true;
+    while (hasMore) {
+      if (signal?.aborted) {
+        break;
+      }
+      const body = {
+        objecttype: objectType,
+        fields,
+        query: query || "",
+        sort_by: sortBy,
+        sort_type: sortType,
+        page_size: maxPageSize,
+        page_number: currentPage,
+        show_real_value: showRealValue ? 1 : 0
+      };
+      const response = await this.request({
+        method: "POST",
+        endpoint: "/api/query",
+        body,
+        signal
+      });
+      const pageData = response.data?.Data || [];
+      allRecords.push(...pageData);
+      if (limit && allRecords.length >= limit) {
+        allRecords.splice(limit);
+        break;
+      }
+      if (pageData.length < maxPageSize) {
+        hasMore = false;
+      } else {
+        currentPage++;
+      }
+    }
+    return {
+      records: allRecords,
+      total: allRecords.length,
+      success: true
+    };
+  }
+  /**
+   * Executes a fetch request with retry logic for 429 errors
+   */
+  async executeWithRetry(url, options, retryCount = 0) {
+    try {
+      const timeoutController = new AbortController();
+      const timeoutId = setTimeout(() => {
+        timeoutController.abort();
+      }, this.config.timeout);
+      const combinedSignal = options.signal ? this.combineSignals([options.signal, timeoutController.signal]) : timeoutController.signal;
+      const response = await fetch(url, {
+        ...options,
+        signal: combinedSignal
+      });
+      clearTimeout(timeoutId);
+      if (response.status === 429 && this.config.retryOn429) {
+        if (retryCount < this.config.maxRetries) {
+          await wait(this.config.retryDelay);
+          return this.executeWithRetry(url, options, retryCount + 1);
+        }
+        throw new FireberryError("Rate limit exceeded after max retries", {
+          code: "RATE_LIMITED" /* RATE_LIMITED */,
+          statusCode: 429,
+          context: { retryCount }
+        });
+      }
+      let body;
+      const contentType = response.headers.get("content-type");
+      if (contentType?.includes("application/json")) {
+        body = await response.json();
+      } else {
+        body = await response.text();
+      }
+      if (!response.ok) {
+        throw createErrorFromResponse(response, body);
+      }
+      return body;
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        throw createNetworkError(error);
+      }
+      if (error instanceof FireberryError) {
+        throw error;
+      }
+      throw createNetworkError(error);
+    }
+  }
+  /**
+   * Combines multiple abort signals into one
+   */
+  combineSignals(signals) {
+    const controller = new AbortController();
+    for (const signal of signals) {
+      if (signal.aborted) {
+        controller.abort();
+        break;
+      }
+      signal.addEventListener("abort", () => controller.abort(), { once: true });
+    }
+    return controller.signal;
+  }
+};
+
+// src/transport/sdk.ts
+var BATCH_SIZE = 20;
+var SDKTransport = class {
+  sdk;
+  constructor(config) {
+    this.sdk = config.sdk;
+  }
+  getType() {
+    return "sdk";
+  }
+  async request(_options) {
+    throw new FireberryError(
+      "Raw request() is not supported in SDK mode. Use specific methods like query(), createRecord(), etc.",
+      {
+        code: "INVALID_REQUEST" /* INVALID_REQUEST */
+      }
+    );
+  }
+  async query(options) {
+    const {
+      objectType,
+      fields,
+      query,
+      limit,
+      page = 1,
+      pageSize = 500,
+      autoPage = true,
+      signal
+    } = options;
+    let fieldsStr;
+    if (Array.isArray(fields)) {
+      fieldsStr = fields.join(",");
+    } else if (typeof fields === "string") {
+      fieldsStr = fields;
+    } else {
+      fieldsStr = "*";
+    }
+    if (autoPage) {
+      return this.queryAllPages({
+        objectType,
+        fields: fieldsStr,
+        query,
+        limit,
+        pageSize,
+        signal
+      });
+    }
+    const payload = {
+      fields: fieldsStr,
+      query: query || "",
+      page_size: Math.min(pageSize, limit || 500),
+      page_number: page
+    };
+    const response = await this.sdk.api.query(objectType, payload);
+    if (!response.success && response.error) {
+      throw new FireberryError(
+        response.error.data?.Message || response.error.statusText || "SDK query failed",
+        {
+          code: "SERVER_ERROR" /* SERVER_ERROR */,
+          statusCode: response.error.status,
+          context: { response }
+        }
+      );
+    }
+    const pageData = Array.isArray(response.data) ? response.data : [response.data];
+    const records = pageData.filter(
+      (record) => record && typeof record === "object"
+    );
+    return {
+      records,
+      total: records.length,
+      success: true
+    };
+  }
+  async createRecord(objectType, data, signal) {
+    if (signal?.aborted) {
+      throw new FireberryError("Request aborted", {
+        code: "NETWORK_ERROR" /* NETWORK_ERROR */
+      });
+    }
+    const response = await this.sdk.api.create(objectType, data);
+    if (!response.success && response.error) {
+      throw new FireberryError(
+        response.error.data?.Message || response.error.statusText || "SDK create failed",
+        {
+          code: "SERVER_ERROR" /* SERVER_ERROR */,
+          statusCode: response.error.status,
+          context: { response }
+        }
+      );
+    }
+    return response.data;
+  }
+  async updateRecord(objectType, recordId, data, signal) {
+    if (signal?.aborted) {
+      throw new FireberryError("Request aborted", {
+        code: "NETWORK_ERROR" /* NETWORK_ERROR */
+      });
+    }
+    const response = await this.sdk.api.update(objectType, recordId, data);
+    if (!response.success && response.error) {
+      throw new FireberryError(
+        response.error.data?.Message || response.error.statusText || "SDK update failed",
+        {
+          code: "SERVER_ERROR" /* SERVER_ERROR */,
+          statusCode: response.error.status,
+          context: { response }
+        }
+      );
+    }
+    return response.data;
+  }
+  async deleteRecord(objectType, recordId, signal) {
+    if (signal?.aborted) {
+      throw new FireberryError("Request aborted", {
+        code: "NETWORK_ERROR" /* NETWORK_ERROR */
+      });
+    }
+    const response = await this.sdk.api.delete(objectType, recordId);
+    if (!response.success && response.error) {
+      throw new FireberryError(
+        response.error.data?.Message || response.error.statusText || "SDK delete failed",
+        {
+          code: "SERVER_ERROR" /* SERVER_ERROR */,
+          statusCode: response.error.status,
+          context: { response }
+        }
+      );
+    }
+    return {
+      success: true,
+      id: recordId
+    };
+  }
+  async batchCreate(objectType, records, signal) {
+    const batches = chunkArray(records, BATCH_SIZE);
+    const allResponses = [];
+    for (const batch of batches) {
+      if (signal?.aborted) {
+        break;
+      }
+      const batchPromises = batch.map((record) => this.createRecord(objectType, record, signal));
+      const batchResults = await Promise.all(batchPromises);
+      allResponses.push(...batchResults);
+    }
+    return {
+      success: true,
+      data: allResponses,
+      count: allResponses.length
+    };
+  }
+  async batchUpdate(objectType, records, signal) {
+    const batches = chunkArray(records, BATCH_SIZE);
+    const allResponses = [];
+    for (const batch of batches) {
+      if (signal?.aborted) {
+        break;
+      }
+      const batchPromises = batch.map(
+        (item) => this.updateRecord(objectType, item.id, item.record, signal)
+      );
+      const batchResults = await Promise.all(batchPromises);
+      allResponses.push(...batchResults);
+    }
+    return {
+      success: true,
+      data: allResponses,
+      count: allResponses.length
+    };
+  }
+  async batchDelete(objectType, recordIds, signal) {
+    const batches = chunkArray(recordIds, BATCH_SIZE);
+    const allDeletedIds = [];
+    for (const batch of batches) {
+      if (signal?.aborted) {
+        break;
+      }
+      const batchPromises = batch.map((id) => this.deleteRecord(objectType, id, signal));
+      await Promise.all(batchPromises);
+      allDeletedIds.push(...batch);
+    }
+    return {
+      success: true,
+      ids: allDeletedIds,
+      count: allDeletedIds.length
+    };
+  }
+  /**
+   * Fetches all pages of a query using SDK
+   */
+  async queryAllPages(options) {
+    const { objectType, fields, query, limit, pageSize = 500, signal } = options;
+    const maxPageSize = 500;
+    const allRecords = [];
+    let currentPage = 1;
+    let hasMore = true;
+    while (hasMore) {
+      if (signal?.aborted) {
+        break;
+      }
+      const payload = {
+        fields,
+        query: query || "",
+        page_size: Math.min(maxPageSize, pageSize),
+        page_number: currentPage
+      };
+      const response = await this.sdk.api.query(objectType, payload);
+      if (!response.success && response.error) {
+        throw new FireberryError(
+          response.error.data?.Message || response.error.statusText || "SDK query failed",
+          {
+            code: "SERVER_ERROR" /* SERVER_ERROR */,
+            statusCode: response.error.status,
+            context: { response }
+          }
+        );
+      }
+      const pageData = Array.isArray(response.data) ? response.data : [response.data];
+      const validRecords = pageData.filter(
+        (record) => record && typeof record === "object"
+      );
+      allRecords.push(...validRecords);
+      if (limit && allRecords.length >= limit) {
+        allRecords.splice(limit);
+        break;
+      }
+      if (validRecords.length < maxPageSize) {
+        hasMore = false;
+      } else {
+        currentPage++;
+      }
+    }
+    return {
+      records: allRecords,
+      total: allRecords.length,
+      success: true
+    };
+  }
+};
+
+// src/utils/transport.ts
+function createTransport(config) {
+  if (config.sdk) {
+    return new SDKTransport({ sdk: config.sdk });
+  }
+  if (config.apiKey) {
+    return new HTTPTransport({
+      apiKey: config.apiKey,
+      baseUrl: config.baseUrl,
+      timeout: config.timeout,
+      retryOn429: config.retryOn429,
+      maxRetries: config.maxRetries,
+      retryDelay: config.retryDelay
+    });
+  }
+  throw new FireberryError(
+    "Either apiKey or sdk must be provided in FireberryClientConfig",
+    {
+      code: "INVALID_REQUEST" /* INVALID_REQUEST */
+    }
+  );
+}
+function createMetadataTransport(config) {
+  if (!config.apiKey) {
+    return null;
+  }
+  return new HTTPTransport({
+    apiKey: config.apiKey,
+    baseUrl: config.baseUrl,
+    timeout: config.timeout,
+    retryOn429: config.retryOn429,
+    maxRetries: config.maxRetries,
+    retryDelay: config.retryDelay
+  });
+}
+function isMetadataAvailable(config) {
+  return Boolean(config.apiKey);
+}
+
 // src/constants/fieldTypes.ts
 var FIELD_TYPE_IDS = {
   DROPDOWN: "b4919f2e-2996-48e4-a03c-ba39fb64386c",
@@ -1113,6 +1677,23 @@ var MetadataAPI = class {
   constructor(client) {
     this.client = client;
   }
+  /**
+   * Checks if metadata operations are available and throws error if not
+   * @private
+   */
+  ensureMetadataAvailable() {
+    if (!this.client.isMetadataAvailable()) {
+      throw new FireberryError(
+        "Metadata operations are not available in SDK-only mode. Please provide an API key in the FireberryClient configuration to use metadata features.",
+        {
+          code: "INVALID_REQUEST" /* INVALID_REQUEST */,
+          context: {
+            hint: "Fireberry SDK does not yet support metadata operations. Use API key mode or hybrid mode (both SDK + API key) to access metadata."
+          }
+        }
+      );
+    }
+  }
   /**
    * Gets all available objects/entity types from Fireberry
    *
@@ -1126,6 +1707,7 @@ var MetadataAPI = class {
    * ```
    */
   async getObjects(signal) {
+    this.ensureMetadataAvailable();
     const cached = this.client.getCached("objects");
     if (cached) {
       return cached;
@@ -1163,6 +1745,7 @@ var MetadataAPI = class {
    * ```
    */
   async getFields(objectType, options) {
+    this.ensureMetadataAvailable();
     const objectTypeStr = String(objectType);
     const opts = options instanceof AbortSignal ? { signal: options, includeLookupRelations: true } : { signal: options?.signal, includeLookupRelations: options?.includeLookupRelations ?? true };
     const cached = this.client.getCached("fields", objectTypeStr);
@@ -1219,24 +1802,27 @@ var MetadataAPI = class {
     if (queryableFields.length === 0) {
       return relations;
     }
-    const response = await this.client.request({
-      method: "POST",
-      endpoint: ENDPOINTS.QUERY,
-      body: {
-        objecttype: objectType,
-        fields: queryableFields.join(","),
-        query: "",
-        page_size: 1,
-        page_number: 1,
-        show_real_value: 0
-      },
-      signal
-    });
-    const columns = response.data?.Columns || [];
-    for (const column of columns) {
-      if (column.fieldobjecttype !== null && column.fieldobjecttype !== void 0) {
-        relations.set(column.fieldname, column.fieldobjecttype);
+    try {
+      const response = await this.client.request({
+        method: "POST",
+        endpoint: ENDPOINTS.QUERY,
+        body: {
+          objecttype: objectType,
+          fields: queryableFields.join(","),
+          query: "",
+          page_size: 1,
+          page_number: 1,
+          show_real_value: 0
+        },
+        signal
+      });
+      const columns = response.data?.Columns || [];
+      for (const column of columns) {
+        if (column.fieldobjecttype !== null && column.fieldobjecttype !== void 0) {
+          relations.set(column.fieldname, column.fieldobjecttype);
+        }
       }
+    } catch (error) {
     }
     return relations;
   }
@@ -1255,6 +1841,7 @@ var MetadataAPI = class {
    * ```
    */
   async getFieldValues(objectType, fieldName, signal) {
+    this.ensureMetadataAvailable();
     const objectTypeStr = String(objectType);
     const cached = this.client.getCached(
       "fieldValues",
@@ -1304,14 +1891,10 @@ var RecordsAPI = class {
    */
   async create(objectType, data, options) {
     const objectTypeStr = String(objectType);
-    const response = await this.client.request({
-      method: "POST",
-      endpoint: `/api/v2/record/${objectTypeStr}`,
-      body: data,
-      signal: options?.signal
-    });
+    const transport = this.client.getTransport();
+    const record = await transport.createRecord(objectTypeStr, data, options?.signal);
     this.client.invalidateCacheForMutation(objectTypeStr);
-    return response.record;
+    return record;
   }
   /**
    * Updates an existing record in Fireberry
@@ -1331,14 +1914,10 @@ var RecordsAPI = class {
    */
   async update(objectType, recordId, data, options) {
     const objectTypeStr = String(objectType);
-    const response = await this.client.request({
-      method: "PUT",
-      endpoint: `/api/v2/record/${objectTypeStr}/${recordId}`,
-      body: data,
-      signal: options?.signal
-    });
+    const transport = this.client.getTransport();
+    const record = await transport.updateRecord(objectTypeStr, recordId, data, options?.signal);
     this.client.invalidateCacheForMutation(objectTypeStr);
-    return response.record;
+    return record;
   }
   /**
    * Deletes a record from Fireberry
@@ -1355,16 +1934,10 @@ var RecordsAPI = class {
    */
   async delete(objectType, recordId, options) {
     const objectTypeStr = String(objectType);
-    await this.client.request({
-      method: "DELETE",
-      endpoint: `/api/record/${objectTypeStr}/${recordId}`,
-      signal: options?.signal
-    });
+    const transport = this.client.getTransport();
+    const result = await transport.deleteRecord(objectTypeStr, recordId, options?.signal);
     this.client.invalidateCacheForMutation(objectTypeStr);
-    return {
-      success: true,
-      id: recordId
-    };
+    return result;
   }
   /**
    * Upserts a record (creates if not exists, updates if exists)
@@ -1432,7 +2005,7 @@ var RecordsAPI = class {
 };
 
 // src/api/batch.ts
-var BATCH_SIZE = 20;
+var BATCH_SIZE2 = 20;
 var BatchAPI = class {
   constructor(client) {
     this.client = client;
@@ -1457,25 +2030,15 @@ var BatchAPI = class {
    */
   async create(objectType, records, options) {
     const objectTypeStr = String(objectType);
-    const batches = chunkArray(records, BATCH_SIZE);
+    const transport = this.client.getTransport();
+    const batches = chunkArray(records, BATCH_SIZE2);
     const allResponses = [];
     for (const batch of batches) {
       if (options?.signal?.aborted) {
         break;
       }
-      const response = await this.client.request({
-        method: "POST",
-        endpoint: `/api/v3/record/${objectTypeStr}/batch/create`,
-        body: { data: batch },
-        signal: options?.signal
-      });
-      if (response.data) {
-        if (Array.isArray(response.data)) {
-          allResponses.push(...response.data);
-        } else {
-          allResponses.push(response.data);
-        }
-      }
+      const result = await transport.batchCreate(objectTypeStr, batch, options?.signal);
+      allResponses.push(...result.data);
     }
     this.client.invalidateCacheForMutation(objectTypeStr);
     return {
@@ -1503,25 +2066,15 @@ var BatchAPI = class {
    */
   async update(objectType, records, options) {
     const objectTypeStr = String(objectType);
-    const batches = chunkArray(records, BATCH_SIZE);
+    const transport = this.client.getTransport();
+    const batches = chunkArray(records, BATCH_SIZE2);
     const allResponses = [];
     for (const batch of batches) {
       if (options?.signal?.aborted) {
         break;
       }
-      const response = await this.client.request({
-        method: "POST",
-        endpoint: `/api/v3/record/${objectTypeStr}/batch/update`,
-        body: { data: batch },
-        signal: options?.signal
-      });
-      if (response.data) {
-        if (Array.isArray(response.data)) {
-          allResponses.push(...response.data);
-        } else {
-          allResponses.push(response.data);
-        }
-      }
+      const result = await transport.batchUpdate(objectTypeStr, batch, options?.signal);
+      allResponses.push(...result.data);
     }
     this.client.invalidateCacheForMutation(objectTypeStr);
     return {
@@ -1547,19 +2100,15 @@ var BatchAPI = class {
    */
   async delete(objectType, recordIds, options) {
     const objectTypeStr = String(objectType);
-    const batches = chunkArray(recordIds, BATCH_SIZE);
+    const transport = this.client.getTransport();
+    const batches = chunkArray(recordIds, BATCH_SIZE2);
     const allDeletedIds = [];
     for (const batch of batches) {
       if (options?.signal?.aborted) {
         break;
       }
-      await this.client.request({
-        method: "POST",
-        endpoint: `/api/v3/record/${objectTypeStr}/batch/delete`,
-        body: { data: batch },
-        signal: options?.signal
-      });
-      allDeletedIds.push(...batch);
+      const result = await transport.batchDelete(objectTypeStr, batch, options?.signal);
+      allDeletedIds.push(...result.ids);
     }
     this.client.invalidateCacheForMutation(objectTypeStr);
     return {
@@ -1737,7 +2286,15 @@ var FilesAPI = class {
     const objectTypeStr = String(objectType);
     const { buffer, filename, mimeType } = options;
     const config = this.client.getConfig();
-    const url = `${config.baseUrl}/api/v2/record/${objectTypeStr}/${recordId}/files`;
+    if (!config.apiKey) {
+      throw new FireberryError(
+        "File upload requires an API key. SDK mode does not support file uploads.",
+        {
+          code: "INVALID_REQUEST" /* INVALID_REQUEST */
+        }
+      );
+    }
+    const url = `${config.baseUrl || "https://api.fireberry.com"}/api/v2/record/${objectTypeStr}/${recordId}/files`;
     const boundary = `----FormBoundary${Date.now()}`;
     const formParts = [];
     const fileHeader = [
@@ -1810,9 +2367,12 @@ function generateQueryCacheKey(options) {
 }
 var FireberryClient = class {
   config;
+  normalizedConfig;
   cacheStore;
   inFlightQueries = /* @__PURE__ */ new Map();
   queryCache = /* @__PURE__ */ new Map();
+  transport;
+  metadataTransport;
   /** Metadata API operations */
   metadata;
   /** Records CRUD operations */
@@ -1827,8 +2387,8 @@ var FireberryClient = class {
    * Creates a new FireberryClient instance
    */
   constructor(config) {
-    this.config = {
-      apiKey: config.apiKey,
+    this.config = config;
+    this.normalizedConfig = {
       baseUrl: config.baseUrl || "https://api.fireberry.com",
       timeout: config.timeout || 3e4,
       retryOn429: config.retryOn429 ?? true,
@@ -1847,6 +2407,8 @@ var FireberryClient = class {
       fields: /* @__PURE__ */ new Map(),
       fieldValues: /* @__PURE__ */ new Map()
     };
+    this.transport = createTransport(config);
+    this.metadataTransport = createMetadataTransport(config);
     this.metadata = new MetadataAPI(this);
     this.records = new RecordsAPI(this);
     this.batch = new BatchAPI(this);
@@ -1854,10 +2416,34 @@ var FireberryClient = class {
     this.files = new FilesAPI(this);
   }
   /**
-   * Gets the client configuration
+   * Gets the client configuration with all defaults applied
    */
   getConfig() {
-    return this.config;
+    return {
+      ...this.config,
+      ...this.normalizedConfig
+    };
+  }
+  /**
+   * Gets the transport instance (for internal use by API modules)
+   * @internal
+   */
+  getTransport() {
+    return this.transport;
+  }
+  /**
+   * Gets the metadata transport instance (for internal use by MetadataAPI)
+   * Returns null if metadata is not available (SDK-only mode without API key)
+   * @internal
+   */
+  getMetadataTransport() {
+    return this.metadataTransport;
+  }
+  /**
+   * Checks if metadata operations are available
+   */
+  isMetadataAvailable() {
+    return isMetadataAvailable(this.config);
   }
   /**
    * Cache control methods
@@ -1906,7 +2492,7 @@ var FireberryClient = class {
    * @internal
    */
   invalidateCacheForMutation(objectType) {
-    if (this.config.invalidateCacheOnMutation) {
+    if (this.normalizedConfig.invalidateCacheOnMutation) {
       this.cache.clearQueryResultsForObject(objectType);
     }
   }
@@ -1915,55 +2501,55 @@ var FireberryClient = class {
    */
   cleanupExpiredCacheEntries() {
     const now = Date.now();
-    if (this.config.cacheQueryResults) {
+    if (this.normalizedConfig.cacheQueryResults) {
       for (const [key, entry] of this.queryCache) {
-        if (now - entry.timestamp >= this.config.queryResultCacheTTL) {
+        if (now - entry.timestamp >= this.normalizedConfig.queryResultCacheTTL) {
           this.queryCache.delete(key);
         }
       }
     }
-    if (this.config.cacheMetadata) {
-      if (this.cacheStore.objects && now - this.cacheStore.objects.timestamp >= this.config.cacheTTL) {
+    if (this.normalizedConfig.cacheMetadata) {
+      if (this.cacheStore.objects && now - this.cacheStore.objects.timestamp >= this.normalizedConfig.cacheTTL) {
         this.cacheStore.objects = void 0;
       }
       for (const [key, entry] of this.cacheStore.fields) {
-        if (now - entry.timestamp >= this.config.cacheTTL) {
+        if (now - entry.timestamp >= this.normalizedConfig.cacheTTL) {
           this.cacheStore.fields.delete(key);
         }
       }
       for (const [key, entry] of this.cacheStore.fieldValues) {
-        if (now - entry.timestamp >= this.config.cacheTTL) {
+        if (now - entry.timestamp >= this.normalizedConfig.cacheTTL) {
           this.cacheStore.fieldValues.delete(key);
         }
       }
     }
   }
   getCached(type, objectType, fieldName) {
-    if (!this.config.cacheMetadata) {
+    if (!this.normalizedConfig.cacheMetadata) {
       return void 0;
     }
     const now = Date.now();
     if (type === "objects") {
       const cached = this.cacheStore.objects;
-      if (cached && now - cached.timestamp < this.config.cacheTTL) {
+      if (cached && now - cached.timestamp < this.normalizedConfig.cacheTTL) {
         return cached.data;
       }
     } else if (type === "fields" && objectType) {
       const cached = this.cacheStore.fields.get(objectType);
-      if (cached && now - cached.timestamp < this.config.cacheTTL) {
+      if (cached && now - cached.timestamp < this.normalizedConfig.cacheTTL) {
         return cached.data;
       }
     } else if (type === "fieldValues" && objectType && fieldName) {
       const key = `${objectType}:${fieldName}`;
       const cached = this.cacheStore.fieldValues.get(key);
-      if (cached && now - cached.timestamp < this.config.cacheTTL) {
+      if (cached && now - cached.timestamp < this.normalizedConfig.cacheTTL) {
         return cached.data;
       }
     }
     return void 0;
   }
   setCache(type, objectTypeOrData, fieldNameOrData, data) {
-    if (!this.config.cacheMetadata) {
+    if (!this.normalizedConfig.cacheMetadata) {
       return;
     }
     this.cleanupExpiredCacheEntries();
@@ -2116,9 +2702,9 @@ var FireberryClient = class {
    */
   async query(options) {
     const cacheKey = generateQueryCacheKey(options);
-    if (this.config.cacheQueryResults) {
+    if (this.normalizedConfig.cacheQueryResults) {
       const cached = this.queryCache.get(cacheKey);
-      if (cached && Date.now() - cached.timestamp < this.config.queryResultCacheTTL) {
+      if (cached && Date.now() - cached.timestamp < this.normalizedConfig.queryResultCacheTTL) {
         return cached.data;
       }
     }
@@ -2130,7 +2716,7 @@ var FireberryClient = class {
     this.inFlightQueries.set(cacheKey, queryPromise);
     try {
       const result = await queryPromise;
-      if (this.config.cacheQueryResults) {
+      if (this.normalizedConfig.cacheQueryResults) {
         this.cleanupExpiredCacheEntries();
         this.queryCache.set(cacheKey, {
           data: result,
@@ -2149,14 +2735,6 @@ var FireberryClient = class {
     const {
       objectType,
       fields,
-      query,
-      sortBy = "modifiedon",
-      sortType = "desc",
-      limit,
-      page = 1,
-      pageSize = 500,
-      showRealValue = true,
-      autoPage = true,
       signal
     } = options;
     let fieldsStr;
@@ -2170,87 +2748,10 @@ var FireberryClient = class {
     if (fieldsStr === "*") {
       fieldsStr = await this.expandStarFields(objectType, signal);
     }
-    if (autoPage) {
-      return this.queryAllPages({
-        objectType,
-        fields: fieldsStr,
-        query,
-        sortBy,
-        sortType,
-        showRealValue,
-        limit,
-        signal
-      });
-    }
-    const body = {
-      objecttype: objectType,
-      fields: fieldsStr,
-      query: query || "",
-      sort_by: sortBy,
-      sort_type: sortType,
-      page_size: Math.min(pageSize, limit || 500),
-      page_number: page,
-      show_real_value: showRealValue ? 1 : 0
-    };
-    const response = await this.request({
-      method: "POST",
-      endpoint: "/api/query",
-      body,
-      signal
+    return this.transport.query({
+      ...options,
+      fields: fieldsStr
     });
-    const records = response.data?.Data || [];
-    return {
-      records,
-      total: records.length,
-      success: true
-    };
-  }
-  /**
-   * Fetches all pages of a query
-   */
-  async queryAllPages(options) {
-    const { objectType, fields, query, sortBy, sortType, showRealValue, limit, signal } = options;
-    const maxPageSize = 500;
-    const allRecords = [];
-    let currentPage = 1;
-    let hasMore = true;
-    while (hasMore) {
-      if (signal?.aborted) {
-        break;
-      }
-      const body = {
-        objecttype: objectType,
-        fields,
-        query: query || "",
-        sort_by: sortBy,
-        sort_type: sortType,
-        page_size: maxPageSize,
-        page_number: currentPage,
-        show_real_value: showRealValue ? 1 : 0
-      };
-      const response = await this.request({
-        method: "POST",
-        endpoint: "/api/query",
-        body,
-        signal
-      });
-      const pageData = response.data?.Data || [];
-      allRecords.push(...pageData);
-      if (limit && allRecords.length >= limit) {
-        allRecords.splice(limit);
-        break;
-      }
-      if (pageData.length < maxPageSize) {
-        hasMore = false;
-      } else {
-        currentPage++;
-      }
-    }
-    return {
-      records: allRecords,
-      total: allRecords.length,
-      success: true
-    };
   }
   /**
    * Expands '*' fields to actual field names, excluding problematic fields for specific object types
@@ -2270,104 +2771,20 @@ var FireberryClient = class {
   }
   /**
    * Makes a raw API request to the Fireberry API
+   * @deprecated Use getTransport() or getMetadataTransport() for new code
+   * @internal This method is kept for backwards compatibility with API modules
    */
   async request(options) {
-    const {
-      method,
-      endpoint,
-      query: queryParams,
-      body,
-      headers: customHeaders,
-      signal
-    } = options;
-    let url = `${this.config.baseUrl}${endpoint}`;
-    if (queryParams && Object.keys(queryParams).length > 0) {
-      const params = new URLSearchParams();
-      for (const [key, value] of Object.entries(queryParams)) {
-        if (value !== void 0 && value !== null) {
-          params.set(key, String(value));
-        }
-      }
-      url += `?${params.toString()}`;
-    }
-    const headers = {
-      Accept: "application/json",
-      tokenid: this.config.apiKey,
-      ...customHeaders
-    };
-    if (body) {
-      headers["Content-Type"] = "application/json";
-    }
-    const fetchOptions = {
-      method,
-      headers,
-      signal
-    };
-    if (body) {
-      fetchOptions.body = JSON.stringify(body);
-    }
-    return this.executeWithRetry(url, fetchOptions);
-  }
-  /**
-   * Executes a fetch request with retry logic for 429 errors
-   */
-  async executeWithRetry(url, options, retryCount = 0) {
-    try {
-      const timeoutController = new AbortController();
-      const timeoutId = setTimeout(() => {
-        timeoutController.abort();
-      }, this.config.timeout);
-      const combinedSignal = options.signal ? this.combineSignals([options.signal, timeoutController.signal]) : timeoutController.signal;
-      const response = await fetch(url, {
-        ...options,
-        signal: combinedSignal
-      });
-      clearTimeout(timeoutId);
-      if (response.status === 429 && this.config.retryOn429) {
-        if (retryCount < this.config.maxRetries) {
-          await wait(this.config.retryDelay);
-          return this.executeWithRetry(url, options, retryCount + 1);
-        }
-        throw new FireberryError("Rate limit exceeded after max retries", {
-          code: "RATE_LIMITED" /* RATE_LIMITED */,
-          statusCode: 429,
-          context: { retryCount }
-        });
-      }
-      let body;
-      const contentType = response.headers.get("content-type");
-      if (contentType?.includes("application/json")) {
-        body = await response.json();
-      } else {
-        body = await response.text();
-      }
-      if (!response.ok) {
-        throw createErrorFromResponse(response, body);
-      }
-      return body;
-    } catch (error) {
-      if (error instanceof Error && error.name === "AbortError") {
-        throw createNetworkError(error);
-      }
-      if (error instanceof FireberryError) {
-        throw error;
-      }
-      throw createNetworkError(error);
-    }
-  }
-  /**
-   * Combines multiple abort signals into one
-   */
-  combineSignals(signals) {
-    const controller = new AbortController();
-    for (const signal of signals) {
-      if (signal.aborted) {
-        controller.abort();
-        break;
+    const transport = this.metadataTransport || this.transport;
+    if (transport instanceof HTTPTransport) {
+      return transport.request(options);
+    }
+    throw new FireberryError(
+      "Raw request() is not supported in SDK mode. Use specific methods like query(), createRecord(), etc.",
+      {
+        code: "INVALID_REQUEST" /* INVALID_REQUEST */
       }
-      signal.addEventListener("abort", () => controller.abort(), { once: true });
-    }
-    return controller.signal;
+    );
   }
 };
 
@@ -2852,6 +3269,14 @@ function getRelatedFieldInfo(fieldName) {
   return { ...parsed, ...resolved };
 }
 
+// src/types/transport.ts
+function isHTTPTransportConfig(config) {
+  return "apiKey" in config;
+}
+function isSDKTransportConfig(config) {
+  return "sdk" in config;
+}
+
 // src/constants/objectNames.ts
 var OBJECT_NAME_MAP = {
   1: "accountname",
@@ -2981,6 +3406,8 @@ exports.escapeQueryValue = escapeQueryValue;
 exports.expandRelatedFields = expandRelatedFields;
 exports.getObjectTypeFromReferenceField = getObjectTypeFromReferenceField;
 exports.getRelatedFieldInfo = getRelatedFieldInfo;
+exports.isHTTPTransportConfig = isHTTPTransportConfig;
+exports.isSDKTransportConfig = isSDKTransportConfig;
 exports.parseRelatedField = parseRelatedField;
 exports.resolveRelatedField = resolveRelatedField;
 exports.sanitizeQuery = sanitizeQuery;