@carddb/core 0.4.5 → 0.5.0

package/dist/index.js

@@ -446,6 +446,22 @@ var SCHEMA_FIELDS = `
     }
   }
 `;
+var DATASET_FILTER_VALUE_CONNECTION_FIELDS = `
+  field
+  edges {
+    cursor
+    node {
+      value
+      count
+    }
+  }
+  pageInfo {
+    hasNextPage
+    hasPreviousPage
+    startCursor
+    endCursor
+  }
+`;
 var OBJECT_FIELD_FIELDS = `
   id
   objectTypeId
@@ -580,6 +596,103 @@ var DECK_VALIDATION_FIELDS = `
   }
   checkedAt
 `;
+var RULESET_VERSION_FIELDS = `
+  id
+  rulesetId
+  versionLabel
+  status
+  rules
+  sectionDefinitions {
+    ${DECK_SECTION_DEFINITION_FIELDS}
+  }
+  cardDatasetId
+  cardDatasetVersionId
+  sourceDatasetId
+  sourceDatasetVersionId
+  sourceDatasetRecordId
+  sourceRecordIdentifier
+  rulesFingerprint
+  effectiveAt
+  changelog
+  createdByAccountId
+  publishedByAccountId
+  publishedAt
+  supersededAt
+  createdAt
+  updatedAt
+`;
+var RULESET_FIELDS = `
+  id
+  gameId
+  game {
+    id
+    key
+    name
+  }
+  key
+  name
+  description
+  tags
+  sortOrder
+  currentVersionId
+  currentVersion {
+    ${RULESET_VERSION_FIELDS}
+  }
+  archivedAt
+  isArchived
+  createdAt
+  updatedAt
+`;
+var DECK_VALIDATION_RULES_FIELDS = `
+  rulesetId
+  rulesetVersionId
+  rulesetKey
+  rulesetVersionLabel
+  rules
+  sections {
+    ${DECK_SECTION_DEFINITION_FIELDS}
+  }
+`;
+var RULESET_VALIDATION_IMPACT_DECK_FIELDS = `
+  deckId
+  title
+  slug
+  state
+  hasUnpublishedChanges
+  valid
+  blockerCount
+  warningCount
+  affectedEntryCount
+  issues {
+    ${DECK_VALIDATION_ISSUE_FIELDS}
+  }
+`;
+var RULESET_VALIDATION_IMPACT_FIELDS = `
+  rulesetId
+  rulesetVersionId
+  checkedAt
+  affectedDeckCount
+  invalidDeckCount
+  blockerCount
+  warningCount
+  results {
+    ${RULESET_VALIDATION_IMPACT_DECK_FIELDS}
+  }
+`;
+var RULESET_VERSION_DRAFT_IMPORT_PREVIEW_FIELDS = `
+  sourceDatasetId
+  sourceDatasetVersionId
+  sourceDatasetRecordId
+  sourceRecordIdentifier
+  rules
+  sectionDefinitions {
+    ${DECK_SECTION_DEFINITION_FIELDS}
+  }
+  rulesFingerprint
+  summary
+  sectionCount
+  copyLimitCount
+`;
 var DECK_DIFF_FIELDS = `
   deckId
   fromVersionId
