@classytic/arc 1.0.0

package/dist/utils/index.js

@@ -0,0 +1,905 @@
+// src/utils/errors.ts
+var ArcError = class extends Error {
+  name;
+  code;
+  statusCode;
+  details;
+  cause;
+  timestamp;
+  requestId;
+  constructor(message, options = {}) {
+    super(message);
+    this.name = "ArcError";
+    this.code = options.code ?? "ARC_ERROR";
+    this.statusCode = options.statusCode ?? 500;
+    this.details = options.details;
+    this.cause = options.cause;
+    this.timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    this.requestId = options.requestId;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+  /**
+   * Set request ID (typically from request context)
+   */
+  withRequestId(requestId) {
+    this.requestId = requestId;
+    return this;
+  }
+  /**
+   * Convert to JSON response
+   */
+  toJSON() {
+    return {
+      success: false,
+      error: this.message,
+      code: this.code,
+      timestamp: this.timestamp,
+      ...this.requestId && { requestId: this.requestId },
+      ...this.details && { details: this.details }
+    };
+  }
+};
+var NotFoundError = class extends ArcError {
+  constructor(resource, identifier) {
+    const message = identifier ? `${resource} with identifier '${identifier}' not found` : `${resource} not found`;
+    super(message, {
+      code: "NOT_FOUND",
+      statusCode: 404,
+      details: { resource, identifier }
+    });
+    this.name = "NotFoundError";
+  }
+};
+var ValidationError = class extends ArcError {
+  errors;
+  constructor(message, errors = []) {
+    super(message, {
+      code: "VALIDATION_ERROR",
+      statusCode: 400,
+      details: { errors }
+    });
+    this.name = "ValidationError";
+    this.errors = errors;
+  }
+};
+var UnauthorizedError = class extends ArcError {
+  constructor(message = "Authentication required") {
+    super(message, {
+      code: "UNAUTHORIZED",
+      statusCode: 401
+    });
+    this.name = "UnauthorizedError";
+  }
+};
+var ForbiddenError = class extends ArcError {
+  constructor(message = "Access denied") {
+    super(message, {
+      code: "FORBIDDEN",
+      statusCode: 403
+    });
+    this.name = "ForbiddenError";
+  }
+};
+var ConflictError = class extends ArcError {
+  constructor(message, field) {
+    super(message, {
+      code: "CONFLICT",
+      statusCode: 409,
+      details: field ? { field } : void 0
+    });
+    this.name = "ConflictError";
+  }
+};
+var OrgRequiredError = class extends ArcError {
+  organizations;
+  constructor(message, organizations) {
+    super(message, {
+      code: "ORG_SELECTION_REQUIRED",
+      statusCode: 403,
+      details: organizations ? { organizations } : void 0
+    });
+    this.name = "OrgRequiredError";
+    this.organizations = organizations;
+  }
+};
+var OrgAccessDeniedError = class extends ArcError {
+  constructor(orgId) {
+    super("Organization access denied", {
+      code: "ORG_ACCESS_DENIED",
+      statusCode: 403,
+      details: orgId ? { organizationId: orgId } : void 0
+    });
+    this.name = "OrgAccessDeniedError";
+  }
+};
+var RateLimitError = class extends ArcError {
+  retryAfter;
+  constructor(message = "Too many requests", retryAfter) {
+    super(message, {
+      code: "RATE_LIMITED",
+      statusCode: 429,
+      details: retryAfter ? { retryAfter } : void 0
+    });
+    this.name = "RateLimitError";
+    this.retryAfter = retryAfter;
+  }
+};
+var ServiceUnavailableError = class extends ArcError {
+  constructor(message = "Service temporarily unavailable") {
+    super(message, {
+      code: "SERVICE_UNAVAILABLE",
+      statusCode: 503
+    });
+    this.name = "ServiceUnavailableError";
+  }
+};
+function createError(statusCode, message, details) {
+  const codes = {
+    400: "BAD_REQUEST",
+    401: "UNAUTHORIZED",
+    403: "FORBIDDEN",
+    404: "NOT_FOUND",
+    409: "CONFLICT",
+    429: "RATE_LIMITED",
+    500: "INTERNAL_ERROR",
+    503: "SERVICE_UNAVAILABLE"
+  };
+  return new ArcError(message, {
+    code: codes[statusCode] ?? "ERROR",
+    statusCode,
+    details
+  });
+}
+function isArcError(error) {
+  return error instanceof ArcError;
+}
+
+// src/utils/responseSchemas.ts
+var successResponseSchema = {
+  type: "object",
+  properties: {
+    success: { type: "boolean", example: true }
+  },
+  required: ["success"]
+};
+var errorResponseSchema = {
+  type: "object",
+  properties: {
+    success: { type: "boolean", example: false },
+    error: { type: "string", description: "Error message" },
+    code: { type: "string", description: "Error code" },
+    message: { type: "string", description: "Detailed message" }
+  },
+  required: ["success", "error"]
+};
+var paginationSchema = {
+  type: "object",
+  properties: {
+    page: { type: "integer", example: 1 },
+    limit: { type: "integer", example: 20 },
+    total: { type: "integer", example: 100 },
+    totalPages: { type: "integer", example: 5 },
+    hasNextPage: { type: "boolean", example: true },
+    hasPrevPage: { type: "boolean", example: false }
+  },
+  required: ["page", "limit", "total", "totalPages", "hasNextPage", "hasPrevPage"]
+};
+function wrapResponse(dataSchema) {
+  return {
+    type: "object",
+    properties: {
+      success: { type: "boolean", example: true },
+      data: dataSchema
+    },
+    required: ["success", "data"]
+  };
+}
+function listResponse(itemSchema) {
+  return {
+    type: "object",
+    properties: {
+      success: { type: "boolean", example: true },
+      data: {
+        type: "array",
+        items: itemSchema
+      },
+      pagination: paginationSchema
+    },
+    required: ["success", "data"]
+  };
+}
+function itemResponse(itemSchema) {
+  return wrapResponse(itemSchema);
+}
+function mutationResponse(itemSchema) {
+  return {
+    type: "object",
+    properties: {
+      success: { type: "boolean", example: true },
+      data: itemSchema,
+      message: { type: "string", example: "Created successfully" }
+    },
+    required: ["success", "data"]
+  };
+}
+function deleteResponse() {
+  return {
+    type: "object",
+    properties: {
+      success: { type: "boolean", example: true },
+      message: { type: "string", example: "Deleted successfully" }
+    },
+    required: ["success"]
+  };
+}
+var responses = {
+  200: (schema) => ({
+    description: "Successful response",
+    content: {
+      "application/json": { schema }
+    }
+  }),
+  201: (schema) => ({
+    description: "Created successfully",
+    content: {
+      "application/json": { schema: mutationResponse(schema) }
+    }
+  }),
+  400: {
+    description: "Bad Request",
+    content: {
+      "application/json": {
+        schema: {
+          ...errorResponseSchema,
+          properties: {
+            ...errorResponseSchema.properties,
+            code: { type: "string", example: "VALIDATION_ERROR" },
+            details: {
+              type: "object",
+              properties: {
+                errors: {
+                  type: "array",
+                  items: {
+                    type: "object",
+                    properties: {
+                      field: { type: "string" },
+                      message: { type: "string" }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  },
+  401: {
+    description: "Unauthorized",
+    content: {
+      "application/json": {
+        schema: {
+          ...errorResponseSchema,
+          properties: {
+            ...errorResponseSchema.properties,
+            code: { type: "string", example: "UNAUTHORIZED" }
+          }
+        }
+      }
+    }
+  },
+  403: {
+    description: "Forbidden",
+    content: {
+      "application/json": {
+        schema: {
+          ...errorResponseSchema,
+          properties: {
+            ...errorResponseSchema.properties,
+            code: { type: "string", example: "FORBIDDEN" }
+          }
+        }
+      }
+    }
+  },
+  404: {
+    description: "Not Found",
+    content: {
+      "application/json": {
+        schema: {
+          ...errorResponseSchema,
+          properties: {
+            ...errorResponseSchema.properties,
+            code: { type: "string", example: "NOT_FOUND" }
+          }
+        }
+      }
+    }
+  },
+  409: {
+    description: "Conflict",
+    content: {
+      "application/json": {
+        schema: {
+          ...errorResponseSchema,
+          properties: {
+            ...errorResponseSchema.properties,
+            code: { type: "string", example: "CONFLICT" }
+          }
+        }
+      }
+    }
+  },
+  500: {
+    description: "Internal Server Error",
+    content: {
+      "application/json": {
+        schema: {
+          ...errorResponseSchema,
+          properties: {
+            ...errorResponseSchema.properties,
+            code: { type: "string", example: "INTERNAL_ERROR" }
+          }
+        }
+      }
+    }
+  }
+};
+var queryParams = {
+  pagination: {
+    page: {
+      type: "integer",
+      minimum: 1,
+      default: 1,
+      description: "Page number"
+    },
+    limit: {
+      type: "integer",
+      minimum: 1,
+      maximum: 100,
+      default: 20,
+      description: "Items per page"
+    }
+  },
+  sorting: {
+    sort: {
+      type: "string",
+      description: "Sort field (prefix with - for descending)",
+      example: "-createdAt"
+    }
+  },
+  filtering: {
+    select: {
+      type: "string",
+      description: "Fields to include (space-separated)",
+      example: "name email createdAt"
+    },
+    populate: {
+      type: "string",
+      description: "Relations to populate (comma-separated)",
+      example: "author,category"
+    }
+  }
+};
+function getListQueryParams() {
+  return {
+    type: "object",
+    properties: {
+      ...queryParams.pagination,
+      ...queryParams.sorting,
+      ...queryParams.filtering
+    }
+  };
+}
+
+// src/utils/stateMachine.ts
+function createStateMachine(name, transitions = {}, options = {}) {
+  const normalized = /* @__PURE__ */ new Map();
+  const history = options.trackHistory ? [] : void 0;
+  Object.entries(transitions).forEach(([action, allowed]) => {
+    if (Array.isArray(allowed)) {
+      normalized.set(action, { from: new Set(allowed) });
+    } else if (typeof allowed === "object" && "from" in allowed) {
+      normalized.set(action, {
+        from: new Set(Array.isArray(allowed.from) ? allowed.from : [allowed.from]),
+        to: allowed.to,
+        guard: allowed.guard,
+        before: allowed.before,
+        after: allowed.after
+      });
+    }
+  });
+  const canSync = (action, status) => {
+    const transition = normalized.get(action);
+    if (!transition || !status) return false;
+    return transition.from.has(status);
+  };
+  const assert = (action, status, errorFactory, message) => {
+    if (canSync(action, status)) return;
+    const errorMessage = message || `${name} cannot '${action}' when status is '${status || "unknown"}'`;
+    if (typeof errorFactory === "function") {
+      throw errorFactory(errorMessage);
+    }
+    throw new Error(errorMessage);
+  };
+  const recordTransition = (from, to, action, metadata) => {
+    if (history) {
+      history.push({
+        from,
+        to,
+        action,
+        timestamp: /* @__PURE__ */ new Date(),
+        metadata
+      });
+    }
+  };
+  const getHistory = () => {
+    return history ? [...history] : [];
+  };
+  const clearHistory = () => {
+    if (history) {
+      history.length = 0;
+    }
+  };
+  const getAvailableActions = (status) => {
+    const actions = [];
+    for (const [action, transition] of normalized.entries()) {
+      if (transition.from.has(status)) {
+        actions.push(action);
+      }
+    }
+    return actions;
+  };
+  return {
+    can: canSync,
+    // Return sync version for backward compatibility
+    assert,
+    recordTransition,
+    getHistory,
+    clearHistory,
+    getAvailableActions
+  };
+}
+
+// src/utils/circuitBreaker.ts
+var CircuitState = /* @__PURE__ */ ((CircuitState2) => {
+  CircuitState2["CLOSED"] = "CLOSED";
+  CircuitState2["OPEN"] = "OPEN";
+  CircuitState2["HALF_OPEN"] = "HALF_OPEN";
+  return CircuitState2;
+})(CircuitState || {});
+var CircuitBreakerError = class extends Error {
+  constructor(message, state) {
+    super(message);
+    this.state = state;
+    this.name = "CircuitBreakerError";
+  }
+};
+var CircuitBreaker = class {
+  constructor(fn, options = {}) {
+    this.fn = fn;
+    this.failureThreshold = options.failureThreshold ?? 5;
+    this.resetTimeout = options.resetTimeout ?? 6e4;
+    this.timeout = options.timeout ?? 1e4;
+    this.successThreshold = options.successThreshold ?? 1;
+    this.fallback = options.fallback;
+    this.onStateChange = options.onStateChange;
+    this.onError = options.onError;
+    this.name = options.name ?? "CircuitBreaker";
+  }
+  state = "CLOSED" /* CLOSED */;
+  failures = 0;
+  successes = 0;
+  totalCalls = 0;
+  nextAttempt = 0;
+  lastCallAt = null;
+  openedAt = null;
+  failureThreshold;
+  resetTimeout;
+  timeout;
+  successThreshold;
+  fallback;
+  onStateChange;
+  onError;
+  name;
+  /**
+   * Call the wrapped function with circuit breaker protection
+   */
+  async call(...args) {
+    this.totalCalls++;
+    this.lastCallAt = Date.now();
+    if (this.state === "OPEN" /* OPEN */) {
+      if (Date.now() < this.nextAttempt) {
+        const error = new CircuitBreakerError(
+          `Circuit breaker is OPEN for ${this.name}`,
+          "OPEN" /* OPEN */
+        );
+        if (this.fallback) {
+          return this.fallback(...args);
+        }
+        throw error;
+      }
+      this.setState("HALF_OPEN" /* HALF_OPEN */);
+    }
+    try {
+      const result = await this.executeWithTimeout(args);
+      this.onSuccess();
+      return result;
+    } catch (error) {
+      this.onFailure(error);
+      throw error;
+    }
+  }
+  /**
+   * Execute function with timeout
+   */
+  async executeWithTimeout(args) {
+    return new Promise((resolve, reject) => {
+      const timeoutId = setTimeout(() => {
+        reject(new Error(`Request timeout after ${this.timeout}ms`));
+      }, this.timeout);
+      this.fn(...args).then((result) => {
+        clearTimeout(timeoutId);
+        resolve(result);
+      }).catch((error) => {
+        clearTimeout(timeoutId);
+        reject(error);
+      });
+    });
+  }
+  /**
+   * Handle successful call
+   */
+  onSuccess() {
+    this.failures = 0;
+    this.successes++;
+    if (this.state === "HALF_OPEN" /* HALF_OPEN */) {
+      if (this.successes >= this.successThreshold) {
+        this.setState("CLOSED" /* CLOSED */);
+        this.successes = 0;
+      }
+    }
+  }
+  /**
+   * Handle failed call
+   */
+  onFailure(error) {
+    this.failures++;
+    this.successes = 0;
+    if (this.onError) {
+      this.onError(error);
+    }
+    if (this.state === "HALF_OPEN" /* HALF_OPEN */ || this.failures >= this.failureThreshold) {
+      this.setState("OPEN" /* OPEN */);
+      this.nextAttempt = Date.now() + this.resetTimeout;
+      this.openedAt = Date.now();
+    }
+  }
+  /**
+   * Change circuit state
+   */
+  setState(newState) {
+    const oldState = this.state;
+    if (oldState !== newState) {
+      this.state = newState;
+      if (this.onStateChange) {
+        this.onStateChange(oldState, newState);
+      }
+    }
+  }
+  /**
+   * Manually open the circuit
+   */
+  open() {
+    this.setState("OPEN" /* OPEN */);
+    this.nextAttempt = Date.now() + this.resetTimeout;
+    this.openedAt = Date.now();
+  }
+  /**
+   * Manually close the circuit
+   */
+  close() {
+    this.failures = 0;
+    this.successes = 0;
+    this.setState("CLOSED" /* CLOSED */);
+    this.openedAt = null;
+  }
+  /**
+   * Get current statistics
+   */
+  getStats() {
+    return {
+      name: this.name,
+      state: this.state,
+      failures: this.failures,
+      successes: this.successes,
+      totalCalls: this.totalCalls,
+      openedAt: this.openedAt,
+      lastCallAt: this.lastCallAt
+    };
+  }
+  /**
+   * Get current state
+   */
+  getState() {
+    return this.state;
+  }
+  /**
+   * Check if circuit is open
+   */
+  isOpen() {
+    return this.state === "OPEN" /* OPEN */;
+  }
+  /**
+   * Check if circuit is closed
+   */
+  isClosed() {
+    return this.state === "CLOSED" /* CLOSED */;
+  }
+  /**
+   * Reset statistics
+   */
+  reset() {
+    this.failures = 0;
+    this.successes = 0;
+    this.totalCalls = 0;
+    this.lastCallAt = null;
+    this.openedAt = null;
+    this.setState("CLOSED" /* CLOSED */);
+  }
+};
+function createCircuitBreaker(fn, options) {
+  return new CircuitBreaker(fn, options);
+}
+var CircuitBreakerRegistry = class {
+  breakers = /* @__PURE__ */ new Map();
+  /**
+   * Register a circuit breaker
+   */
+  register(name, fn, options) {
+    const breaker = new CircuitBreaker(fn, { ...options, name });
+    this.breakers.set(name, breaker);
+    return breaker;
+  }
+  /**
+   * Get a circuit breaker by name
+   */
+  get(name) {
+    return this.breakers.get(name);
+  }
+  /**
+   * Get all breakers
+   */
+  getAll() {
+    return this.breakers;
+  }
+  /**
+   * Get statistics for all breakers
+   */
+  getAllStats() {
+    const stats = {};
+    for (const [name, breaker] of this.breakers.entries()) {
+      stats[name] = breaker.getStats();
+    }
+    return stats;
+  }
+  /**
+   * Reset all breakers
+   */
+  resetAll() {
+    for (const breaker of this.breakers.values()) {
+      breaker.reset();
+    }
+  }
+  /**
+   * Open all breakers
+   */
+  openAll() {
+    for (const breaker of this.breakers.values()) {
+      breaker.open();
+    }
+  }
+  /**
+   * Close all breakers
+   */
+  closeAll() {
+    for (const breaker of this.breakers.values()) {
+      breaker.close();
+    }
+  }
+};
+var circuitBreakerRegistry = new CircuitBreakerRegistry();
+
+// src/utils/queryParser.ts
+var DANGEROUS_REGEX_PATTERNS = /(\{[0-9,]+\}|\*\+|\+\+|\?\+|(\(.+\))\+|\(\?\:|\\[0-9]|(\[.+\]).+(\[.+\]))/;
+var MAX_REGEX_LENGTH = 500;
+var MAX_SEARCH_LENGTH = 200;
+var MAX_FILTER_DEPTH = 10;
+var MAX_LIMIT = 1e3;
+var DEFAULT_LIMIT = 20;
+var ArcQueryParser = class {
+  maxLimit;
+  defaultLimit;
+  maxRegexLength;
+  maxSearchLength;
+  maxFilterDepth;
+  /** Supported filter operators */
+  operators = {
+    eq: "$eq",
+    ne: "$ne",
+    gt: "$gt",
+    gte: "$gte",
+    lt: "$lt",
+    lte: "$lte",
+    in: "$in",
+    nin: "$nin",
+    like: "$regex",
+    contains: "$regex",
+    regex: "$regex",
+    exists: "$exists"
+  };
+  constructor(options = {}) {
+    this.maxLimit = options.maxLimit ?? MAX_LIMIT;
+    this.defaultLimit = options.defaultLimit ?? DEFAULT_LIMIT;
+    this.maxRegexLength = options.maxRegexLength ?? MAX_REGEX_LENGTH;
+    this.maxSearchLength = options.maxSearchLength ?? MAX_SEARCH_LENGTH;
+    this.maxFilterDepth = options.maxFilterDepth ?? MAX_FILTER_DEPTH;
+  }
+  /**
+   * Parse URL query parameters into structured query options
+   */
+  parse(query) {
+    const q = query ?? {};
+    const page = this.parseNumber(q.page, 1);
+    const limit = Math.min(this.parseNumber(q.limit, this.defaultLimit), this.maxLimit);
+    const after = this.parseString(q.after ?? q.cursor);
+    const sort = this.parseSort(q.sort);
+    const populate = this.parseString(q.populate);
+    const search = this.parseSearch(q.search);
+    const select = this.parseSelect(q.select);
+    const filters = this.parseFilters(q);
+    return {
+      filters,
+      limit,
+      sort,
+      populate,
+      search,
+      page: after ? void 0 : page,
+      after,
+      select
+    };
+  }
+  // ============================================================================
+  // Parse Helpers
+  // ============================================================================
+  parseNumber(value, defaultValue) {
+    if (value === void 0 || value === null) return defaultValue;
+    const num = parseInt(String(value), 10);
+    return Number.isNaN(num) ? defaultValue : Math.max(1, num);
+  }
+  parseString(value) {
+    if (value === void 0 || value === null) return void 0;
+    const str = String(value).trim();
+    return str.length > 0 ? str : void 0;
+  }
+  parseSort(value) {
+    if (!value) return void 0;
+    const sortStr = String(value);
+    const result = {};
+    for (const field of sortStr.split(",")) {
+      const trimmed = field.trim();
+      if (!trimmed) continue;
+      if (!/^-?[a-zA-Z_][a-zA-Z0-9_.]*$/.test(trimmed)) continue;
+      if (trimmed.startsWith("-")) {
+        result[trimmed.slice(1)] = -1;
+      } else {
+        result[trimmed] = 1;
+      }
+    }
+    return Object.keys(result).length > 0 ? result : void 0;
+  }
+  parseSearch(value) {
+    if (!value) return void 0;
+    const search = String(value).trim();
+    if (search.length === 0) return void 0;
+    if (search.length > this.maxSearchLength) {
+      return search.slice(0, this.maxSearchLength);
+    }
+    return search;
+  }
+  parseSelect(value) {
+    if (!value) return void 0;
+    const selectStr = String(value);
+    const result = {};
+    for (const field of selectStr.split(",")) {
+      const trimmed = field.trim();
+      if (!trimmed) continue;
+      if (!/^-?[a-zA-Z_][a-zA-Z0-9_.]*$/.test(trimmed)) continue;
+      if (trimmed.startsWith("-")) {
+        result[trimmed.slice(1)] = 0;
+      } else {
+        result[trimmed] = 1;
+      }
+    }
+    return Object.keys(result).length > 0 ? result : void 0;
+  }
+  parseFilters(query) {
+    const reservedKeys = /* @__PURE__ */ new Set([
+      "page",
+      "limit",
+      "sort",
+      "populate",
+      "search",
+      "select",
+      "after",
+      "cursor",
+      "lean",
+      "_policyFilters"
+    ]);
+    const filters = {};
+    for (const [key, value] of Object.entries(query)) {
+      if (reservedKeys.has(key)) continue;
+      if (value === void 0 || value === null) continue;
+      const match = key.match(/^([a-zA-Z_][a-zA-Z0-9_.]*)(?:\[([a-z]+)\])?$/);
+      if (!match) continue;
+      const [, fieldName, operator] = match;
+      if (!fieldName) continue;
+      if (operator && this.operators[operator]) {
+        const mongoOp = this.operators[operator];
+        const parsedValue = this.parseFilterValue(value, operator);
+        if (!filters[fieldName]) {
+          filters[fieldName] = {};
+        }
+        filters[fieldName][mongoOp] = parsedValue;
+      } else if (!operator) {
+        filters[fieldName] = this.parseFilterValue(value);
+      }
+    }
+    return filters;
+  }
+  parseFilterValue(value, operator) {
+    if (operator === "in" || operator === "nin") {
+      if (Array.isArray(value)) {
+        return value.map((v) => this.coerceValue(v));
+      }
+      if (typeof value === "string" && value.includes(",")) {
+        return value.split(",").map((v) => this.coerceValue(v.trim()));
+      }
+      return [this.coerceValue(value)];
+    }
+    if (operator === "like" || operator === "contains" || operator === "regex") {
+      return this.sanitizeRegex(String(value));
+    }
+    if (operator === "exists") {
+      const str = String(value).toLowerCase();
+      return str === "true" || str === "1";
+    }
+    return this.coerceValue(value);
+  }
+  coerceValue(value) {
+    if (value === "true") return true;
+    if (value === "false") return false;
+    if (value === "null") return null;
+    if (typeof value === "string") {
+      const num = Number(value);
+      if (!Number.isNaN(num) && value.trim() !== "") {
+        return num;
+      }
+    }
+    return value;
+  }
+  sanitizeRegex(pattern) {
+    let sanitized = pattern.slice(0, this.maxRegexLength);
+    if (DANGEROUS_REGEX_PATTERNS.test(sanitized)) {
+      sanitized = sanitized.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    }
+    return sanitized;
+  }
+};
+function createQueryParser(options) {
+  return new ArcQueryParser(options);
+}
+
+export { ArcError, ArcQueryParser, CircuitBreaker, CircuitBreakerError, CircuitBreakerRegistry, CircuitState, ConflictError, ForbiddenError, NotFoundError, OrgAccessDeniedError, OrgRequiredError, RateLimitError, ServiceUnavailableError, UnauthorizedError, ValidationError, circuitBreakerRegistry, createCircuitBreaker, createError, createQueryParser, createStateMachine, deleteResponse, errorResponseSchema, getListQueryParams, isArcError, itemResponse, listResponse, mutationResponse, paginationSchema, queryParams, responses, successResponseSchema, wrapResponse };