@carddb/core 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1177 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AuthenticationError: () => AuthenticationError,
+  CardDBError: () => CardDBError,
+  Collection: () => Collection,
+  ConnectionError: () => ConnectionError,
+  FilterBuilder: () => FilterBuilder,
+  GraphQLError: () => GraphQLError,
+  LinkResolutionError: () => LinkResolutionError,
+  NotFoundError: () => NotFoundError,
+  QueryBuilder: () => QueryBuilder,
+  RateLimitError: () => RateLimitError,
+  RestrictedError: () => RestrictedError,
+  ServerError: () => ServerError,
+  TimeoutError: () => TimeoutError,
+  ValidationError: () => ValidationError,
+  contains: () => contains,
+  eq: () => eq,
+  gt: () => gt,
+  gte: () => gte,
+  ilike: () => ilike,
+  isNotNull: () => isNotNull,
+  isNull: () => isNull,
+  like: () => like,
+  lt: () => lt,
+  lte: () => lte,
+  neq: () => neq,
+  notWithin: () => notWithin,
+  resolveFilter: () => resolveFilter,
+  within: () => within
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors.ts
+var CardDBError = class _CardDBError extends Error {
+  /** The full response body if available */
+  response;
+  constructor(message, response) {
+    super(message);
+    this.name = "CardDBError";
+    this.response = response;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _CardDBError);
+    }
+  }
+};
+var AuthenticationError = class extends CardDBError {
+  constructor(message = "Invalid or missing API key", response) {
+    super(message, response);
+    this.name = "AuthenticationError";
+  }
+};
+var RateLimitError = class extends CardDBError {
+  /** Seconds until rate limit resets */
+  retryAfter;
+  /** Maximum requests allowed */
+  limit;
+  /** Remaining requests in window */
+  remaining;
+  /** Time when the rate limit resets */
+  resetAt;
+  constructor(message = "Rate limit exceeded", options = {}) {
+    super(message, options.response);
+    this.name = "RateLimitError";
+    this.retryAfter = options.retryAfter ?? null;
+    this.limit = options.limit ?? null;
+    this.remaining = options.remaining ?? null;
+    this.resetAt = options.resetAt ?? null;
+  }
+};
+var NotFoundError = class extends CardDBError {
+  constructor(message = "Resource not found", response) {
+    super(message, response);
+    this.name = "NotFoundError";
+  }
+};
+var ValidationError = class extends CardDBError {
+  /** List of validation errors */
+  errors;
+  constructor(message = "Validation error", options = {}) {
+    super(message, options.response);
+    this.name = "ValidationError";
+    this.errors = options.errors ?? [];
+  }
+};
+var RestrictedError = class extends CardDBError {
+  constructor(message, response) {
+    super(message, response);
+    this.name = "RestrictedError";
+  }
+};
+var GraphQLError = class extends CardDBError {
+  /** List of GraphQL errors */
+  errors;
+  constructor(message = "GraphQL error", options = {}) {
+    super(message, options.response);
+    this.name = "GraphQLError";
+    this.errors = options.errors ?? [];
+  }
+};
+var ConnectionError = class extends CardDBError {
+  constructor(message = "Connection error", response) {
+    super(message, response);
+    this.name = "ConnectionError";
+  }
+};
+var TimeoutError = class extends ConnectionError {
+  constructor(message = "Request timed out", response) {
+    super(message, response);
+    this.name = "TimeoutError";
+  }
+};
+var ServerError = class extends CardDBError {
+  /** HTTP status code */
+  status;
+  constructor(message = "Server error", options = {}) {
+    super(message, options.response);
+    this.name = "ServerError";
+    this.status = options.status ?? null;
+  }
+};
+var LinkResolutionError = class extends CardDBError {
+  /** List of link resolution failures */
+  failures;
+  /** Partial results that were successfully resolved */
+  partialResults;
+  constructor(message = "Some links could not be resolved", options = {}) {
+    super(message, options.response);
+    this.name = "LinkResolutionError";
+    this.failures = options.failures ?? [];
+    this.partialResults = options.partialResults;
+  }
+  /**
+   * Get failures for a specific field
+   */
+  getFailuresForField(field) {
+    return this.failures.filter((f) => f.field === field);
+  }
+  /**
+   * Check if a specific field had resolution failures
+   */
+  hasFailuresForField(field) {
+    return this.failures.some((f) => f.field === field);
+  }
+};
+
+// src/operators.ts
+function eq(value) {
+  return { eq: value };
+}
+function neq(value) {
+  return { neq: value };
+}
+function gt(value) {
+  return { gt: value };
+}
+function gte(value) {
+  return { gte: value };
+}
+function lt(value) {
+  return { lt: value };
+}
+function lte(value) {
+  return { lte: value };
+}
+function within(values) {
+  return { in: values };
+}
+function notWithin(values) {
+  return { nin: values };
+}
+function contains(value) {
+  return { contains: value };
+}
+function like(pattern) {
+  return { like: pattern };
+}
+function ilike(pattern) {
+  return { ilike: pattern };
+}
+function isNull() {
+  return { is_null: true };
+}
+function isNotNull() {
+  return { is_null: false };
+}
+
+// src/filter-builder.ts
+var FilterBuilder = class _FilterBuilder {
+  conditions = [];
+  orGroups = [];
+  where(fieldOrConditions, value) {
+    if (typeof fieldOrConditions === "string") {
+      this.conditions.push({ [fieldOrConditions]: value });
+    } else {
+      for (const [field, val] of Object.entries(fieldOrConditions)) {
+        this.conditions.push({ [field]: val });
+      }
+    }
+    return this;
+  }
+  /**
+   * Add an OR group (any of the conditions must match)
+   *
+   * @example
+   * .where('type', 'creature')
+   * .any(or => or
+   *   .where('color', 'red')
+   *   .where('color', 'blue')
+   * )
+   */
+  any(callback) {
+    const orBuilder = new _FilterBuilder();
+    callback(orBuilder);
+    const orConditions = orBuilder.getConditions();
+    if (orConditions.length > 0) {
+      this.orGroups.push({ $or: orConditions });
+    }
+    return this;
+  }
+  /**
+   * Add a link filter condition (filter on linked records)
+   *
+   * @example
+   * .whereLink('set_id', { code: 'DMU' })
+   * .whereLink('set_id', { name: ilike('%dominaria%') })
+   */
+  whereLink(field, conditions) {
+    const linkFilter = {};
+    for (const [key, val] of Object.entries(conditions)) {
+      linkFilter[key] = val;
+    }
+    this.conditions.push({ [`${field}._link`]: linkFilter });
+    return this;
+  }
+  /**
+   * Add an array element filter (for ARRAY of HASH fields)
+   * Matches if any element in the array matches all conditions
+   *
+   * @example
+   * .whereAny('attacks', { damage: gte(50) })
+   * .whereAny('attacks', { name: ilike('%thunder%') })
+   */
+  whereAny(field, conditions) {
+    const anyFilter = {};
+    for (const [key, val] of Object.entries(conditions)) {
+      anyFilter[key] = val;
+    }
+    this.conditions.push({ [`${field}._any`]: anyFilter });
+    return this;
+  }
+  /**
+   * Get the conditions array (used internally for OR groups)
+   */
+  getConditions() {
+    return this.conditions;
+  }
+  /**
+   * Build the final filter object
+   */
+  build() {
+    const allConditions = [...this.conditions, ...this.orGroups];
+    if (allConditions.length === 0) {
+      return {};
+    }
+    if (allConditions.length === 1) {
+      return allConditions[0];
+    }
+    return { $and: allConditions };
+  }
+};
+function resolveFilter(input) {
+  if (input === void 0) {
+    return void 0;
+  }
+  if (typeof input === "function") {
+    const builder = new FilterBuilder();
+    input(builder);
+    const result = builder.build();
+    return Object.keys(result).length > 0 ? result : void 0;
+  }
+  return Object.keys(input).length > 0 ? input : void 0;
+}
+
+// src/query-builder.ts
+var PUBLISHER_FIELDS = `
+  id
+  name
+  slug
+  status
+  description
+  website
+  createdAt
+  updatedAt
+  logoFile {
+    id
+    url
+  }
+  bannerFile {
+    id
+    url
+  }
+`;
+var GAME_FIELDS = `
+  id
+  publisherId
+  key
+  name
+  description
+  website
+  visibility
+  isArchived
+  createdAt
+  updatedAt
+  publisher {
+    id
+    name
+    slug
+  }
+  logoFile {
+    id
+    url
+  }
+  coverFile {
+    id
+    url
+  }
+`;
+var DATASET_FIELDS = `
+  id
+  publisherId
+  gameId
+  key
+  name
+  description
+  purpose
+  visibility
+  isArchived
+  createdAt
+  updatedAt
+  publisher {
+    id
+    name
+    slug
+  }
+  game {
+    id
+    key
+    name
+  }
+`;
+var SCHEMA_FIELDS = `
+  schema {
+    fields {
+      key
+      label
+      description
+      type
+      isRequired
+      filterable
+      searchable
+      isIdentifier
+      itemType
+      displayFormat
+      allowedValues
+      nestedFields {
+        key
+        label
+        description
+        type
+        isRequired
+        filterable
+        searchable
+        itemType
+      }
+    }
+    filterableFields
+    searchableFields
+    linkFields {
+      key
+      label
+      targetDatasetKey
+      targetDatasetName
+      targetDatasetId
+    }
+  }
+`;
+var RECORD_FIELDS = `
+  id
+  datasetId
+  data
+  createdAt
+  updatedAt
+  dataset {
+    id
+    key
+    name
+    gameId
+    publisherId
+  }
+`;
+var DECK_FIELDS = `
+  id
+  accountId
+  apiApplicationId
+  gameId
+  title
+  description
+  formatKey
+  visibility
+  externalRef
+  sourceUrl
+  metadata
+  createdAt
+  updatedAt
+  game {
+    ${GAME_FIELDS}
+  }
+  entries {
+    id
+    datasetId
+    recordId
+    identifier
+    quantity
+    section
+    sortOrder
+    annotations
+    record {
+      ${RECORD_FIELDS}
+    }
+  }
+`;
+var RESOLVED_LINKS_FIELDS = `
+  resolvedLinks {
+    field
+    linkFieldKey
+    values
+    records {
+      id
+      datasetId
+      data
+    }
+  }
+`;
+function connectionFields(nodeFields) {
+  return `
+    totalCount
+    pageInfo {
+      hasNextPage
+      hasPreviousPage
+      startCursor
+      endCursor
+    }
+    edges {
+      cursor
+      node {
+        ${nodeFields}
+      }
+    }
+  `;
+}
+var QueryBuilder = {
+  // Publishers
+  searchPublishers(params = {}) {
+    const variables = {};
+    const args = [];
+    const defs = [];
+    if (params.search !== void 0) {
+      defs.push("$search: String");
+      args.push("search: $search");
+      variables["search"] = params.search;
+    }
+    if (params.first !== void 0) {
+      defs.push("$first: Int");
+      args.push("first: $first");
+      variables["first"] = params.first;
+    }
+    if (params.after !== void 0) {
+      defs.push("$after: String");
+      args.push("after: $after");
+      variables["after"] = params.after;
+    }
+    const defStr = defs.length > 0 ? `(${defs.join(", ")})` : "";
+    const argStr = args.length > 0 ? `(${args.join(", ")})` : "";
+    return {
+      query: `
+        query SearchPublishers${defStr} {
+          searchPublishers${argStr} {
+            ${connectionFields(PUBLISHER_FIELDS)}
+          }
+        }
+      `,
+      variables
+    };
+  },
+  fetchPublisherById() {
+    return {
+      query: `
+        query FetchPublisher($id: UUID!) {
+          fetchPublisher(id: $id) {
+            ${PUBLISHER_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  fetchPublisherBySlug() {
+    return {
+      query: `
+        query FetchPublisher($slug: String!) {
+          fetchPublisher(slug: $slug) {
+            ${PUBLISHER_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  fetchPublishers() {
+    return {
+      query: `
+        query FetchPublishers($slugs: [String!]!) {
+          fetchPublishers(slugs: $slugs) {
+            ${PUBLISHER_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  // Games
+  searchGames(params = {}) {
+    const variables = {};
+    const args = [];
+    const defs = [];
+    if (params.publisherSlug !== void 0) {
+      defs.push("$publisherSlug: String");
+      args.push("publisherSlug: $publisherSlug");
+      variables["publisherSlug"] = params.publisherSlug;
+    }
+    if (params.search !== void 0) {
+      defs.push("$search: String");
+      args.push("search: $search");
+      variables["search"] = params.search;
+    }
+    if (params.first !== void 0) {
+      defs.push("$first: Int");
+      args.push("first: $first");
+      variables["first"] = params.first;
+    }
+    if (params.after !== void 0) {
+      defs.push("$after: String");
+      args.push("after: $after");
+      variables["after"] = params.after;
+    }
+    const defStr = defs.length > 0 ? `(${defs.join(", ")})` : "";
+    const argStr = args.length > 0 ? `(${args.join(", ")})` : "";
+    return {
+      query: `
+        query SearchGames${defStr} {
+          searchGames${argStr} {
+            ${connectionFields(GAME_FIELDS)}
+          }
+        }
+      `,
+      variables
+    };
+  },
+  fetchGameById() {
+    return {
+      query: `
+        query FetchGame($id: UUID!) {
+          fetchGame(id: $id) {
+            ${GAME_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  fetchGameByKeys() {
+    return {
+      query: `
+        query FetchGame($publisherSlug: String!, $gameKey: String!) {
+          fetchGame(publisherSlug: $publisherSlug, gameKey: $gameKey) {
+            ${GAME_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  fetchGames() {
+    return {
+      query: `
+        query FetchGames($ids: [UUID!]!) {
+          fetchGames(ids: $ids) {
+            ${GAME_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  // Datasets
+  searchDatasets(params = {}) {
+    const variables = {};
+    const args = [];
+    const defs = [];
+    if (params.publisherSlug !== void 0) {
+      defs.push("$publisherSlug: String");
+      args.push("publisherSlug: $publisherSlug");
+      variables["publisherSlug"] = params.publisherSlug;
+    }
+    if (params.gameKey !== void 0) {
+      defs.push("$gameKey: String");
+      args.push("gameKey: $gameKey");
+      variables["gameKey"] = params.gameKey;
+    }
+    if (params.search !== void 0) {
+      defs.push("$search: String");
+      args.push("search: $search");
+      variables["search"] = params.search;
+    }
+    if (params.purpose !== void 0) {
+      defs.push("$purpose: DatasetPurpose");
+      args.push("purpose: $purpose");
+      variables["purpose"] = params.purpose;
+    }
+    if (params.first !== void 0) {
+      defs.push("$first: Int");
+      args.push("first: $first");
+      variables["first"] = params.first;
+    }
+    if (params.after !== void 0) {
+      defs.push("$after: String");
+      args.push("after: $after");
+      variables["after"] = params.after;
+    }
+    const defStr = defs.length > 0 ? `(${defs.join(", ")})` : "";
+    const argStr = args.length > 0 ? `(${args.join(", ")})` : "";
+    return {
+      query: `
+        query SearchDatasets${defStr} {
+          searchDatasets${argStr} {
+            ${connectionFields(DATASET_FIELDS)}
+          }
+        }
+      `,
+      variables
+    };
+  },
+  fetchDatasetById() {
+    return {
+      query: `
+        query FetchDataset($id: UUID!) {
+          fetchDataset(id: $id) {
+            ${DATASET_FIELDS}
+            ${SCHEMA_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  fetchDatasetByKeys() {
+    return {
+      query: `
+        query FetchDataset($publisherSlug: String!, $gameKey: String!, $datasetKey: String!) {
+          fetchDataset(publisherSlug: $publisherSlug, gameKey: $gameKey, datasetKey: $datasetKey) {
+            ${DATASET_FIELDS}
+            ${SCHEMA_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  fetchDatasets() {
+    return {
+      query: `
+        query FetchDatasets($ids: [UUID!]!) {
+          fetchDatasets(ids: $ids) {
+            ${DATASET_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  // Records
+  searchRecords(params) {
+    const variables = {
+      publisherSlug: params.publisherSlug,
+      gameKey: params.gameKey,
+      datasetKey: params.datasetKey
+    };
+    const args = [
+      "publisherSlug: $publisherSlug",
+      "gameKey: $gameKey",
+      "datasetKey: $datasetKey"
+    ];
+    const defs = ["$publisherSlug: String!", "$gameKey: String!", "$datasetKey: String!"];
+    if (params.filter !== void 0) {
+      defs.push("$filter: JSON");
+      args.push("filter: $filter");
+      variables["filter"] = params.filter;
+    }
+    if (params.search !== void 0) {
+      defs.push("$search: String");
+      args.push("search: $search");
+      variables["search"] = params.search;
+    }
+    if (params.orderBy !== void 0) {
+      defs.push("$orderBy: String");
+      args.push("orderBy: $orderBy");
+      variables["orderBy"] = params.orderBy;
+    }
+    if (params.resolveLinks !== void 0) {
+      defs.push("$resolveLinks: [String!]");
+      args.push("resolveLinks: $resolveLinks");
+      variables["resolveLinks"] = params.resolveLinks;
+    }
+    if (params.first !== void 0) {
+      defs.push("$first: Int");
+      args.push("first: $first");
+      variables["first"] = params.first;
+    }
+    if (params.after !== void 0) {
+      defs.push("$after: String");
+      args.push("after: $after");
+      variables["after"] = params.after;
+    }
+    if (params.validateSchema !== void 0) {
+      defs.push("$validateSchema: Boolean");
+      args.push("validateSchema: $validateSchema");
+      variables["validateSchema"] = params.validateSchema;
+    }
+    const includeResolvedLinks = params.resolveLinks && params.resolveLinks.length > 0;
+    const nodeFields = includeResolvedLinks ? `${RECORD_FIELDS}
+${RESOLVED_LINKS_FIELDS}` : RECORD_FIELDS;
+    return {
+      query: `
+        query SearchRecords(${defs.join(", ")}) {
+          searchRecords(${args.join(", ")}) {
+            ${connectionFields(nodeFields)}
+          }
+        }
+      `,
+      variables
+    };
+  },
+  fetchRecordById() {
+    return {
+      query: `
+        query FetchRecord($id: UUID!) {
+          fetchRecord(id: $id) {
+            ${RECORD_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  fetchRecordByIdentifier() {
+    return {
+      query: `
+        query FetchRecordByIdentifier($publisherSlug: String!, $gameKey: String!, $datasetKey: String!, $identifier: String!) {
+          fetchRecordByIdentifier(publisherSlug: $publisherSlug, gameKey: $gameKey, datasetKey: $datasetKey, identifier: $identifier) {
+            ${RECORD_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  fetchRecordsByIdentifier() {
+    return {
+      query: `
+        query FetchRecordsByIdentifier($publisherSlug: String!, $gameKey: String!, $datasetKey: String!, $identifiers: [String!]!) {
+          fetchRecordsByIdentifier(publisherSlug: $publisherSlug, gameKey: $gameKey, datasetKey: $datasetKey, identifiers: $identifiers) {
+            ${RECORD_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  fetchRecords() {
+    return {
+      query: `
+        query FetchRecords($ids: [UUID!]!) {
+          fetchRecords(ids: $ids) {
+            ${RECORD_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  // Decks
+  listMyDecks(params = {}) {
+    const variables = {};
+    const args = [];
+    const defs = [];
+    if (params.first !== void 0) {
+      defs.push("$first: Int");
+      args.push("first: $first");
+      variables["first"] = params.first;
+    }
+    if (params.after !== void 0) {
+      defs.push("$after: String");
+      args.push("after: $after");
+      variables["after"] = params.after;
+    }
+    const defStr = defs.length > 0 ? `(${defs.join(", ")})` : "";
+    const argStr = args.length > 0 ? `(${args.join(", ")})` : "";
+    return {
+      query: `
+        query MyDecks${defStr} {
+          myDecks${argStr} {
+            ${connectionFields(DECK_FIELDS)}
+          }
+        }
+      `,
+      variables
+    };
+  },
+  fetchDeckById() {
+    return {
+      query: `
+        query FetchDeck($id: UUID!) {
+          fetchDeck(id: $id) {
+            ${DECK_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  fetchDeckByExternalRef() {
+    return {
+      query: `
+        query FetchDeckByExternalRef($externalRef: String!) {
+          fetchDeckByExternalRef(externalRef: $externalRef) {
+            ${DECK_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  createDeck() {
+    return {
+      query: `
+        mutation DeckCreate($input: DeckCreateInput!) {
+          deckCreate(input: $input) {
+            ${DECK_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  updateDeck() {
+    return {
+      query: `
+        mutation DeckUpdate($id: UUID!, $input: DeckUpdateInput!) {
+          deckUpdate(id: $id, input: $input) {
+            ${DECK_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  deleteDeck() {
+    return {
+      query: `
+        mutation DeckDelete($id: UUID!) {
+          deckDelete(id: $id)
+        }
+      `
+    };
+  },
+  deckCreateVariables(input) {
+    return { input };
+  },
+  deckUpdateVariables(id, input) {
+    return { id, input };
+  },
+  // API Key Info
+  fetchMe() {
+    return {
+      query: `
+        query FetchMe {
+          fetchMe {
+            application {
+              id
+              name
+              description
+              environment
+              apiKeyPrefix
+              allowedOrigins
+              allowedIps
+              createdAt
+              updatedAt
+              lastUsedAt
+            }
+            account {
+              id
+              displayName
+              createdAt
+            }
+          }
+        }
+      `
+    };
+  }
+};
+
+// src/collection.ts
+var Collection = class {
+  /** Total count of matching records across all pages */
+  totalCount;
+  /** Pagination info */
+  pageInfo;
+  /** Items in the current page */
+  items;
+  /** Function to load the next page */
+  nextPageLoader;
+  constructor(data, options = {}) {
+    this.totalCount = data.totalCount;
+    this.pageInfo = data.pageInfo;
+    this.items = data.edges.map(
+      (edge) => options.itemTransformer ? options.itemTransformer(edge.node) : edge.node
+    );
+    this.nextPageLoader = options.nextPageLoader;
+  }
+  /** Check if there are more pages */
+  get hasNextPage() {
+    return this.pageInfo.hasNextPage;
+  }
+  /** Check if there are previous pages */
+  get hasPreviousPage() {
+    return this.pageInfo.hasPreviousPage;
+  }
+  /** Get the cursor for the next page */
+  get endCursor() {
+    return this.pageInfo.endCursor;
+  }
+  /** Get the cursor for the previous page */
+  get startCursor() {
+    return this.pageInfo.startCursor;
+  }
+  /** Number of items in the current page */
+  get length() {
+    return this.items.length;
+  }
+  /** Check if the current page is empty */
+  get isEmpty() {
+    return this.items.length === 0;
+  }
+  /** Get the first item */
+  get first() {
+    return this.items[0];
+  }
+  /** Get the last item */
+  get last() {
+    return this.items[this.items.length - 1];
+  }
+  /**
+   * Fetch the next page of results
+   *
+   * @returns The next page collection, or null if no more pages
+   * @throws Error if no next page loader is configured
+   */
+  async nextPage() {
+    if (!this.hasNextPage) {
+      return null;
+    }
+    if (!this.nextPageLoader) {
+      throw new Error("No next page loader configured");
+    }
+    if (!this.endCursor) {
+      return null;
+    }
+    return this.nextPageLoader(this.endCursor);
+  }
+  /**
+   * Async iterator that automatically paginates through all results
+   *
+   * @example
+   * for await (const record of collection) {
+   *   console.log(record.name)
+   * }
+   *
+   * @example
+   * const allRecords = []
+   * for await (const record of collection) {
+   *   allRecords.push(record)
+   * }
+   */
+  async *[Symbol.asyncIterator]() {
+    let current = this;
+    while (current) {
+      for (const item of current.items) {
+        yield item;
+      }
+      if (!current.hasNextPage) {
+        break;
+      }
+      current = await current.nextPage();
+    }
+  }
+  /**
+   * Iterate through all results, calling a callback for each item
+   * Similar to Array.forEach but async and auto-paginating
+   *
+   * @example
+   * await collection.forEach(async (record) => {
+   *   await processRecord(record)
+   * })
+   */
+  async forEach(callback) {
+    let index = 0;
+    for await (const item of this) {
+      await callback(item, index++);
+    }
+  }
+  /**
+   * Map over all results, returning a new array
+   * Auto-paginates through all pages
+   *
+   * @example
+   * const names = await collection.map(record => record.name)
+   */
+  async map(callback) {
+    const results = [];
+    let index = 0;
+    for await (const item of this) {
+      results.push(await callback(item, index++));
+    }
+    return results;
+  }
+  /**
+   * Filter results, returning items that match the predicate
+   * Auto-paginates through all pages
+   *
+   * @example
+   * const rareCards = await collection.filter(card => card.rarity === 'rare')
+   */
+  async filter(predicate) {
+    const results = [];
+    let index = 0;
+    for await (const item of this) {
+      if (await predicate(item, index++)) {
+        results.push(item);
+      }
+    }
+    return results;
+  }
+  /**
+   * Find the first item matching a predicate
+   * Stops iterating once found
+   *
+   * @example
+   * const pikachu = await collection.find(card => card.name === 'Pikachu')
+   */
+  async find(predicate) {
+    let index = 0;
+    for await (const item of this) {
+      if (await predicate(item, index++)) {
+        return item;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Take the first n items
+   * Stops fetching pages once n items are collected
+   *
+   * @example
+   * const first100 = await collection.take(100)
+   */
+  async take(n) {
+    const results = [];
+    for await (const item of this) {
+      if (results.length >= n) {
+        break;
+      }
+      results.push(item);
+    }
+    return results;
+  }
+  /**
+   * Collect all items into an array
+   * Auto-paginates through all pages
+   *
+   * @example
+   * const allRecords = await collection.toArray()
+   */
+  async toArray() {
+    const results = [];
+    for await (const item of this) {
+      results.push(item);
+    }
+    return results;
+  }
+  /**
+   * Iterate in batches (similar to Rails find_in_batches)
+   *
+   * @example
+   * for await (const batch of collection.batches()) {
+   *   await processBatch(batch)
+   * }
+   */
+  async *batches() {
+    let current = this;
+    while (current) {
+      if (current.items.length > 0) {
+        yield current.items;
+      }
+      if (!current.hasNextPage) {
+        break;
+      }
+      current = await current.nextPage();
+    }
+  }
+  /**
+   * Iterate one item at a time with batched fetching (similar to Rails find_each)
+   *
+   * @example
+   * for await (const item of collection.each()) {
+   *   await processItem(item)
+   * }
+   */
+  each() {
+    return this;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AuthenticationError,
+  CardDBError,
+  Collection,
+  ConnectionError,
+  FilterBuilder,
+  GraphQLError,
+  LinkResolutionError,
+  NotFoundError,
+  QueryBuilder,
+  RateLimitError,
+  RestrictedError,
+  ServerError,
+  TimeoutError,
+  ValidationError,
+  contains,
+  eq,
+  gt,
+  gte,
+  ilike,
+  isNotNull,
+  isNull,
+  like,
+  lt,
+  lte,
+  neq,
+  notWithin,
+  resolveFilter,
+  within
+});
+//# sourceMappingURL=index.cjs.map