@classytic/arc 1.1.0 → 2.1.2

package/dist/utils/index.js

@@ -1,931 +0,0 @@
-// 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 },
-    pages: { type: "integer", example: 5 },
-    hasNext: { type: "boolean", example: true },
-    hasPrev: { type: "boolean", example: false }
-  },
-  required: ["page", "limit", "total", "pages", "hasNext", "hasPrev"]
-};
-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 },
-      docs: {
-        type: "array",
-        items: itemSchema
-      },
-      // Flat pagination fields (not nested)
-      page: { type: "integer", example: 1 },
-      limit: { type: "integer", example: 20 },
-      total: { type: "integer", example: 100 },
-      pages: { type: "integer", example: 5 },
-      hasNext: { type: "boolean", example: false },
-      hasPrev: { type: "boolean", example: false }
-    },
-    required: ["success", "docs"]
-  };
-}
-var paginateWrapper = listResponse;
-function itemResponse(itemSchema) {
-  return wrapResponse(itemSchema);
-}
-var itemWrapper = itemResponse;
-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 messageWrapper = deleteResponse;
-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;
-      if (!/^[a-zA-Z_][a-zA-Z0-9_.]*$/.test(key)) continue;
-      if (typeof value === "object" && value !== null && !Array.isArray(value)) {
-        const operatorObj = value;
-        const operatorKeys = Object.keys(operatorObj);
-        const allOperators = operatorKeys.every((op) => this.operators[op]);
-        if (allOperators && operatorKeys.length > 0) {
-          const mongoFilters = {};
-          for (const [op, opValue] of Object.entries(operatorObj)) {
-            const mongoOp = this.operators[op];
-            if (mongoOp) {
-              mongoFilters[mongoOp] = this.parseFilterValue(opValue, op);
-            }
-          }
-          filters[key] = mongoFilters;
-          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, itemWrapper, listResponse, messageWrapper, mutationResponse, paginateWrapper, paginationSchema, queryParams, responses, successResponseSchema, wrapResponse };