@@ -1730,6 +1843,67 @@ var QueryBuilder = {
       `
     };
   },
+  fetchDatasetFilterValues(params) {
+    if (params.fields.length === 0) {
+      throw new ValidationError("fields must contain at least one field key");
+    }
+    const byId = params.id !== void 0;
+    const byKeys = params.publisherSlug !== void 0 && params.gameKey !== void 0 && params.datasetKey !== void 0;
+    if (!byId && !byKeys) {
+      throw new ValidationError("provide either id or publisherSlug, gameKey, and datasetKey");
+    }
+    const definitions = ["$fields: [String!]!"];
+    const filterValueArgs = ["fields: $fields"];
+    const variables = { fields: params.fields };
+    if (params.search !== void 0) {
+      definitions.push("$search: String");
+      filterValueArgs.push("search: $search");
+      variables["search"] = params.search;
+    }
+    if (params.includeCounts !== void 0) {
+      definitions.push("$includeCounts: Boolean");
+      filterValueArgs.push("includeCounts: $includeCounts");
+      variables["includeCounts"] = params.includeCounts;
+    }
+    if (params.first !== void 0) {
+      definitions.push("$first: Int");
+      filterValueArgs.push("first: $first");
+      variables["first"] = params.first;
+    }
+    if (params.after !== void 0) {
+      definitions.push("$after: String");
+      filterValueArgs.push("after: $after");
+      variables["after"] = params.after;
+    }
+    const datasetArgs = [];
+    if (byId) {
+      definitions.push("$id: UUID!");
+      datasetArgs.push("id: $id");
+      variables["id"] = params.id;
+    } else {
+      definitions.push("$publisherSlug: String!", "$gameKey: String!", "$datasetKey: String!");
+      datasetArgs.push(
+        "publisherSlug: $publisherSlug",
+        "gameKey: $gameKey",
+        "datasetKey: $datasetKey"
+      );
+      variables["publisherSlug"] = params.publisherSlug;
+      variables["gameKey"] = params.gameKey;
+      variables["datasetKey"] = params.datasetKey;
+    }
+    return {
+      query: `
+        query FetchDatasetFilterValues(${definitions.join(", ")}) {
+          fetchDataset(${datasetArgs.join(", ")}) {
+            filterValues(${filterValueArgs.join(", ")}) {
+              ${DATASET_FILTER_VALUE_CONNECTION_FIELDS}
+            }
+          }
+        }
+      `,
+      variables
+    };
+  },
   listDatasets(params) {
     const variables = { publisherId: params.publisherId };
     const args = ["publisherId: $publisherId"];
@@ -2635,6 +2809,261 @@ ${RESOLVED_LINKS_FIELDS}` : selectedRecordFields;
       `
     };
   },
+  // Rulesets
+  rulesets(params) {
+    const variables = { gameId: params.gameId };
+    const args = ["gameId: $gameId"];
+    const defs = ["$gameId: UUID!"];
+    if (params.includeArchived !== void 0) {
+      defs.push("$includeArchived: Boolean");
+      args.push("includeArchived: $includeArchived");
+      variables["includeArchived"] = params.includeArchived;
+    }
+    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 Rulesets(${defs.join(", ")}) {
+          rulesets(${args.join(", ")}) {
+            ${connectionFields(RULESET_FIELDS)}
+          }
+        }
+      `,
+      variables
+    };
+  },
+  publicRulesets(params) {
+    const variables = { gameId: params.gameId };
+    const args = ["gameId: $gameId"];
+    const defs = ["$gameId: 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;
+    }
+    return {
+      query: `
+        query PublicRulesets(${defs.join(", ")}) {
+          publicRulesets(${args.join(", ")}) {
+            ${connectionFields(RULESET_FIELDS)}
+          }
+        }
+      `,
+      variables
+    };
+  },
+  ruleset(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.gameId !== void 0) {
+      defs.push("$gameId: UUID");
+      args.push("gameId: $gameId");
+      variables["gameId"] = params.gameId;
+    }
+    if (params.key !== void 0) {
+      defs.push("$key: String");
+      args.push("key: $key");
+      variables["key"] = params.key;
+    }
+    return {
+      query: `
+        query Ruleset(${defs.join(", ")}) {
+          ruleset(${args.join(", ")}) {
+            ${RULESET_FIELDS}
+          }
+        }
+      `,
+      variables
+    };
+  },
+  rulesetVersions(params) {
+    const variables = { rulesetId: params.rulesetId };
+    const args = ["rulesetId: $rulesetId"];
+    const defs = ["$rulesetId: UUID!"];
+    if (params.status !== void 0) {
+      defs.push("$status: RulesetVersionStatus");
+      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 RulesetVersions(${defs.join(", ")}) {
+          rulesetVersions(${args.join(", ")}) {
+            ${connectionFields(RULESET_VERSION_FIELDS)}
+          }
+        }
+      `,
+      variables
+    };
+  },
+  rulesetVersion() {
+    return {
+      query: `
+        query RulesetVersion($id: UUID!) {
+          rulesetVersion(id: $id) {
+            ${RULESET_VERSION_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  rulesetValidationRules() {
+    return {
+      query: `
+        query RulesetValidationRules($gameId: UUID!, $rulesetKey: String!, $rulesetVersionId: UUID) {
+          rulesetValidationRules(gameId: $gameId, rulesetKey: $rulesetKey, rulesetVersionId: $rulesetVersionId)
+        }
+      `
+    };
+  },
+  deckValidationRules() {
+    return {
+      query: `
+        query DeckValidationRules($gameId: UUID!, $rulesetKey: String!, $rulesetVersionId: UUID) {
+          deckValidationRules(gameId: $gameId, rulesetKey: $rulesetKey, rulesetVersionId: $rulesetVersionId) {
+            ${DECK_VALIDATION_RULES_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  rulesetVersionDraftImportPreview() {
+    return {
+      query: `
+        query RulesetVersionDraftImportPreview($rulesetId: UUID!, $input: RulesetVersionDraftImportFromDatasetRecordInput!) {
+          rulesetVersionDraftImportPreview(rulesetId: $rulesetId, input: $input) {
+            ${RULESET_VERSION_DRAFT_IMPORT_PREVIEW_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  rulesetValidationImpact(params) {
+    const variables = { rulesetVersionId: params.rulesetVersionId };
+    const args = ["rulesetVersionId: $rulesetVersionId"];
+    const defs = ["$rulesetVersionId: UUID!"];
+    if (params.first !== void 0) {
+      defs.push("$first: Int");
+      args.push("first: $first");
+      variables["first"] = params.first;
+    }
+    return {
+      query: `
+        query RulesetValidationImpact(${defs.join(", ")}) {
+          rulesetValidationImpact(${args.join(", ")}) {
+            ${RULESET_VALIDATION_IMPACT_FIELDS}
+          }
+        }
+      `,
+      variables
+    };
+  },
+  createRuleset() {
+    return {
+      query: `
+        mutation RulesetCreate($input: RulesetCreateInput!) {
+          rulesetCreate(input: $input) {
+            ${RULESET_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  updateRuleset() {
+    return {
+      query: `
+        mutation RulesetUpdate($id: UUID!, $input: RulesetUpdateInput!) {
+          rulesetUpdate(id: $id, input: $input) {
+            ${RULESET_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  createRulesetVersionDraft() {
+    return {
+      query: `
+        mutation RulesetVersionDraftCreate($rulesetId: UUID!, $input: RulesetVersionDraftCreateInput!) {
+          rulesetVersionDraftCreate(rulesetId: $rulesetId, input: $input) {
+            ${RULESET_VERSION_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  importRulesetVersionDraftFromDatasetRecord() {
+    return {
+      query: `
+        mutation RulesetVersionDraftImportFromDatasetRecord($rulesetId: UUID!, $input: RulesetVersionDraftImportFromDatasetRecordInput!) {
+          rulesetVersionDraftImportFromDatasetRecord(rulesetId: $rulesetId, input: $input) {
+            ${RULESET_VERSION_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  updateRulesetVersionDraft() {
+    return {
+      query: `
+        mutation RulesetVersionDraftUpdate($id: UUID!, $input: RulesetVersionDraftUpdateInput!) {
+          rulesetVersionDraftUpdate(id: $id, input: $input) {
+            ${RULESET_VERSION_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  publishRulesetVersion() {
+    return {
+      query: `
+        mutation RulesetVersionPublish($id: UUID!, $input: RulesetVersionPublishInput) {
+          rulesetVersionPublish(id: $id, input: $input) {
+            ${RULESET_VERSION_FIELDS}
+          }
+        }
+      `
+    };
+  },
+  activateRulesetVersion() {
+    return {
+      query: `
+        mutation RulesetVersionActivate($id: UUID!) {
+          rulesetVersionActivate(id: $id) {
+            ${RULESET_VERSION_FIELDS}
+          }
+        }
+      `
+    };
+  },
   // Decks
   listMyDecks(params = {}) {
     const variables = {};
@@ -3409,6 +3838,30 @@ ${RESOLVED_LINKS_FIELDS}` : selectedRecordFields;
       `
     };
   },
+  rulesetValidationRulesVariables(gameId, rulesetKey, rulesetVersionId) {
+    return rulesetVersionId === void 0 ? { gameId, rulesetKey } : { gameId, rulesetKey, rulesetVersionId };
+  },
+  rulesetVersionDraftImportPreviewVariables(rulesetId, input) {
+    return { rulesetId, input };
+  },
+  rulesetCreateVariables(input) {
+    return { input };
+  },
+  rulesetUpdateVariables(id, input) {
+    return { id, input };
+  },
+  rulesetVersionDraftCreateVariables(rulesetId, input) {
+    return { rulesetId, input };
+  },
+  rulesetVersionDraftImportFromDatasetRecordVariables(rulesetId, input) {
+    return { rulesetId, input };
+  },
+  rulesetVersionDraftUpdateVariables(id, input) {
+    return { id, input };
+  },
+  rulesetVersionPublishVariables(id, input) {
+    return input === void 0 ? { id } : { id, input };
+  },
   deckCreateVariables(input) {
     return { input: normalizeDeckJsonInput(input) };
   },