fireberry-api-client 1.0.0-beta.1

package/dist/index.js

@@ -0,0 +1,1586 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/constants/excludedFields.ts
+var excludedFields_exports = {};
+__export(excludedFields_exports, {
+  EXCLUDED_FIELDS_FOR_STAR_QUERY: () => EXCLUDED_FIELDS_FOR_STAR_QUERY,
+  getExcludedFieldsForStarQuery: () => getExcludedFieldsForStarQuery,
+  isExcludedFromStarQuery: () => isExcludedFromStarQuery
+});
+function isExcludedFromStarQuery(objectType, fieldName) {
+  const objectTypeStr = String(objectType);
+  const excludedFields = EXCLUDED_FIELDS_FOR_STAR_QUERY[objectTypeStr];
+  return excludedFields ? excludedFields.includes(fieldName) : false;
+}
+function getExcludedFieldsForStarQuery(objectType) {
+  const objectTypeStr = String(objectType);
+  return EXCLUDED_FIELDS_FOR_STAR_QUERY[objectTypeStr] || [];
+}
+var EXCLUDED_FIELDS_FOR_STAR_QUERY;
+var init_excludedFields = __esm({
+  "src/constants/excludedFields.ts"() {
+    EXCLUDED_FIELDS_FOR_STAR_QUERY = {
+      "7": ["deletedon", "deletedby"],
+      // Note
+      "8": ["deletedon", "deletedby"],
+      // Competitor
+      "114": ["deletedon", "deletedby"],
+      // Calendar Resource
+      "115": ["deletedon", "deletedby"],
+      // Customer Journey
+      "116": ["deletedon", "deletedby"],
+      // Profile
+      "117": ["deletedon", "deletedby"]
+      // Landing Page
+    };
+  }
+});
+
+// src/errors.ts
+var FireberryErrorCode = /* @__PURE__ */ ((FireberryErrorCode2) => {
+  FireberryErrorCode2["UNKNOWN"] = "UNKNOWN";
+  FireberryErrorCode2["NETWORK_ERROR"] = "NETWORK_ERROR";
+  FireberryErrorCode2["TIMEOUT"] = "TIMEOUT";
+  FireberryErrorCode2["AUTHENTICATION_FAILED"] = "AUTHENTICATION_FAILED";
+  FireberryErrorCode2["AUTHORIZATION_FAILED"] = "AUTHORIZATION_FAILED";
+  FireberryErrorCode2["NOT_FOUND"] = "NOT_FOUND";
+  FireberryErrorCode2["RATE_LIMITED"] = "RATE_LIMITED";
+  FireberryErrorCode2["INVALID_REQUEST"] = "INVALID_REQUEST";
+  FireberryErrorCode2["SERVER_ERROR"] = "SERVER_ERROR";
+  FireberryErrorCode2["ABORTED"] = "ABORTED";
+  FireberryErrorCode2["INVALID_RESPONSE"] = "INVALID_RESPONSE";
+  return FireberryErrorCode2;
+})(FireberryErrorCode || {});
+var FireberryError = class _FireberryError extends Error {
+  /** Error code */
+  code;
+  /** HTTP status code if applicable */
+  statusCode;
+  /** Original error that caused this error */
+  cause;
+  /** Additional context data */
+  context;
+  constructor(message, options) {
+    super(message);
+    this.name = "FireberryError";
+    this.code = options.code;
+    this.statusCode = options.statusCode;
+    this.cause = options.cause;
+    this.context = options.context;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _FireberryError);
+    }
+  }
+  /**
+   * Creates a string representation of the error
+   */
+  toString() {
+    let str = `${this.name} [${this.code}]: ${this.message}`;
+    if (this.statusCode) {
+      str += ` (HTTP ${this.statusCode})`;
+    }
+    return str;
+  }
+  /**
+   * Converts the error to a plain object for logging/serialization
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      statusCode: this.statusCode,
+      context: this.context,
+      stack: this.stack
+    };
+  }
+};
+function createErrorFromResponse(response, body) {
+  const status = response.status;
+  let code;
+  let message;
+  switch (status) {
+    case 400:
+      code = "INVALID_REQUEST" /* INVALID_REQUEST */;
+      message = "Invalid request parameters";
+      break;
+    case 401:
+      code = "AUTHENTICATION_FAILED" /* AUTHENTICATION_FAILED */;
+      message = "Authentication failed - invalid or missing API key";
+      break;
+    case 403:
+      code = "AUTHORIZATION_FAILED" /* AUTHORIZATION_FAILED */;
+      message = "Authorization failed - insufficient permissions";
+      break;
+    case 404:
+      code = "NOT_FOUND" /* NOT_FOUND */;
+      message = "Resource not found";
+      break;
+    case 429:
+      code = "RATE_LIMITED" /* RATE_LIMITED */;
+      message = "Rate limit exceeded - too many requests";
+      break;
+    default:
+      if (status >= 500) {
+        code = "SERVER_ERROR" /* SERVER_ERROR */;
+        message = `Server error (${status})`;
+      } else {
+        code = "UNKNOWN" /* UNKNOWN */;
+        message = `HTTP error ${status}`;
+      }
+  }
+  if (body && typeof body === "object") {
+    const bodyObj = body;
+    if (typeof bodyObj.message === "string") {
+      message = bodyObj.message;
+    } else if (typeof bodyObj.error === "string") {
+      message = bodyObj.error;
+    }
+  }
+  return new FireberryError(message, {
+    code,
+    statusCode: status,
+    context: { body }
+  });
+}
+function createNetworkError(error) {
+  if (error.name === "AbortError") {
+    return new FireberryError("Request was aborted", {
+      code: "ABORTED" /* ABORTED */,
+      cause: error
+    });
+  }
+  if (error.name === "TimeoutError" || error.message.includes("timeout")) {
+    return new FireberryError("Request timed out", {
+      code: "TIMEOUT" /* TIMEOUT */,
+      cause: error
+    });
+  }
+  return new FireberryError(`Network error: ${error.message}`, {
+    code: "NETWORK_ERROR" /* NETWORK_ERROR */,
+    cause: 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/utils/queryBuilder.ts
+function escapeQueryValue(value) {
+  if (!value) {
+    return "";
+  }
+  let escaped = value.replace(/\\/g, "\\\\");
+  escaped = escaped.replace(/\(/g, "\\(");
+  escaped = escaped.replace(/\)/g, "\\)");
+  escaped = escaped.replace(/\bor\b/gi, "\\or");
+  escaped = escaped.replace(/\band\b/gi, "\\and");
+  return escaped;
+}
+function sanitizeQuery(query) {
+  if (!query) {
+    return "";
+  }
+  query = query.replace(
+    /\(\s*([a-zA-Z0-9_]+)\s+(is-null|is-not-null)\s*\)/g,
+    "($1 __SPECIAL_OPERATOR__$2)"
+  );
+  query = query.replace(
+    /\(\s*([a-zA-Z0-9_]+)\s+(start-with|not-start-with)\s+([^)]+)\s*\)/g,
+    "($1 __TEXT_OPERATOR__$2 $3)"
+  );
+  query = query.replace(
+    /\(\s*([a-zA-Z0-9_]+(?:field|Field|system|System)[0-9]*)\s+(?!__SPECIAL_OPERATOR__|__TEXT_OPERATOR__)([^()<>=!]+)\s*\)/g,
+    "($1 = $2)"
+  );
+  query = query.replace(
+    /\(\s*([a-zA-Z0-9_]+)\s+(?!__SPECIAL_OPERATOR__|__TEXT_OPERATOR__|<=|>=|!=|<|>|=\s)([^()<>]+)\s*\)/g,
+    "($1 = $2)"
+  );
+  query = query.replace(/__SPECIAL_OPERATOR__/g, "");
+  query = query.replace(/__TEXT_OPERATOR__/g, "");
+  query = query.replace(/\(\s*(?:<=|>=|!=|<|>|=)\s*\)/g, "");
+  query = query.replace(/\(\s*(?:start-with|not-start-with)\s*\)/gi, "");
+  query = query.replace(/\(\s*(?:and|or)\s*\)/gi, "");
+  query = query.replace(/\(\s*\)/g, "");
+  query = query.replace(/^\s*(and|or)\s*/gi, "");
+  query = query.replace(/\s*(and|or)\s*$/gi, "");
+  const nestedPattern = /\(\s*\(([^()]+)\)\s*\)/g;
+  while (nestedPattern.test(query)) {
+    query = query.replace(nestedPattern, "($1)");
+  }
+  query = query.replace(/\s+/g, " ");
+  return query.trim();
+}
+var QueryBuilder = class {
+  conditions = [];
+  joinOperators = [];
+  currentField = null;
+  selectedFields = [];
+  objectTypeId = null;
+  sortByField = null;
+  sortDirection = "desc";
+  limitValue = null;
+  pageNumber = 1;
+  showRealValueFlag = true;
+  client = null;
+  /**
+   * Creates a new QueryBuilder
+   * @param client - Optional FireberryClient for executing queries
+   */
+  constructor(client) {
+    this.client = client ?? null;
+  }
+  /**
+   * Sets the object type for the query
+   * @param objectType - Object type ID (e.g., '1' for Account)
+   */
+  objectType(objectType) {
+    this.objectTypeId = String(objectType);
+    return this;
+  }
+  /**
+   * Adds fields to select
+   * @param fields - Field names to select
+   */
+  select(...fields) {
+    this.selectedFields.push(...fields);
+    return this;
+  }
+  /**
+   * Starts a new WHERE condition
+   * @param field - Field name to filter on
+   */
+  where(field) {
+    this.currentField = field;
+    return this.createConditionBuilder();
+  }
+  /**
+   * Adds an AND logical operator
+   */
+  and() {
+    if (this.conditions.length > 0) {
+      this.joinOperators.push("and");
+    }
+    return this;
+  }
+  /**
+   * Adds an OR logical operator
+   */
+  or() {
+    if (this.conditions.length > 0) {
+      this.joinOperators.push("or");
+    }
+    return this;
+  }
+  /**
+   * Sets the sort field and direction
+   * @param field - Field to sort by
+   * @param direction - Sort direction ('asc' or 'desc')
+   */
+  sortBy(field, direction = "desc") {
+    this.sortByField = field;
+    this.sortDirection = direction;
+    return this;
+  }
+  /**
+   * Sets the maximum number of records to return
+   * @param count - Maximum record count
+   */
+  limit(count) {
+    this.limitValue = count;
+    return this;
+  }
+  /**
+   * Sets the page number for pagination
+   * @param page - Page number (1-based)
+   */
+  page(page) {
+    this.pageNumber = page;
+    return this;
+  }
+  /**
+   * Controls whether to show real values (labels) for dropdown fields
+   * @param show - Whether to show real values (default: true)
+   */
+  showRealValue(show) {
+    this.showRealValueFlag = show;
+    return this;
+  }
+  /**
+   * Builds the query string from conditions
+   * @returns The built query string
+   */
+  build() {
+    if (this.conditions.length === 0) {
+      return "";
+    }
+    const parts = [];
+    for (let i = 0; i < this.conditions.length; i++) {
+      const condition = this.conditions[i];
+      let conditionStr;
+      if (condition.operator === "is-null" || condition.operator === "is-not-null") {
+        conditionStr = `(${condition.field} ${condition.operator})`;
+      } else {
+        const escapedValue = escapeQueryValue(condition.value || "");
+        conditionStr = `(${condition.field} ${condition.operator} ${escapedValue})`;
+      }
+      parts.push(conditionStr);
+      if (i < this.joinOperators.length) {
+        parts.push(this.joinOperators[i]);
+      }
+    }
+    return parts.join(" ");
+  }
+  /**
+   * Returns the selected fields array
+   * Useful for inspecting the query configuration
+   */
+  getFields() {
+    return [...this.selectedFields];
+  }
+  /**
+   * Converts the query builder state to a payload compatible with @fireberry/sdk
+   *
+   * @returns Object with `fields` (comma-separated string) and `query` (filter string)
+   *
+   * @example
+   * ```typescript
+   * import FireberryClientSDK from '@fireberry/sdk/client';
+   * import { QueryBuilder } from 'fireberry-api-client';
+   *
+   * const sdk = new FireberryClientSDK();
+   * await sdk.initializeContext();
+   *
+   * const payload = new QueryBuilder()
+   *   .select('accountid', 'accountname')
+   *   .where('statuscode').equals('1')
+   *   .toSDKPayload();
+   *
+   * // Use with SDK
+   * const results = await sdk.api.query(1, payload);
+   * ```
+   */
+  toSDKPayload() {
+    const payload = {
+      fields: this.selectedFields.length > 0 ? this.selectedFields.join(",") : "*",
+      query: this.build()
+    };
+    if (this.limitValue !== null) {
+      payload.page_size = this.limitValue;
+    }
+    if (this.pageNumber > 1) {
+      payload.page_number = this.pageNumber;
+    }
+    return payload;
+  }
+  /**
+   * Executes the query (requires client to be set)
+   * @param signal - Optional AbortSignal for cancellation
+   * @returns Query results
+   */
+  async execute(signal) {
+    if (!this.client) {
+      throw new Error("QueryBuilder requires a client to execute queries. Pass a FireberryClient to the constructor.");
+    }
+    if (!this.objectTypeId) {
+      throw new Error("Object type is required. Use .objectType() before executing.");
+    }
+    const queryOptions = {
+      objectType: this.objectTypeId,
+      fields: this.selectedFields.length > 0 ? this.selectedFields : ["*"],
+      query: this.build(),
+      showRealValue: this.showRealValueFlag
+    };
+    if (this.sortByField) {
+      queryOptions.sortBy = this.sortByField;
+      queryOptions.sortType = this.sortDirection;
+    }
+    if (this.limitValue !== null) {
+      queryOptions.limit = this.limitValue;
+    }
+    if (this.pageNumber > 1) {
+      queryOptions.page = this.pageNumber;
+    }
+    if (signal) {
+      queryOptions.signal = signal;
+    }
+    return this.client.query(queryOptions);
+  }
+  /**
+   * Creates a condition builder for the current field
+   */
+  createConditionBuilder() {
+    const field = this.currentField;
+    return {
+      equals: (value) => {
+        this.addCondition(field, "=", String(value));
+        return this;
+      },
+      notEquals: (value) => {
+        this.addCondition(field, "!=", String(value));
+        return this;
+      },
+      lessThan: (value) => {
+        this.addCondition(field, "<", String(value));
+        return this;
+      },
+      greaterThan: (value) => {
+        this.addCondition(field, ">", String(value));
+        return this;
+      },
+      lessThanOrEqual: (value) => {
+        this.addCondition(field, "<=", String(value));
+        return this;
+      },
+      greaterThanOrEqual: (value) => {
+        this.addCondition(field, ">=", String(value));
+        return this;
+      },
+      contains: (value) => {
+        this.addCondition(field, "start-with", `%${value}`);
+        return this;
+      },
+      notContains: (value) => {
+        this.addCondition(field, "not-start-with", `%${value}`);
+        return this;
+      },
+      startsWith: (value) => {
+        this.addCondition(field, "start-with", value);
+        return this;
+      },
+      notStartsWith: (value) => {
+        this.addCondition(field, "not-start-with", value);
+        return this;
+      },
+      isNull: () => {
+        this.addCondition(field, "is-null");
+        return this;
+      },
+      isNotNull: () => {
+        this.addCondition(field, "is-not-null");
+        return this;
+      }
+    };
+  }
+  /**
+   * Adds a condition to the query
+   */
+  addCondition(field, operator, value) {
+    this.conditions.push({ field, operator, value });
+    this.currentField = null;
+  }
+};
+
+// src/constants/fieldTypes.ts
+var FIELD_TYPE_IDS = {
+  DROPDOWN: "b4919f2e-2996-48e4-a03c-ba39fb64386c",
+  LOOKUP: "a8fcdf65-91bc-46fd-82f6-1234758345a1",
+  EMAIL: "c713d2f7-8fa9-43c3-8062-f07486eaf567",
+  TEXT: "a1e7ed6f-5083-477b-b44c-9943a6181359",
+  URL: "c820d32f-44df-4c2a-9c1e-18734e864fd5",
+  LONG_TEXT: "80108f9d-1e75-40fa-9fa9-02be4ddc1da1",
+  DATETIME: "ce972d02-5013-46d4-9d1d-f09df1ac346a",
+  DATE: "83bf530c-e04c-462b-9ffc-a46f750fc072",
+  HTML: "ed2ad39d-32fc-4585-8f5b-2e93463f050a",
+  TELEPHONE: "3f62f67a-1cee-403a-bec6-aa02a9804edb",
+  NUMERIC: "6a34bfe3-fece-4da1-9136-a7b1e5ae3319"
+};
+var FIELD_TYPE_MAPPINGS = {
+  [FIELD_TYPE_IDS.DROPDOWN]: "Dropdown",
+  [FIELD_TYPE_IDS.EMAIL]: "Email",
+  [FIELD_TYPE_IDS.TEXT]: "Text",
+  [FIELD_TYPE_IDS.LOOKUP]: "Lookup",
+  [FIELD_TYPE_IDS.URL]: "URL",
+  [FIELD_TYPE_IDS.LONG_TEXT]: "Long Text",
+  [FIELD_TYPE_IDS.DATETIME]: "DateTime",
+  [FIELD_TYPE_IDS.DATE]: "Date",
+  [FIELD_TYPE_IDS.HTML]: "HTML",
+  [FIELD_TYPE_IDS.TELEPHONE]: "Telephone",
+  [FIELD_TYPE_IDS.NUMERIC]: "Number"
+};
+
+// src/api/metadata.ts
+var MetadataAPI = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Gets all available objects/entity types from Fireberry
+   *
+   * @param signal - Optional AbortSignal for cancellation
+   * @returns List of all objects
+   *
+   * @example
+   * ```typescript
+   * const result = await client.metadata.getObjects();
+   * console.log(result.objects); // [{ objectType: 1, name: 'Account', ... }, ...]
+   * ```
+   */
+  async getObjects(signal) {
+    const cached = this.client.getCached("objects");
+    if (cached) {
+      return cached;
+    }
+    const response = await this.client.request({
+      method: "GET",
+      endpoint: "/metadata/records",
+      signal
+    });
+    const result = {
+      objects: response.data || [],
+      total: response.data?.length || 0,
+      success: true
+    };
+    this.client.setCache("objects", result);
+    return result;
+  }
+  /**
+   * Gets all fields for a specific object type
+   *
+   * @param objectType - The object type ID (e.g., '1' for Account)
+   * @param signal - Optional AbortSignal for cancellation
+   * @returns List of fields with metadata
+   *
+   * @example
+   * ```typescript
+   * const result = await client.metadata.getFields('1');
+   * console.log(result.fields); // [{ fieldName: 'accountid', label: 'Account ID', ... }, ...]
+   * ```
+   */
+  async getFields(objectType, signal) {
+    const objectTypeStr = String(objectType);
+    const cached = this.client.getCached("fields", objectTypeStr);
+    if (cached) {
+      return cached;
+    }
+    const response = await this.client.request({
+      method: "GET",
+      endpoint: `/metadata/records/${objectTypeStr}/fields`,
+      signal
+    });
+    const fields = (response.data || []).map((field) => ({
+      ...field,
+      fieldType: FIELD_TYPE_MAPPINGS[field.systemFieldTypeId] || field.systemFieldTypeId
+    }));
+    const result = {
+      objectTypeId: objectTypeStr,
+      fields,
+      total: fields.length,
+      success: true
+    };
+    this.client.setCache("fields", objectTypeStr, result);
+    return result;
+  }
+  /**
+   * Gets all possible values for a dropdown field
+   *
+   * @param objectType - The object type ID
+   * @param fieldName - The field name
+   * @param signal - Optional AbortSignal for cancellation
+   * @returns List of dropdown values
+   *
+   * @example
+   * ```typescript
+   * const result = await client.metadata.getFieldValues('1', 'statuscode');
+   * console.log(result.values); // [{ name: 'Active', value: '1' }, { name: 'Inactive', value: '2' }]
+   * ```
+   */
+  async getFieldValues(objectType, fieldName, signal) {
+    const objectTypeStr = String(objectType);
+    const cached = this.client.getCached(
+      "fieldValues",
+      objectTypeStr,
+      fieldName
+    );
+    if (cached) {
+      return cached;
+    }
+    const response = await this.client.request({
+      method: "GET",
+      endpoint: `/metadata/records/${objectTypeStr}/fields/${fieldName}/values`,
+      signal
+    });
+    const result = {
+      objectTypeId: objectTypeStr,
+      fieldName,
+      values: response.data?.values || [],
+      total: response.data?.values?.length || 0,
+      success: true
+    };
+    this.client.setCache("fieldValues", objectTypeStr, fieldName, result);
+    return result;
+  }
+};
+
+// src/constants/objectIds.ts
+var OBJECT_ID_MAP = {
+  1: "accountid",
+  2: "contactid",
+  3: "leadid",
+  4: "opportunityid",
+  5: "casesid",
+  6: "activityid",
+  7: "noteid",
+  8: "competitorid",
+  9: "crmuserid",
+  10: "taskid",
+  13: "crmorderid",
+  14: "productid",
+  17: "crmorderitemid",
+  20: "emailtemplateid",
+  23: "businessunitid",
+  27: "printtemplateid",
+  28: "contractid",
+  33: "accountproductid",
+  46: "projectid",
+  67: "campaignid",
+  76: "articleid",
+  86: "invoiceid",
+  101: "attendanceclockid",
+  102: "activitylogid",
+  104: "conversationid",
+  114: "calendarresourceid"
+};
+function getObjectIdFieldName(objectTypeId) {
+  const objectTypeNum = typeof objectTypeId === "string" ? parseInt(objectTypeId, 10) : objectTypeId;
+  if (OBJECT_ID_MAP[objectTypeNum]) {
+    return OBJECT_ID_MAP[objectTypeNum];
+  }
+  if (objectTypeNum >= 1e3) {
+    return `customobject${objectTypeNum}id`;
+  }
+  return "id";
+}
+
+// src/api/records.ts
+var RecordsAPI = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Creates a new record in Fireberry
+   *
+   * @param objectType - The object type ID (e.g., '1' for Account)
+   * @param data - Record data to create
+   * @param options - Optional settings
+   * @returns Created record data
+   *
+   * @example
+   * ```typescript
+   * const result = await client.records.create('1', {
+   *   accountname: 'New Account',
+   *   emailaddress1: 'contact@example.com',
+   * });
+   * ```
+   */
+  async create(objectType, data, options) {
+    const response = await this.client.request({
+      method: "POST",
+      endpoint: `/api/v2/record/${objectType}`,
+      body: data,
+      signal: options?.signal
+    });
+    return response.record;
+  }
+  /**
+   * Updates an existing record in Fireberry
+   *
+   * @param objectType - The object type ID
+   * @param recordId - The record ID to update
+   * @param data - Record data to update
+   * @param options - Optional settings
+   * @returns Updated record data
+   *
+   * @example
+   * ```typescript
+   * const result = await client.records.update('1', 'abc123', {
+   *   accountname: 'Updated Account Name',
+   * });
+   * ```
+   */
+  async update(objectType, recordId, data, options) {
+    const response = await this.client.request({
+      method: "PUT",
+      endpoint: `/api/v2/record/${objectType}/${recordId}`,
+      body: data,
+      signal: options?.signal
+    });
+    return response.record;
+  }
+  /**
+   * Deletes a record from Fireberry
+   *
+   * @param objectType - The object type ID
+   * @param recordId - The record ID to delete
+   * @param options - Optional settings
+   * @returns Success status
+   *
+   * @example
+   * ```typescript
+   * await client.records.delete('1', 'abc123');
+   * ```
+   */
+  async delete(objectType, recordId, options) {
+    await this.client.request({
+      method: "DELETE",
+      endpoint: `/api/record/${objectType}/${recordId}`,
+      signal: options?.signal
+    });
+    return {
+      success: true,
+      id: recordId
+    };
+  }
+  /**
+   * Upserts a record (creates if not exists, updates if exists)
+   *
+   * @param objectType - The object type ID
+   * @param keyFields - Fields to use for matching existing records
+   * @param data - Record data to upsert
+   * @param options - Optional settings
+   * @returns Upsert result with operation type and record data
+   *
+   * @example
+   * ```typescript
+   * const result = await client.records.upsert('1', ['emailaddress1'], {
+   *   accountname: 'Acme Corp',
+   *   emailaddress1: 'contact@acme.com',
+   * });
+   * console.log(result.operationType); // 'create' or 'update'
+   * ```
+   */
+  async upsert(objectType, keyFields, data, options) {
+    const objectTypeStr = String(objectType);
+    const upsertKeyValues = {};
+    for (const key of keyFields) {
+      if (!(key in data)) {
+        throw new Error(`Missing value for upsert key field: ${key}`);
+      }
+      upsertKeyValues[key] = data[key];
+    }
+    const queryConditions = keyFields.map((key) => `(${key} = ${data[key]})`);
+    const queryString = queryConditions.join(" and ");
+    const queryResult = await this.client.query({
+      objectType: objectTypeStr,
+      fields: "*",
+      query: queryString,
+      limit: 1,
+      showRealValue: true,
+      signal: options?.signal
+    });
+    const existingRecords = queryResult.records;
+    if (existingRecords.length > 0) {
+      const existingRecord = existingRecords[0];
+      const idFieldName = getObjectIdFieldName(objectTypeStr);
+      const recordId = String(existingRecord[idFieldName]);
+      const updatedRecord = await this.update(objectTypeStr, recordId, data, options);
+      return {
+        success: true,
+        operationType: "update",
+        upsertKeys: keyFields,
+        upsertKeyValues,
+        oldRecord: existingRecord,
+        newRecord: updatedRecord
+      };
+    } else {
+      const createdRecord = await this.create(objectTypeStr, data, options);
+      return {
+        success: true,
+        operationType: "create",
+        upsertKeys: keyFields,
+        upsertKeyValues,
+        oldRecord: null,
+        newRecord: createdRecord
+      };
+    }
+  }
+};
+
+// src/api/batch.ts
+var BATCH_SIZE = 20;
+var BatchAPI = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Creates multiple records in batch
+   * Automatically chunks into batches of 20 records
+   *
+   * @param objectType - The object type ID
+   * @param records - Array of records to create
+   * @param options - Optional settings
+   * @returns Batch result with all created records
+   *
+   * @example
+   * ```typescript
+   * const result = await client.batch.create('1', [
+   *   { accountname: 'Account 1' },
+   *   { accountname: 'Account 2' },
+   * ]);
+   * console.log(result.count); // 2
+   * ```
+   */
+  async create(objectType, records, options) {
+    const objectTypeStr = String(objectType);
+    const batches = chunkArray(records, BATCH_SIZE);
+    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);
+        }
+      }
+    }
+    return {
+      success: true,
+      data: allResponses,
+      count: allResponses.length
+    };
+  }
+  /**
+   * Updates multiple records in batch
+   * Automatically chunks into batches of 20 records
+   *
+   * @param objectType - The object type ID
+   * @param records - Array of records with ID and data to update
+   * @param options - Optional settings
+   * @returns Batch result with all updated records
+   *
+   * @example
+   * ```typescript
+   * const result = await client.batch.update('1', [
+   *   { id: 'abc123', record: { accountname: 'Updated 1' } },
+   *   { id: 'def456', record: { accountname: 'Updated 2' } },
+   * ]);
+   * ```
+   */
+  async update(objectType, records, options) {
+    const objectTypeStr = String(objectType);
+    const batches = chunkArray(records, BATCH_SIZE);
+    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);
+        }
+      }
+    }
+    return {
+      success: true,
+      data: allResponses,
+      count: allResponses.length
+    };
+  }
+  /**
+   * Deletes multiple records in batch
+   * Automatically chunks into batches of 20 records
+   *
+   * @param objectType - The object type ID
+   * @param recordIds - Array of record IDs to delete
+   * @param options - Optional settings
+   * @returns Batch delete result with deleted IDs
+   *
+   * @example
+   * ```typescript
+   * const result = await client.batch.delete('1', ['abc123', 'def456']);
+   * console.log(result.ids); // ['abc123', 'def456']
+   * ```
+   */
+  async delete(objectType, recordIds, options) {
+    const objectTypeStr = String(objectType);
+    const batches = chunkArray(recordIds, BATCH_SIZE);
+    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);
+    }
+    return {
+      success: true,
+      ids: allDeletedIds,
+      count: allDeletedIds.length
+    };
+  }
+};
+
+// src/api/fields.ts
+var FIELD_TYPE_ENDPOINTS = {
+  text: "text",
+  email: "email",
+  url: "url",
+  phone: "phone",
+  number: "number",
+  textarea: "textarea",
+  html: "html",
+  date: "date",
+  datetime: "datetime",
+  lookup: "lookup",
+  summary: "summary",
+  formula: "formula",
+  picklist: "picklist"
+};
+var FieldsAPI = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Creates a new custom field in a Fireberry object
+   *
+   * @param objectType - The object type ID
+   * @param options - Field creation options
+   * @returns Created field result
+   *
+   * @example
+   * ```typescript
+   * // Create a text field
+   * const result = await client.fields.create('1', {
+   *   type: 'text',
+   *   fieldName: 'pcf_custom_field',
+   *   label: 'Custom Field',
+   *   maxLength: 100,
+   * });
+   *
+   * // Create a picklist field
+   * const result = await client.fields.create('1', {
+   *   type: 'picklist',
+   *   fieldName: 'pcf_status',
+   *   label: 'Status',
+   *   values: [
+   *     { name: 'Active', value: '1' },
+   *     { name: 'Inactive', value: '2' },
+   *   ],
+   * });
+   *
+   * // Create a lookup field
+   * const result = await client.fields.create('2', {
+   *   type: 'lookup',
+   *   fieldName: 'pcf_related_account',
+   *   label: 'Related Account',
+   *   relatedObjectId: '1',
+   * });
+   * ```
+   */
+  async create(objectType, options) {
+    const objectTypeStr = String(objectType);
+    const { type, fieldName, label, defaultValue, follow, autoComplete } = options;
+    const fieldData = {
+      fieldName,
+      label
+    };
+    if (defaultValue !== void 0) {
+      fieldData.defaultValue = defaultValue;
+    }
+    if (follow !== void 0) {
+      fieldData.follow = follow;
+    }
+    if (autoComplete !== void 0 && ["text", "email", "url", "phone", "number"].includes(type)) {
+      fieldData.autoComplete = autoComplete;
+    }
+    switch (type) {
+      case "text":
+      case "email":
+      case "url": {
+        const opts = options;
+        if (opts.maxLength !== void 0 && opts.maxLength > 0) {
+          fieldData.maxLength = opts.maxLength;
+        }
+        break;
+      }
+      case "number": {
+        const opts = options;
+        if (opts.precision !== void 0) {
+          fieldData.precision = opts.precision;
+        }
+        break;
+      }
+      case "lookup": {
+        const opts = options;
+        fieldData.relatedObjectId = opts.relatedObjectId;
+        break;
+      }
+      case "picklist": {
+        const opts = options;
+        fieldData.values = opts.values;
+        break;
+      }
+      case "summary": {
+        const opts = options;
+        fieldData.summaryType = opts.summaryType;
+        fieldData.relatedObjectId = opts.relatedObjectId;
+        if (opts.summaryField) {
+          fieldData.summaryField = opts.summaryField;
+        }
+        break;
+      }
+      case "formula": {
+        const opts = options;
+        fieldData.formula = opts.formula;
+        fieldData.fieldType = opts.formulaFieldType;
+        if (opts.formulaFieldType === "number" && opts.formulaPrecision !== void 0) {
+          fieldData.precision = opts.formulaPrecision;
+        }
+        break;
+      }
+    }
+    const endpoint = FIELD_TYPE_ENDPOINTS[type];
+    if (!endpoint) {
+      throw new Error(`Unsupported field type: ${type}`);
+    }
+    const response = await this.client.request({
+      method: "POST",
+      endpoint: `/api/v2/system-field/${objectTypeStr}/${endpoint}`,
+      body: fieldData
+    });
+    return {
+      objectTypeId: objectTypeStr,
+      fieldType: type,
+      fieldData: response,
+      success: true
+    };
+  }
+};
+
+// src/api/files.ts
+var FilesAPI = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Uploads a file attachment to a Fireberry record
+   *
+   * @param objectType - The object type ID
+   * @param recordId - The record ID to attach the file to
+   * @param options - File upload options
+   * @param signal - Optional AbortSignal for cancellation
+   * @returns Upload result
+   *
+   * @example
+   * ```typescript
+   * import { readFileSync } from 'fs';
+   *
+   * const fileBuffer = readFileSync('document.pdf');
+   * const result = await client.files.upload('1', 'abc123', {
+   *   buffer: fileBuffer,
+   *   filename: 'document.pdf',
+   *   mimeType: 'application/pdf',
+   * });
+   * ```
+   */
+  async upload(objectType, recordId, options, signal) {
+    const objectTypeStr = String(objectType);
+    const { buffer, filename, mimeType } = options;
+    const config = this.client.getConfig();
+    const url = `${config.baseUrl}/api/v2/record/${objectTypeStr}/${recordId}/files`;
+    const boundary = `----FormBoundary${Date.now()}`;
+    const formParts = [];
+    const fileHeader = [
+      `--${boundary}`,
+      `Content-Disposition: form-data; name="file"; filename="${filename}"`,
+      `Content-Type: ${mimeType}`,
+      "",
+      ""
+    ].join("\r\n");
+    formParts.push(Buffer.from(fileHeader));
+    formParts.push(buffer);
+    formParts.push(Buffer.from(`\r
+--${boundary}--\r
+`));
+    const body = Buffer.concat(formParts);
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          Accept: "application/json",
+          "Content-Type": `multipart/form-data; boundary=${boundary}`,
+          tokenid: config.apiKey
+        },
+        body,
+        signal
+      });
+      if (!response.ok) {
+        throw new FireberryError(`File upload failed: ${response.statusText}`, {
+          code: "INVALID_REQUEST" /* INVALID_REQUEST */,
+          statusCode: response.status
+        });
+      }
+      const responseData = await response.json();
+      return {
+        success: true,
+        objectType: objectTypeStr,
+        recordId,
+        fileName: filename,
+        mimeType,
+        fileSize: buffer.length,
+        response: responseData
+      };
+    } catch (error) {
+      if (error instanceof FireberryError) {
+        throw error;
+      }
+      throw new FireberryError(`File upload failed: ${error.message}`, {
+        code: "NETWORK_ERROR" /* NETWORK_ERROR */,
+        cause: error
+      });
+    }
+  }
+};
+
+// src/client.ts
+var FireberryClient = class {
+  config;
+  cacheStore;
+  /** Metadata API operations */
+  metadata;
+  /** Records CRUD operations */
+  records;
+  /** Batch operations */
+  batch;
+  /** Field management operations */
+  fields;
+  /** File operations */
+  files;
+  /**
+   * Creates a new FireberryClient instance
+   */
+  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,
+      cacheMetadata: config.cacheMetadata || false,
+      cacheTTL: config.cacheTTL || 3e5
+      // 5 minutes default
+    };
+    this.cacheStore = {
+      fields: /* @__PURE__ */ new Map(),
+      fieldValues: /* @__PURE__ */ new Map()
+    };
+    this.metadata = new MetadataAPI(this);
+    this.records = new RecordsAPI(this);
+    this.batch = new BatchAPI(this);
+    this.fields = new FieldsAPI(this);
+    this.files = new FilesAPI(this);
+  }
+  /**
+   * Gets the client configuration
+   */
+  getConfig() {
+    return this.config;
+  }
+  /**
+   * Cache control methods
+   */
+  cache = {
+    clear: () => {
+      this.cacheStore.objects = void 0;
+      this.cacheStore.fields.clear();
+      this.cacheStore.fieldValues.clear();
+    },
+    clearObjects: () => {
+      this.cacheStore.objects = void 0;
+    },
+    clearFields: (objectType) => {
+      this.cacheStore.fields.delete(objectType);
+    },
+    clearFieldValues: (objectType, fieldName) => {
+      if (fieldName) {
+        this.cacheStore.fieldValues.delete(`${objectType}:${fieldName}`);
+      } else {
+        for (const key of this.cacheStore.fieldValues.keys()) {
+          if (key.startsWith(`${objectType}:`)) {
+            this.cacheStore.fieldValues.delete(key);
+          }
+        }
+      }
+    }
+  };
+  getCached(type, objectType, fieldName) {
+    if (!this.config.cacheMetadata) {
+      return void 0;
+    }
+    const now = Date.now();
+    if (type === "objects") {
+      const cached = this.cacheStore.objects;
+      if (cached && now - cached.timestamp < this.config.cacheTTL) {
+        return cached.data;
+      }
+    } else if (type === "fields" && objectType) {
+      const cached = this.cacheStore.fields.get(objectType);
+      if (cached && now - cached.timestamp < this.config.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) {
+        return cached.data;
+      }
+    }
+    return void 0;
+  }
+  setCache(type, objectTypeOrData, fieldNameOrData, data) {
+    if (!this.config.cacheMetadata) {
+      return;
+    }
+    const now = Date.now();
+    if (type === "objects") {
+      this.cacheStore.objects = { data: objectTypeOrData, timestamp: now };
+    } else if (type === "fields" && typeof objectTypeOrData === "string") {
+      this.cacheStore.fields.set(objectTypeOrData, {
+        data: fieldNameOrData,
+        timestamp: now
+      });
+    } else if (type === "fieldValues" && typeof objectTypeOrData === "string" && typeof fieldNameOrData === "string") {
+      const key = `${objectTypeOrData}:${fieldNameOrData}`;
+      this.cacheStore.fieldValues.set(key, { data, timestamp: now });
+    }
+  }
+  /**
+   * Creates a new QueryBuilder instance
+   */
+  queryBuilder() {
+    return new QueryBuilder(this);
+  }
+  /**
+   * Executes a query against the Fireberry API
+   */
+  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 (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
+    });
+    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
+   */
+  async expandStarFields(objectType, signal) {
+    const { getExcludedFieldsForStarQuery: getExcludedFieldsForStarQuery2 } = await Promise.resolve().then(() => (init_excludedFields(), excludedFields_exports));
+    const excludedFields = getExcludedFieldsForStarQuery2(objectType);
+    if (excludedFields.length === 0) {
+      return "*";
+    }
+    const fieldsResult = await this.metadata.getFields(objectType, signal);
+    const allFieldNames = fieldsResult.fields.map((f) => f.fieldName);
+    const filteredFields = allFieldNames.filter(
+      (fieldName) => !excludedFields.includes(fieldName)
+    );
+    return filteredFields.join(",");
+  }
+  /**
+   * Makes a raw API request to the Fireberry API
+   */
+  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;
+      }
+      signal.addEventListener("abort", () => controller.abort(), { once: true });
+    }
+    return controller.signal;
+  }
+};
+
+// src/constants/objectNames.ts
+var OBJECT_NAME_MAP = {
+  1: "accountname",
+  // Account
+  2: "fullname",
+  // Contact
+  3: "fullname",
+  // Lead
+  4: "name",
+  // Opportunity
+  5: "title",
+  // Case
+  6: "subject",
+  // Activity
+  7: "subject",
+  // Note
+  8: "name",
+  // Competitor
+  9: "fullname",
+  // CRM User
+  10: "subject",
+  // Task
+  13: "name",
+  // CRM Order
+  14: "productname",
+  // Product
+  17: "productname",
+  // CRM Order Item
+  20: "name",
+  // Email Template
+  23: "name",
+  // Business Unit
+  27: "name",
+  // Print Template
+  28: "name",
+  // Contract
+  33: "productname",
+  // Account Product
+  46: "name",
+  // Project
+  67: "name",
+  // Campaign
+  76: "title",
+  // Article
+  86: "name",
+  // Invoice
+  101: "name",
+  // Attendance Clock
+  102: "subject",
+  // Activity Log
+  104: "subject",
+  // Conversation
+  114: "name"
+  // Calendar Resource
+};
+
+// src/constants/index.ts
+init_excludedFields();
+
+export { EXCLUDED_FIELDS_FOR_STAR_QUERY, FIELD_TYPE_IDS, FIELD_TYPE_MAPPINGS, FireberryClient, FireberryError, FireberryErrorCode, OBJECT_ID_MAP, OBJECT_NAME_MAP, QueryBuilder, escapeQueryValue, sanitizeQuery };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map