@carddb/client 0.4.5 → 0.5.0

package/dist/index.cjs

@@ -902,6 +902,36 @@ var DatasetsResource = class extends BaseResource {
       return result["fetchDatasets"] ?? [];
     });
   }
+  async filterValues(idOrPublisherSlug, fieldsOrGameKey, datasetKeyOrFields, fieldsOrOptions, maybeOptions) {
+    let queryParams;
+    let options;
+    if (Array.isArray(fieldsOrGameKey)) {
+      queryParams = { id: idOrPublisherSlug, fields: fieldsOrGameKey };
+      options = datasetKeyOrFields ?? {};
+    } else {
+      queryParams = {
+        publisherSlug: idOrPublisherSlug,
+        gameKey: fieldsOrGameKey,
+        datasetKey: datasetKeyOrFields,
+        fields: fieldsOrOptions
+      };
+      options = maybeOptions ?? {};
+      this.validateAccess(queryParams.publisherSlug, queryParams.gameKey);
+    }
+    const { query, variables } = core.QueryBuilder.fetchDatasetFilterValues({
+      ...queryParams,
+      search: options.search,
+      includeCounts: options.includeCounts,
+      first: options.first,
+      after: options.after
+    });
+    const key = this.cacheKey("datasets", "filterValues", variables);
+    return this.withCache(key, "datasets", options, async () => {
+      const result = await this.connection.execute(query, variables);
+      const dataset = result["fetchDataset"];
+      return dataset?.filterValues ?? [];
+    });
+  }
 };
 var DecksResource = class extends BaseResource {
   constructor(connection, config) {
@@ -2004,6 +2034,238 @@ var RulesResource = class extends BaseResource {
     });
   }
 };
