@carddb/core 0.2.0 → 0.2.5

package/dist/index.cjs

@@ -303,6 +303,27 @@ function resolveFilter(input) {
 }
 
 // src/query-builder.ts
+var FILE_FIELDS = `
+  id
+  createdAt
+  updatedAt
+  key
+  filename
+  contentType
+  size
+  status
+  isPublic
+  entityType
+  entityId
+  url
+`;
+var PRESIGNED_UPLOAD_FIELDS = `
+  file {
+    ${FILE_FIELDS}
+  }
+  uploadUrl
+  expiresAt
+`;
 var PUBLISHER_FIELDS = `
   id
   name
@@ -327,6 +348,8 @@ var GAME_FIELDS = `
   key
   name
   description
+  metafyGameUuid
+  metafyGameSlug
   website
   visibility
   isArchived
@@ -354,8 +377,13 @@ var DATASET_FIELDS = `
   name
   description
   purpose
+  activeVersionId
   tcgplayerProductIdFieldKey
   visibility
+  posX
+  posY
+  sortOrder
+  archivedAt
   isArchived
   createdAt
   updatedAt
@@ -385,10 +413,28 @@ function fieldInfoFields(depth) {
       filterable
       searchable
       isIdentifier
+      sortOrder
       itemType
+      linkDatasetId
+      linkDatasetKey
+      linkDatasetName
+      linkFieldKey
+      linkAlias
+      linkDirection
       displayFormat
       semanticType
+      placeholder
+      isHidden
+      isComputed
+      isSystemField
+      defaultValue
       allowedValues
+      minLength
+      maxLength
+      minValue
+      maxValue
+      pattern
+      isUnique
       ${nestedFields}
   `;
 }
@@ -405,9 +451,48 @@ var SCHEMA_FIELDS = `
       targetDatasetKey
       targetDatasetName
       targetDatasetId
+      targetFieldKey
+      linkAlias
+      linkDirection
+      isArray
     }
   }
 `;
