@carddb/core 0.4.5 → 0.4.6

package/dist/index.cjs

@@ -633,6 +633,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
@@ -2688,6 +2785,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 = {};
@@ -3462,6 +3814,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) };
   },