@carddb/client 0.4.5 → 0.5.0

package/dist/index.js

@@ -901,6 +901,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 } = 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) {
@@ -2003,6 +2033,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 } = 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 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 } = 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 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 } = 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 } = 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 } = 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 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 } = 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 = QueryBuilder.rulesetValidationRulesVariables(
+      gameId,
+      rulesetKey,
+      options.rulesetVersionId
+    );
+    const key = this.cacheKey("rulesets", "validationRules", variables);
+    return this.withCache(key, "rulesets", options, async () => {
+      const { query } = 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 = QueryBuilder.rulesetValidationRulesVariables(
+      gameId,
+      rulesetKey,
+      options.rulesetVersionId
+    );
+    const key = this.cacheKey("rulesets", "deckValidationRules", variables);
+    return this.withCache(key, "rulesets", options, async () => {
+      const { query } = 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 } = QueryBuilder.rulesetVersionDraftImportPreview();
+    const variables = 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 } = 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 } = QueryBuilder.createRuleset();
+    const result = await this.connection.execute(query, 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 } = QueryBuilder.updateRuleset();
+    const result = await this.connection.execute(
+      query,
+      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 } = QueryBuilder.createRulesetVersionDraft();
+    const result = await this.connection.execute(
+      query,
+      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 } = QueryBuilder.importRulesetVersionDraftFromDatasetRecord();
+    const result = await this.connection.execute(
+      query,
+      QueryBuilder.rulesetVersionDraftImportFromDatasetRecordVariables(rulesetId, input)
+    );
+    return result["rulesetVersionDraftImportFromDatasetRecord"];
+  }
+  /**
+   * Update a draft ruleset version.
+   */
+  async updateDraft(id, input) {
+    this.config.requireSecretCredential("rulesets.updateDraft");
+    const { query } = QueryBuilder.updateRulesetVersionDraft();
+    const result = await this.connection.execute(
+      query,
+      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 } = QueryBuilder.publishRulesetVersion();
+    const result = await this.connection.execute(
+      query,
+      QueryBuilder.rulesetVersionPublishVariables(id, input)
+    );
+    return result["rulesetVersionPublish"];
+  }
+  /**
+   * Activate an already-published version for rollback.
+   */
+  async activateVersion(id) {
+    this.config.requireSecretCredential("rulesets.activateVersion");
+    const { query } = QueryBuilder.activateRulesetVersion();
+    const result = await this.connection.execute(query, { id });
+    return result["rulesetVersionActivate"];
+  }
+};
 var ImportFormatsResource = class extends BaseResource {
   constructor(connection, config) {
     super(connection, config);
@@ -2841,6 +3103,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 */
@@ -2867,6 +3131,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);
@@ -2946,6 +3211,6 @@ var CardDBClient = class _CardDBClient {
   }
 };
 
-export { BaseResource, CardDBClient, Configuration, Connection, DEFAULT_CACHE_TTL, DEFAULT_ENDPOINT, DEFAULT_MAX_NETWORK_RETRIES, DEFAULT_MAX_RETRIES, DEFAULT_OPEN_TIMEOUT, DEFAULT_RETRY_BASE_DELAY, DEFAULT_RETRY_MAX_DELAY, DEFAULT_TIMEOUT, DatasetsResource, DecksResource, ExportsResource, FilesResource, GamesResource, ImportFormatsResource, ImportsResource, PublishersResource, RecordsResource, RulesResource, ScanTemplatesResource, ScansResource, cacheKey, getRateLimitInfo, getSDKVersion, getUserAgent, readCache, writeCache };
+export { BaseResource, CardDBClient, Configuration, Connection, DEFAULT_CACHE_TTL, DEFAULT_ENDPOINT, DEFAULT_MAX_NETWORK_RETRIES, DEFAULT_MAX_RETRIES, DEFAULT_OPEN_TIMEOUT, DEFAULT_RETRY_BASE_DELAY, DEFAULT_RETRY_MAX_DELAY, DEFAULT_TIMEOUT, DatasetsResource, DecksResource, ExportsResource, FilesResource, GamesResource, ImportFormatsResource, ImportsResource, PublishersResource, RecordsResource, RulesResource, RulesetsResource, ScanTemplatesResource, ScansResource, cacheKey, getRateLimitInfo, getSDKVersion, getUserAgent, readCache, writeCache };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map