+var OBJECT_FIELD_FIELDS = `
+  id
+  objectTypeId
+  key
+  label
+  dataType
+  isRequired
+  isFilterable
+  isSearchable
+  isIdentifier
+  sortOrder
+  description
+  placeholder
+  displayFormat
+  semanticType
+  isHidden
+  isComputed
+  isSystemField
+  defaultValue
+  allowedValues
+  minLength
+  maxLength
+  minValue
+  maxValue
+  pattern
+  isUnique
+  itemType
+  linkDatasetId
+  linkFieldKey
+  linkAlias
+  linkDirection
+  parentFieldId
+  createdAt
+  updatedAt
+`;
 var TCGPLAYER_PRICING_FIELDS = `
   pricing {
     productId
@@ -874,6 +959,305 @@ var RESOLVED_LINKS_FIELDS = `
     }
   }
 `;
+var BULK_RECORD_ERROR_FIELDS = `
+  datasetKey
+  index
+  errors {
+    field
+    message
+    details
+  }
+`;
+var IMPORT_STATS_FIELDS = `
+  total
+  inserted
+  updated
+  skipped
+  failed
+`;
+var BULK_IMPORT_RESULT_FIELDS = `
+  inserted {
+    ${RECORD_FIELDS}
+  }
+  updated {
+    ${RECORD_FIELDS}
+  }
+  skipped
+  errors {
+    ${BULK_RECORD_ERROR_FIELDS}
+  }
+  createdFields {
+    ${OBJECT_FIELD_FIELDS}
+  }
+  stats {
+    ${IMPORT_STATS_FIELDS}
+  }
+`;
+var IMPORT_JOB_ASSET_FIELDS = `
+  fileId
+  filename
+  file {
+    ${FILE_FIELDS}
+  }
+`;
+var IMPORT_JOB_FIELDS = `
+  id
+  publisherId
+  publisher {
+    ${PUBLISHER_FIELDS}
+  }
+  datasetId
+  dataset {
+    ${DATASET_FIELDS}
+    ${SCHEMA_FIELDS}
+  }
+  accountId
+  status
+  mode
+  onConflict
+  format
+  fileId
+  progress
+  totalRecords
+  processedRecords
+  insertedCount
+  updatedCount
+  skippedCount
+  failedCount
+  createdFields {
+    ${OBJECT_FIELD_FIELDS}
+  }
+  errors {
+    ${BULK_RECORD_ERROR_FIELDS}
+  }
+  errorMessage
+  assets {
+    ${IMPORT_JOB_ASSET_FIELDS}
+  }
+  startedAt
+  completedAt
+  createdAt
+  updatedAt
+  lastCheckpointIndex
+  isResumed
+  imagesPending
+  imagesCompleted
+  imagesFailed
+`;
+var IMPORT_JOB_LOG_FIELDS = `
+  id
+  importJobId
+  level
+  message
+  datasetKey
+  recordIndex
+  fieldKey
+  details
+  createdAt
+`;
+var DATASET_RECORDS_UPSERT_PAYLOAD_FIELDS = `
+  job {
+    ${IMPORT_JOB_FIELDS}
+  }
+  dryRunResult {
+    ${BULK_IMPORT_RESULT_FIELDS}
+  }
+`;
+var DELETE_JOB_RESULT_FIELDS = `
+  target
+  recordId
+  identifier
+  status
+  message
+`;
+var DATASET_RECORD_DELETE_JOB_FIELDS = `
+  id
+  publisherId
+  publisher {
+    ${PUBLISHER_FIELDS}
+  }
+  datasetId
+  dataset {
+    ${DATASET_FIELDS}
+  }
+  accountId
+  status
+  targetType
+  dryRun
+  targets
+  progress
+  totalTargets
+  processedTargets
+  matchedCount
+  deletedCount
+  missingCount
+  blockedCount
+  failedCount
+  results {
+    ${DELETE_JOB_RESULT_FIELDS}
+  }
+  errorMessage
+  startedAt
+  completedAt
+  createdAt
+  updatedAt
+`;
+var FIELD_MAPPING_FIELDS = `
+  sourceField
+  targetField
+  targetFieldLabel
+  inferredType
+  inferredItemType
+  inferredChildren {
+    key
+    label
+    type
+    required
+    itemType
+    children {
+      key
+      label
+      type
+      required
+      itemType
+    }
+  }
+  inferredLinkDataset
+  inferredLinkFieldKey
+  inferredLinkDirection
+  targetFieldType
+  sampleValues
+  status
+`;
+var IMPORT_WARNING_FIELDS = `
+  datasetKey
+  field
+  message
+  severity
+`;
+var DATASET_IMPORT_PREVIEW_FIELDS = `
+  datasetKey
+  datasetName
+  datasetId
+  exists
+  recordCount
+  fieldMappings {
+    ${FIELD_MAPPING_FIELDS}
+  }
+  warnings {
+    ${IMPORT_WARNING_FIELDS}
+  }
+  canProceed
+  sampleRecords
+  availableDatasets {
+    ${DATASET_FIELDS}
+    ${SCHEMA_FIELDS}
+  }
+`;
+var GAME_IMPORT_PREVIEW_FIELDS = `
+  datasets {
+    datasetKey
+    datasetName
+    datasetId
+    exists
+    recordCount
+    fieldMappings {
+      ${FIELD_MAPPING_FIELDS}
+    }
+    warnings {
+      ${IMPORT_WARNING_FIELDS}
+    }
+    sampleRecords
+  }
+  importOrder
+  warnings {
+    ${IMPORT_WARNING_FIELDS}
+  }
+  canProceed
+`;
+var GAME_IMPORT_DATASET_STATUS_FIELDS = `
+  datasetKey
+  datasetId
+  datasetName
+  status
+  recordCount
+  insertedCount
+  updatedCount
+  skippedCount
+  failedCount
+  errorMessage
+`;
+var GAME_IMPORT_JOB_FIELDS = `
+  id
+  publisherId
+  publisher {
+    ${PUBLISHER_FIELDS}
+  }
+  gameId
+  game {
+    ${GAME_FIELDS}
+  }
+  accountId
+  status
+  mode
+  onConflict
+  fileId
+  assets {
+    ${IMPORT_JOB_ASSET_FIELDS}
+  }
+  totalDatasets
+  completedDatasets
+  progress
+  importOrder
+  datasetStatuses {
+    ${GAME_IMPORT_DATASET_STATUS_FIELDS}
+  }
+  errorMessage
+  startedAt
+  completedAt
+  createdAt
+  updatedAt
+  completedDatasetKeys
+  currentDatasetKey
+  lastCheckpointIndex
+  isResumed
+  imagesPending
+  imagesCompleted
+  imagesFailed
+  phase
+  linkBuildingDataset
+  linkBuildingTotalDatasets
+  linkBuildingCompletedDatasets
+  linkBuildingProcessedRecords
+  linkBuildingTotalRecords
+`;
+var EXPORT_JOB_FIELDS = `
+  id
+  publisherId
+  publisher {
+    ${PUBLISHER_FIELDS}
+  }
+  datasetId
+  dataset {
+    ${DATASET_FIELDS}
+  }
+  accountId
+  status
+  format
+  filter
+  totalRecords
+  processedRecords
+  progress
+  fileId
+  downloadUrl
+  downloadExpiresAt
+  errorMessage
+  startedAt
+  completedAt
+  createdAt
+  updatedAt
+  lastCheckpointIndex
+`;
 function connectionFields(nodeFields) {
   return `
     totalCount