+var RulesetsResource = class extends BaseResource {
+  constructor(connection, config) {
+    super(connection, config);
+  }
+  /**
+   * List first-class rulesets for a game.
+   */
+  async list(gameId, options = {}) {
+    const { query, variables } = core.QueryBuilder.rulesets({
+      gameId,
+      includeArchived: options.includeArchived,
+      first: options.first,
+      after: options.after
+    });
+    const key = this.cacheKey("rulesets", "list", variables);
+    const data = await this.withCache(key, "rulesets", options, async () => {
+      const result = await this.connection.execute(query, variables);
+      return result["rulesets"];
+    });
+    return new core.Collection(data, {
+      nextPageLoader: async (cursor) => this.list(gameId, { ...options, after: cursor })
+    });
+  }
+  /**
+   * List active public rulesets for a public game.
+   */
+  async listPublic(gameId, options = {}) {
+    const { query, variables } = core.QueryBuilder.publicRulesets({
+      gameId,
+      first: options.first,
+      after: options.after
+    });
+    const key = this.cacheKey("rulesets", "listPublic", variables);
+    const data = await this.withCache(key, "rulesets", options, async () => {
+      const result = await this.connection.execute(query, variables);
+      return result["publicRulesets"];
+    });
+    return new core.Collection(data, {
+      nextPageLoader: async (cursor) => this.listPublic(gameId, { ...options, after: cursor })
+    });
+  }
+  /**
+   * Get one ruleset by UUID.
+   */
+  async get(id, options = {}) {
+    const variables = { id };
+    const key = this.cacheKey("rulesets", "get", variables);
+    return this.withCache(key, "rulesets", options, async () => {
+      const { query, variables: variables2 } = core.QueryBuilder.ruleset({ id });
+      const result = await this.connection.execute(query, variables2);
+      return result["ruleset"] ?? null;
+    });
+  }
+  /**
+   * Get one ruleset by game ID and stable key.
+   */
+  async getByKey(options) {
+    const variables = { gameId: options.gameId, key: options.key };
+    const cacheKey2 = this.cacheKey("rulesets", "getByKey", variables);
+    return this.withCache(cacheKey2, "rulesets", options, async () => {
+      const { query, variables: variables2 } = core.QueryBuilder.ruleset({
+        gameId: options.gameId,
+        key: options.key
+      });
+      const result = await this.connection.execute(query, variables2);
+      return result["ruleset"] ?? null;
+    });
+  }
+  /**
+   * List immutable versions for a ruleset.
+   */
+  async versions(rulesetId, options = {}) {
+    const { query, variables } = core.QueryBuilder.rulesetVersions({
+      rulesetId,
+      status: options.status,
+      first: options.first,
+      after: options.after
+    });
+    const key = this.cacheKey("rulesets", "versions", variables);
+    const data = await this.withCache(key, "rulesets", options, async () => {
+      const result = await this.connection.execute(query, variables);
+      return result["rulesetVersions"];
+    });
+    return new core.Collection(data, {
+      nextPageLoader: async (cursor) => this.versions(rulesetId, { ...options, after: cursor })
+    });
+  }
+  /**
+   * Get one immutable ruleset version by UUID.
+   */
+  async getVersion(id, options = {}) {
+    const key = this.cacheKey("rulesets", "getVersion", { id });
+    return this.withCache(key, "rulesets", options, async () => {
+      const { query } = core.QueryBuilder.rulesetVersion();
+      const result = await this.connection.execute(query, { id });
+      return result["rulesetVersion"] ?? null;
+    });
+  }
+  /**
+   * Get the canonical active rules JSON for a ruleset.
+   */
+  async validationRules(gameId, rulesetKey, options = {}) {
+    const variables = core.QueryBuilder.rulesetValidationRulesVariables(
+      gameId,
+      rulesetKey,
+      options.rulesetVersionId
+    );
+    const key = this.cacheKey("rulesets", "validationRules", variables);
+    return this.withCache(key, "rulesets", options, async () => {
+      const { query } = core.QueryBuilder.rulesetValidationRules();
+      const result = await this.connection.execute(query, variables);
+      return result["rulesetValidationRules"] ?? null;
+    });
+  }
+  /**
+   * Get typed validation rules, including parsed deck sections.
+   */
+  async deckValidationRules(gameId, rulesetKey, options = {}) {
+    const variables = core.QueryBuilder.rulesetValidationRulesVariables(
+      gameId,
+      rulesetKey,
+      options.rulesetVersionId
+    );
+    const key = this.cacheKey("rulesets", "deckValidationRules", variables);
+    return this.withCache(key, "rulesets", options, async () => {
+      const { query } = core.QueryBuilder.deckValidationRules();
+      const result = await this.connection.execute(query, variables);
+      return result["deckValidationRules"] ?? null;
+    });
+  }
+  /**
+   * Preview compiling a legacy formats dataset record into a draft ruleset version.
+   */
+  async previewImport(rulesetId, input) {
+    const { query } = core.QueryBuilder.rulesetVersionDraftImportPreview();
+    const variables = core.QueryBuilder.rulesetVersionDraftImportPreviewVariables(rulesetId, input);
+    const result = await this.connection.execute(query, variables);
+    return result["rulesetVersionDraftImportPreview"];
+  }
+  /**
+   * Preview validation impact for decks that use a ruleset version's parent ruleset.
+   */
+  async validationImpact(rulesetVersionId, options = {}) {
+    const { query, variables } = core.QueryBuilder.rulesetValidationImpact({
+      rulesetVersionId,
+      first: options.first
+    });
+    const key = this.cacheKey("rulesets", "validationImpact", variables);
+    return this.withCache(key, "rulesets", options, async () => {
+      const result = await this.connection.execute(query, variables);
+      return result["rulesetValidationImpact"];
+    });
+  }
+  /**
+   * Create a first-class ruleset. Requires a server-side secret credential.
+   */
+  async create(input) {
+    this.config.requireSecretCredential("rulesets.create");
+    const { query } = core.QueryBuilder.createRuleset();
+    const result = await this.connection.execute(query, core.QueryBuilder.rulesetCreateVariables(input));
+    return result["rulesetCreate"];
+  }
+  /**
+   * Update editable ruleset metadata. Requires a server-side secret credential.
+   */
+  async update(id, input) {
+    this.config.requireSecretCredential("rulesets.update");
+    const { query } = core.QueryBuilder.updateRuleset();
+    const result = await this.connection.execute(
+      query,
+      core.QueryBuilder.rulesetUpdateVariables(id, input)
+    );
+    return result["rulesetUpdate"];
+  }
+  /**
+   * Create a draft ruleset version from an explicit canonical rules payload.
+   */
+  async createDraft(rulesetId, input) {
+    this.config.requireSecretCredential("rulesets.createDraft");
+    const { query } = core.QueryBuilder.createRulesetVersionDraft();
+    const result = await this.connection.execute(
+      query,
+      core.QueryBuilder.rulesetVersionDraftCreateVariables(rulesetId, input)
+    );
+    return result["rulesetVersionDraftCreate"];
+  }
+  /**
+   * Create a draft by compiling a legacy formats dataset record.
+   */
+  async importDraftFromDatasetRecord(rulesetId, input) {
+    this.config.requireSecretCredential("rulesets.importDraftFromDatasetRecord");
+    const { query } = core.QueryBuilder.importRulesetVersionDraftFromDatasetRecord();
+    const result = await this.connection.execute(
+      query,
+      core.QueryBuilder.rulesetVersionDraftImportFromDatasetRecordVariables(rulesetId, input)
+    );
+    return result["rulesetVersionDraftImportFromDatasetRecord"];
+  }
+  /**
+   * Update a draft ruleset version.
+   */
+  async updateDraft(id, input) {
+    this.config.requireSecretCredential("rulesets.updateDraft");
+    const { query } = core.QueryBuilder.updateRulesetVersionDraft();
+    const result = await this.connection.execute(
+      query,
+      core.QueryBuilder.rulesetVersionDraftUpdateVariables(id, input)
+    );
+    return result["rulesetVersionDraftUpdate"];
+  }
+  /**
+   * Publish a draft and make it the current active ruleset version.
+   */
+  async publishVersion(id, input) {
+    this.config.requireSecretCredential("rulesets.publishVersion");
+    const { query } = core.QueryBuilder.publishRulesetVersion();
+    const result = await this.connection.execute(
+      query,
+      core.QueryBuilder.rulesetVersionPublishVariables(id, input)
+    );
+    return result["rulesetVersionPublish"];
+  }
+  /**
+   * Activate an already-published version for rollback.
+   */
+  async activateVersion(id) {
+    this.config.requireSecretCredential("rulesets.activateVersion");
+    const { query } = core.QueryBuilder.activateRulesetVersion();
+    const result = await this.connection.execute(query, { id });
+    return result["rulesetVersionActivate"];
+  }
+};
 var ImportFormatsResource = class extends BaseResource {
   constructor(connection, config) {
     super(connection, config);
@@ -2842,6 +3104,8 @@ var CardDBClient = class _CardDBClient {
   decks;
   /** Rules resource for game rules and deck formats */
   rules;
+  /** First-class rulesets resource for deck validation rules */
+  rulesets;
   /** Publisher-managed import format resource */
   importFormats;
   /** Publisher import job resource */
@@ -2868,6 +3132,7 @@ var CardDBClient = class _CardDBClient {
     this.records = new RecordsResource(this.connection, this.config);
     this.decks = new DecksResource(this.connection, this.config);
     this.rules = new RulesResource(this.connection, this.config);
+    this.rulesets = new RulesetsResource(this.connection, this.config);
     this.importFormats = new ImportFormatsResource(this.connection, this.config);
     this.imports = new ImportsResource(this.connection, this.config);
     this.exports = new ExportsResource(this.connection, this.config);
@@ -2969,6 +3234,7 @@ exports.ImportsResource = ImportsResource;
 exports.PublishersResource = PublishersResource;
 exports.RecordsResource = RecordsResource;
 exports.RulesResource = RulesResource;
+exports.RulesetsResource = RulesetsResource;
 exports.ScanTemplatesResource = ScanTemplatesResource;
 exports.ScansResource = ScansResource;
 exports.cacheKey = cacheKey;