@@ -912,147 +1296,878 @@ var QueryBuilder = {
       args.push("after: $after");
       variables["after"] = params.after;
     }
-    const defStr = defs.length > 0 ? `(${defs.join(", ")})` : "";
-    const argStr = args.length > 0 ? `(${args.join(", ")})` : "";
+    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}
+          }
+        }
+      `
+    };
+  },
+  listGames(params) {
+    const variables = { publisherId: params.publisherId };
+    const args = ["publisherId: $publisherId"];
+    const defs = ["$publisherId: UUID!"];
+    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.includeArchived !== void 0) {
+      defs.push("$includeArchived: Boolean");
+      args.push("includeArchived: $includeArchived");
+      variables["includeArchived"] = params.includeArchived;
+    }
+    return {
+      query: `
+        query Games(${defs.join(", ")}) {
+          games(${args.join(", ")}) {
+            ${connectionFields(GAME_FIELDS)}
+          }
+        }
+      `,
+      variables
+    };
+  },
+  game(params) {
+    const variables = {};
+    const args = [];
+    const defs = [];
+    if (params.id !== void 0) {
+      defs.push("$id: UUID");
+      args.push("id: $id");
+      variables["id"] = params.id;
+    }
+    if (params.publisherId !== void 0) {
+      defs.push("$publisherId: UUID");
+      args.push("publisherId: $publisherId");
+      variables["publisherId"] = params.publisherId;
+    }
+    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.gameSlug !== void 0) {
+      defs.push("$gameSlug: String");
+      args.push("gameSlug: $gameSlug");
+      variables["gameSlug"] = params.gameSlug;
+    }
+    return {
+      query: `
+        query Game(${defs.join(", ")}) {
+          game(${args.join(", ")}) {
+            ${GAME_FIELDS}
+          }
+        }
+      `,
+      variables
+    };
+  },
+  createGame() {
+    return {
+      query: `
+        mutation GameCreate($input: GameCreateInput!) {
+          gameCreate(input: $input) {
+            ${GAME_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  updateGame() {
+    return {
+      query: `
+        mutation GameUpdate($id: UUID!, $input: GameUpdateInput!) {
+          gameUpdate(id: $id, input: $input) {
+            ${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}
+          }
+        }
+      `
+    };
+  },
+  listDatasets(params) {
+    const variables = { publisherId: params.publisherId };
+    const args = ["publisherId: $publisherId"];
+    const defs = ["$publisherId: UUID!"];
+    if (params.gameId !== void 0) {
+      defs.push("$gameId: UUID");
+      args.push("gameId: $gameId");
+      variables["gameId"] = params.gameId;
+    }
+    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.includeArchived !== void 0) {
+      defs.push("$includeArchived: Boolean");
+      args.push("includeArchived: $includeArchived");
+      variables["includeArchived"] = params.includeArchived;
+    }
+    if (params.purpose !== void 0) {
+      defs.push("$purpose: DatasetPurpose");
+      args.push("purpose: $purpose");
+      variables["purpose"] = params.purpose;
+    }
+    return {
+      query: `
+        query Datasets(${defs.join(", ")}) {
+          datasets(${args.join(", ")}) {
+            ${connectionFields(`${DATASET_FIELDS}
+${SCHEMA_FIELDS}`)}
+          }
+        }
+      `,
+      variables
+    };
+  },
+  dataset(params) {
+    const variables = {};
+    const args = [];
+    const defs = [];
+    if (params.id !== void 0) {
+      defs.push("$id: UUID");
+      args.push("id: $id");
+      variables["id"] = params.id;
+    }
+    if (params.publisherId !== void 0) {
+      defs.push("$publisherId: UUID");
+      args.push("publisherId: $publisherId");
+      variables["publisherId"] = params.publisherId;
+    }
+    if (params.gameId !== void 0) {
+      defs.push("$gameId: UUID");
+      args.push("gameId: $gameId");
+      variables["gameId"] = params.gameId;
+    }
+    if (params.datasetKey !== void 0) {
+      defs.push("$datasetKey: String");
+      args.push("datasetKey: $datasetKey");
+      variables["datasetKey"] = params.datasetKey;
+    }
+    return {
+      query: `
+        query Dataset(${defs.join(", ")}) {
+          dataset(${args.join(", ")}) {
+            ${DATASET_FIELDS}
+            ${SCHEMA_FIELDS}
+          }
+        }
+      `,
+      variables
+    };
+  },
+  // 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 selectedRecordFields = recordFields({ includePricing: params.includePricing });
+    const nodeFields = includeResolvedLinks ? `${selectedRecordFields}
+${RESOLVED_LINKS_FIELDS}` : selectedRecordFields;
+    return {
+      query: `
+        query SearchRecords(${defs.join(", ")}) {
+          searchRecords(${args.join(", ")}) {
+            ${connectionFields(nodeFields)}
+          }
+        }
+      `,
+      variables
+    };
+  },
+  fetchRecordById(params = {}) {
+    return {
+      query: `
+        query FetchRecord($id: UUID!) {
+          fetchRecord(id: $id) {
+            ${recordFields(params)}
+          }
+        }
+      `
+    };
+  },
+  fetchRecordByIdentifier(params = {}) {
+    return {
+      query: `
+        query FetchRecordByIdentifier($publisherSlug: String!, $gameKey: String!, $datasetKey: String!, $identifier: String!) {
+          fetchRecordByIdentifier(publisherSlug: $publisherSlug, gameKey: $gameKey, datasetKey: $datasetKey, identifier: $identifier) {
+            ${recordFields(params)}
+          }
+        }
+      `
+    };
+  },
+  fetchRecordsByIdentifier(params = {}) {
+    return {
+      query: `
+        query FetchRecordsByIdentifier($publisherSlug: String!, $gameKey: String!, $datasetKey: String!, $identifiers: [String!]!) {
+          fetchRecordsByIdentifier(publisherSlug: $publisherSlug, gameKey: $gameKey, datasetKey: $datasetKey, identifiers: $identifiers) {
+            ${recordFields(params)}
+          }
+        }
+      `
+    };
+  },
+  fetchRecords(params = {}) {
+    return {
+      query: `
+        query FetchRecords($ids: [UUID!]!) {
+          fetchRecords(ids: $ids) {
+            ${recordFields(params)}
+          }
+        }
+      `
+    };
+  },
+  listDatasetRecords(params) {
+    const variables = { datasetId: params.datasetId };
+    const args = ["datasetId: $datasetId"];
+    const defs = ["$datasetId: UUID!"];
+    if (params.filter !== void 0) {
+      defs.push("$filter: JSON");
+      args.push("filter: $filter");
+      variables["filter"] = params.filter;
+    }
+    if (params.orderBy !== void 0) {
+      defs.push("$orderBy: DatasetRecordOrderByInput");
+      args.push("orderBy: $orderBy");
+      variables["orderBy"] = params.orderBy;
+    }
+    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.last !== void 0) {
+      defs.push("$last: Int");
+      args.push("last: $last");
+      variables["last"] = params.last;
+    }
+    if (params.before !== void 0) {
+      defs.push("$before: String");
+      args.push("before: $before");
+      variables["before"] = params.before;
+    }
+    if (params.validateSchema !== void 0) {
+      defs.push("$validateSchema: Boolean");
+      args.push("validateSchema: $validateSchema");
+      variables["validateSchema"] = params.validateSchema;
+    }
+    return {
+      query: `
+        query DatasetRecords(${defs.join(", ")}) {
+          datasetRecords(${args.join(", ")}) {
+            ${connectionFields(RECORD_FIELDS)}
+          }
+        }
+      `,
+      variables
+    };
+  },
+  datasetRecord(params) {
+    const variables = {};
+    const args = [];
+    const defs = [];
+    if (params.id !== void 0) {
+      defs.push("$id: UUID");
+      args.push("id: $id");
+      variables["id"] = params.id;
+    }
+    if (params.datasetId !== void 0) {
+      defs.push("$datasetId: UUID");
+      args.push("datasetId: $datasetId");
+      variables["datasetId"] = params.datasetId;
+    }
+    if (params.identifier !== void 0) {
+      defs.push("$identifier: String");
+      args.push("identifier: $identifier");
+      variables["identifier"] = params.identifier;
+    }
+    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.datasetKey !== void 0) {
+      defs.push("$datasetKey: String");
+      args.push("datasetKey: $datasetKey");
+      variables["datasetKey"] = params.datasetKey;
+    }
+    if (params.recordId !== void 0) {
+      defs.push("$recordId: UUID");
+      args.push("recordId: $recordId");
+      variables["recordId"] = params.recordId;
+    }
+    if (params.resolveLinks !== void 0) {
+      defs.push("$resolveLinks: [String!]");
+      args.push("resolveLinks: $resolveLinks");
+      variables["resolveLinks"] = params.resolveLinks;
+    }
+    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 selectedRecordFields = recordFields({ includePricing: params.includePricing });
+    const fields = includeResolvedLinks ? `${selectedRecordFields}
+${RESOLVED_LINKS_FIELDS}` : selectedRecordFields;
+    return {
+      query: `
+        query DatasetRecord(${defs.join(", ")}) {
+          datasetRecord(${args.join(", ")}) {
+            ${fields}
+          }
+        }
+      `,
+      variables
+    };
+  },
+  upsertDatasetRecords() {
+    return {
+      query: `
+        mutation DatasetRecordsUpsert($input: DatasetRecordsUpsertInput!) {
+          datasetRecordsUpsert(input: $input) {
+            ${DATASET_RECORDS_UPSERT_PAYLOAD_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  deleteDatasetRecords() {
+    return {
+      query: `
+        mutation DatasetRecordsDelete($input: DatasetRecordsDeleteInput!) {
+          datasetRecordsDelete(input: $input) {
+            ${DATASET_RECORD_DELETE_JOB_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  datasetRecordDeleteJob() {
+    return {
+      query: `
+        query DatasetRecordDeleteJob($id: UUID!) {
+          datasetRecordDeleteJob(id: $id) {
+            ${DATASET_RECORD_DELETE_JOB_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  datasetRecordDeleteJobs(params) {
+    const variables = { publisherId: params.publisherId };
+    const args = ["publisherId: $publisherId"];
+    const defs = ["$publisherId: UUID!"];
+    if (params.datasetId !== void 0) {
+      defs.push("$datasetId: UUID");
+      args.push("datasetId: $datasetId");
+      variables["datasetId"] = params.datasetId;
+    }
+    if (params.status !== void 0) {
+      defs.push("$status: DatasetRecordDeleteJobStatus");
+      args.push("status: $status");
+      variables["status"] = params.status;
+    }
+    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;
+    }
+    return {
+      query: `
+        query DatasetRecordDeleteJobs(${defs.join(", ")}) {
+          datasetRecordDeleteJobs(${args.join(", ")}) {
+            ${connectionFields(DATASET_RECORD_DELETE_JOB_FIELDS)}
+          }
+        }
+      `,
+      variables
+    };
+  },
+  datasetImportPreview() {
+    return {
+      query: `
+        query DatasetImportPreview($input: DatasetImportPreviewInput!) {
+          datasetImportPreview(input: $input) {
+            ${DATASET_IMPORT_PREVIEW_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  datasetImportValidate() {
+    return {
+      query: `
+        query DatasetImportValidate($input: DatasetImportValidateInput!) {
+          datasetImportValidate(input: $input) {
+            ${BULK_IMPORT_RESULT_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  datasetImportFromFile() {
+    return {
+      query: `
+        mutation DatasetImportFromFile($input: DatasetImportFromFileInput!) {
+          datasetImportFromFile(input: $input) {
+            ${IMPORT_JOB_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  datasetImportFromPayload() {
+    return {
+      query: `
+        mutation DatasetImportFromPayload($input: DatasetImportFromPayloadInput!) {
+          datasetImportFromPayload(input: $input) {
+            ${IMPORT_JOB_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  datasetImportFromUrl() {
+    return {
+      query: `
+        mutation DatasetImportFromUrl($input: DatasetImportFromUrlInput!) {
+          datasetImportFromUrl(input: $input) {
+            ${IMPORT_JOB_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  importJob() {
+    return {
+      query: `
+        query ImportJob($id: UUID!) {
+          importJob(id: $id) {
+            ${IMPORT_JOB_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  importJobs(params) {
+    const variables = { publisherId: params.publisherId };
+    const args = ["publisherId: $publisherId"];
+    const defs = ["$publisherId: UUID!"];
+    if (params.datasetId !== void 0) {
+      defs.push("$datasetId: UUID");
+      args.push("datasetId: $datasetId");
+      variables["datasetId"] = params.datasetId;
+    }
+    if (params.status !== void 0) {
+      defs.push("$status: ImportJobStatus");
+      args.push("status: $status");
+      variables["status"] = params.status;
+    }
+    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;
+    }
     return {
       query: `
-        query SearchPublishers${defStr} {
-          searchPublishers${argStr} {
-            ${connectionFields(PUBLISHER_FIELDS)}
+        query ImportJobs(${defs.join(", ")}) {
+          importJobs(${args.join(", ")}) {
+            ${connectionFields(IMPORT_JOB_FIELDS)}
           }
         }
       `,
       variables
     };
   },
-  fetchPublisherById() {
+  importJobCancel() {
     return {
       query: `
-        query FetchPublisher($id: UUID!) {
-          fetchPublisher(id: $id) {
-            ${PUBLISHER_FIELDS}
+        mutation ImportJobCancel($id: UUID!) {
+          importJobCancel(id: $id) {
+            ${IMPORT_JOB_FIELDS}
           }
         }
       `
     };
   },
-  fetchPublisherBySlug() {
+  importJobLogs(params) {
+    const variables = { importJobId: params.importJobId };
+    const args = ["id: $importJobId"];
+    const logArgs = [];
+    const defs = ["$importJobId: UUID!"];
+    if (params.level !== void 0) {
+      defs.push("$level: ImportLogLevel");
+      logArgs.push("level: $level");
+      variables["level"] = params.level;
+    }
+    if (params.datasetKey !== void 0) {
+      defs.push("$datasetKey: String");
+      logArgs.push("datasetKey: $datasetKey");
+      variables["datasetKey"] = params.datasetKey;
+    }
+    if (params.first !== void 0) {
+      defs.push("$first: Int");
+      logArgs.push("first: $first");
+      variables["first"] = params.first;
+    }
+    if (params.after !== void 0) {
+      defs.push("$after: String");
+      logArgs.push("after: $after");
+      variables["after"] = params.after;
+    }
+    const logArgStr = logArgs.length > 0 ? `(${logArgs.join(", ")})` : "";
     return {
       query: `
-        query FetchPublisher($slug: String!) {
-          fetchPublisher(slug: $slug) {
-            ${PUBLISHER_FIELDS}
+        query ImportJobLogs(${defs.join(", ")}) {
+          importJob(${args.join(", ")}) {
+            logs${logArgStr} {
+              ${connectionFields(IMPORT_JOB_LOG_FIELDS)}
+            }
           }
         }
-      `
+      `,
+      variables
     };
   },
-  fetchPublishers() {
+  gameImportPreview() {
     return {
       query: `
-        query FetchPublishers($slugs: [String!]!) {
-          fetchPublishers(slugs: $slugs) {
-            ${PUBLISHER_FIELDS}
+        query GameImportPreview($input: GameImportPreviewInput!) {
+          gameImportPreview(input: $input) {
+            ${GAME_IMPORT_PREVIEW_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(", ")})` : "";
+  gameImportFromFile() {
     return {
       query: `
-        query SearchGames${defStr} {
-          searchGames${argStr} {
-            ${connectionFields(GAME_FIELDS)}
+        mutation GameImportFromFile($input: GameImportFromFileInput!) {
+          gameImportFromFile(input: $input) {
+            ${GAME_IMPORT_JOB_FIELDS}
           }
         }
-      `,
-      variables
+      `
     };
   },
-  fetchGameById() {
+  gameImportFromPayload() {
     return {
       query: `
-        query FetchGame($id: UUID!) {
-          fetchGame(id: $id) {
-            ${GAME_FIELDS}
+        mutation GameImportFromPayload($input: GameImportFromPayloadInput!) {
+          gameImportFromPayload(input: $input) {
+            ${GAME_IMPORT_JOB_FIELDS}
           }
         }
       `
     };
   },
-  fetchGameByKeys() {
+  gameImportFromUrl() {
     return {
       query: `
-        query FetchGame($publisherSlug: String!, $gameKey: String!) {
-          fetchGame(publisherSlug: $publisherSlug, gameKey: $gameKey) {
-            ${GAME_FIELDS}
+        mutation GameImportFromUrl($input: GameImportFromUrlInput!) {
+          gameImportFromUrl(input: $input) {
+            ${GAME_IMPORT_JOB_FIELDS}
           }
         }
       `
     };
   },
-  fetchGames() {
+  gameImportJob() {
     return {
       query: `
-        query FetchGames($ids: [UUID!]!) {
-          fetchGames(ids: $ids) {
-            ${GAME_FIELDS}
+        query GameImportJob($id: UUID!) {
+          gameImportJob(id: $id) {
+            ${GAME_IMPORT_JOB_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;
+  gameImportJobs(params) {
+    const variables = { gameId: params.gameId };
+    const args = ["gameId: $gameId"];
+    const defs = ["$gameId: UUID!"];
+    if (params.status !== void 0) {
+      defs.push("$status: ImportJobStatus");
+      args.push("status: $status");
+      variables["status"] = params.status;
     }
     if (params.first !== void 0) {
       defs.push("$first: Int");
@@ -1064,86 +2179,99 @@ var QueryBuilder = {
       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)}
+        query GameImportJobs(${defs.join(", ")}) {
+          gameImportJobs(${args.join(", ")}) {
+            ${connectionFields(GAME_IMPORT_JOB_FIELDS)}
           }
         }
       `,
       variables
     };
   },
-  fetchDatasetById() {
+  gameImportJobCancel() {
     return {
       query: `
-        query FetchDataset($id: UUID!) {
-          fetchDataset(id: $id) {
-            ${DATASET_FIELDS}
-            ${SCHEMA_FIELDS}
+        mutation GameImportJobCancel($id: UUID!) {
+          gameImportJobCancel(id: $id) {
+            ${GAME_IMPORT_JOB_FIELDS}
           }
         }
       `
     };
   },
-  fetchDatasetByKeys() {
+  file() {
     return {
       query: `
-        query FetchDataset($publisherSlug: String!, $gameKey: String!, $datasetKey: String!) {
-          fetchDataset(publisherSlug: $publisherSlug, gameKey: $gameKey, datasetKey: $datasetKey) {
-            ${DATASET_FIELDS}
-            ${SCHEMA_FIELDS}
+        query File($id: UUID!) {
+          file(id: $id) {
+            ${FILE_FIELDS}
           }
         }
       `
     };
   },
-  fetchDatasets() {
+  fileUploadRequest() {
     return {
       query: `
-        query FetchDatasets($ids: [UUID!]!) {
-          fetchDatasets(ids: $ids) {
-            ${DATASET_FIELDS}
+        mutation FileUploadRequest($input: FileUploadInput!) {
+          fileUploadRequest(input: $input) {
+            ${PRESIGNED_UPLOAD_FIELDS}
           }
         }
       `
     };
   },
-  // Records
-  searchRecords(params) {
-    const variables = {
-      publisherSlug: params.publisherSlug,
-      gameKey: params.gameKey,
-      datasetKey: params.datasetKey
+  fileUploadConfirm() {
+    return {
+      query: `
+        mutation FileUploadConfirm($id: UUID!) {
+          fileUploadConfirm(id: $id) {
+            ${FILE_FIELDS}
+          }
+        }
+      `
     };
-    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;
+  },
+  fileDelete() {
+    return {
+      query: `
+        mutation FileDelete($id: UUID!) {
+          fileDelete(id: $id)
+        }
+      `
+    };
+  },
+  exportJob() {
+    return {
+      query: `
+        query ExportJob($id: UUID!) {
+          exportJob(id: $id) {
+            ${EXPORT_JOB_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  exportJobs(params) {
+    const variables = { publisherId: params.publisherId };
+    const args = ["publisherId: $publisherId"];
+    const defs = ["$publisherId: UUID!"];
+    if (params.gameId !== void 0) {
+      defs.push("$gameId: UUID");
+      args.push("gameId: $gameId");
+      variables["gameId"] = params.gameId;
     }
-    if (params.orderBy !== void 0) {
-      defs.push("$orderBy: String");
-      args.push("orderBy: $orderBy");
-      variables["orderBy"] = params.orderBy;
+    if (params.datasetId !== void 0) {
+      defs.push("$datasetId: UUID");
+      args.push("datasetId: $datasetId");
+      variables["datasetId"] = params.datasetId;
     }
-    if (params.resolveLinks !== void 0) {
-      defs.push("$resolveLinks: [String!]");
-      args.push("resolveLinks: $resolveLinks");
-      variables["resolveLinks"] = params.resolveLinks;
+    if (params.status !== void 0) {
+      defs.push("$status: ExportJobStatus");
+      args.push("status: $status");
+      variables["status"] = params.status;
     }
     if (params.first !== void 0) {
       defs.push("$first: Int");
@@ -1155,65 +2283,45 @@ var QueryBuilder = {
       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 selectedRecordFields = recordFields({ includePricing: params.includePricing });
-    const nodeFields = includeResolvedLinks ? `${selectedRecordFields}
-${RESOLVED_LINKS_FIELDS}` : selectedRecordFields;
     return {
       query: `
-        query SearchRecords(${defs.join(", ")}) {
-          searchRecords(${args.join(", ")}) {
-            ${connectionFields(nodeFields)}
+        query ExportJobs(${defs.join(", ")}) {
+          exportJobs(${args.join(", ")}) {
+            ${connectionFields(EXPORT_JOB_FIELDS)}
           }
         }
       `,
       variables
     };
   },
-  fetchRecordById(params = {}) {
-    return {
-      query: `
-        query FetchRecord($id: UUID!) {
-          fetchRecord(id: $id) {
-            ${recordFields(params)}
-          }
-        }
-      `
-    };
-  },
-  fetchRecordByIdentifier(params = {}) {
+  datasetExport() {
     return {
       query: `
-        query FetchRecordByIdentifier($publisherSlug: String!, $gameKey: String!, $datasetKey: String!, $identifier: String!) {
-          fetchRecordByIdentifier(publisherSlug: $publisherSlug, gameKey: $gameKey, datasetKey: $datasetKey, identifier: $identifier) {
-            ${recordFields(params)}
+        mutation DatasetExport($input: DatasetExportInput!) {
+          datasetExport(input: $input) {
+            ${EXPORT_JOB_FIELDS}
           }
         }
       `
     };
   },
-  fetchRecordsByIdentifier(params = {}) {
+  exportJobCancel() {
     return {
       query: `
-        query FetchRecordsByIdentifier($publisherSlug: String!, $gameKey: String!, $datasetKey: String!, $identifiers: [String!]!) {
-          fetchRecordsByIdentifier(publisherSlug: $publisherSlug, gameKey: $gameKey, datasetKey: $datasetKey, identifiers: $identifiers) {
-            ${recordFields(params)}
+        mutation ExportJobCancel($id: UUID!) {
+          exportJobCancel(id: $id) {
+            ${EXPORT_JOB_FIELDS}
           }
         }
       `
     };
   },
-  fetchRecords(params = {}) {
+  exportJobRefreshUrl() {
     return {
       query: `
-        query FetchRecords($ids: [UUID!]!) {
-          fetchRecords(ids: $ids) {
-            ${recordFields(params)}
+        mutation ExportJobRefreshUrl($id: UUID!) {
+          exportJobRefreshUrl(id: $id) {
+            ${EXPORT_JOB_FIELDS}
           }
         }
       `
@@ -1647,9 +2755,19 @@ ${RESOLVED_LINKS_FIELDS}` : selectedRecordFields;
     };
   },
   deckImportFormats(params) {
-    const variables = { gameId: params.gameId };
-    const args = ["gameId: $gameId"];
-    const defs = ["$gameId: UUID!"];
+    const variables = {};
+    const args = [];
+    const defs = [];
+    if (params.publisherId !== void 0) {
+      defs.push("$publisherId: UUID");
+      args.push("publisherId: $publisherId");
+      variables["publisherId"] = params.publisherId;
+    }
+    if (params.gameId !== void 0) {
+      defs.push("$gameId: UUID");
+      args.push("gameId: $gameId");
+      variables["gameId"] = params.gameId;
+    }
     if (params.includeArchived !== void 0) {
       defs.push("$includeArchived: Boolean");
       args.push("includeArchived: $includeArchived");
@@ -1665,10 +2783,12 @@ ${RESOLVED_LINKS_FIELDS}` : selectedRecordFields;
       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 DeckImportFormats(${defs.join(", ")}) {
-          deckImportFormats(${args.join(", ")}) {
+        query DeckImportFormats${defStr} {
+          deckImportFormats${argStr} {
             ${connectionFields(DECK_IMPORT_FORMAT_DEFINITION_FIELDS)}
           }
         }
@@ -1679,8 +2799,8 @@ ${RESOLVED_LINKS_FIELDS}` : selectedRecordFields;
   deckImportFormat() {
     return {
       query: `
-        query DeckImportFormat($id: UUID!) {
-          deckImportFormat(id: $id) {
+        query DeckImportFormat($id: UUID, $gameId: UUID, $key: String) {
+          deckImportFormat(id: $id, gameId: $gameId, key: $key) {
             ${DECK_IMPORT_FORMAT_DEFINITION_FIELDS}
           }
         }
@@ -2183,6 +3303,51 @@ ${RESOLVED_LINKS_FIELDS}` : selectedRecordFields;
   deckApiApplicationAccessRevokeVariables(deckId, apiApplicationId) {
     return { deckId, apiApplicationId };
   },
+  gameCreateVariables(input) {
+    return { input };
+  },
+  gameUpdateVariables(id, input) {
+    return { id, input };
+  },
+  datasetImportPreviewVariables(input) {
+    return { input };
+  },
+  datasetImportValidateVariables(input) {
+    return { input };
+  },
+  datasetImportFromFileVariables(input) {
+    return { input };
+  },
+  datasetImportFromPayloadVariables(input) {
+    return { input };
+  },
+  datasetImportFromUrlVariables(input) {
+    return { input };
+  },
+  gameImportPreviewVariables(input) {
+    return { input };
+  },
+  gameImportFromFileVariables(input) {
+    return { input };
+  },
+  gameImportFromPayloadVariables(input) {
+    return { input };
+  },
+  gameImportFromUrlVariables(input) {
+    return { input };
+  },
+  datasetRecordsUpsertVariables(input) {
+    return { input };
+  },
+  datasetRecordsDeleteVariables(input) {
+    return { input };
+  },
+  fileUploadRequestVariables(input) {
+    return { input };
+  },
+  datasetExportVariables(input) {
+    return { input };
+  },
   // API Key Info
   fetchMe() {
     return {