@carddb/client 0.4.2 → 0.4.6

package/dist/index.cjs

@@ -921,14 +921,27 @@ var DecksResource = class extends BaseResource {
   /**
    * Fetch a deck by UUID using the ownership-aware `deck` API.
    */
-  async get(id, options = {}) {
-    const key = this.cacheKey("decks", "get", { id });
+  async get(id, options) {
+    const variables = core.QueryBuilder.deckReadVariables(id, options.readState, options.version);
+    const key = this.cacheKey("decks", "get", variables);
     return this.withCache(key, "decks", options, async () => {
       const { query } = core.QueryBuilder.deckById();
-      const result = await this.connection.execute(query, { id });
+      const result = await this.connection.execute(query, variables);
       return result["deck"] ?? null;
     });
   }
+  /**
+   * Fetch mutable draft data for a deck by UUID.
+   */
+  async getDraft(id, options = {}) {
+    return this.get(id, { ...options, readState: "DRAFT" });
+  }
+  /**
+   * Fetch immutable published data for a deck by UUID.
+   */
+  async getPublished(id, options = {}) {
+    return this.get(id, { ...options, readState: "PUBLISHED", version: options.version });
+  }
   /**
    * Fetch one deck owned by the current account or API application.
    */
@@ -976,14 +989,35 @@ var DecksResource = class extends BaseResource {
   /**
    * Fetch by external reference using the ownership-aware `deckByExternalRef` API.
    */
-  async getByExternalRef(externalRef, options = {}) {
-    const key = this.cacheKey("decks", "getByExternalRef", { externalRef });
+  async getByExternalRef(externalRef, options) {
+    const variables = core.QueryBuilder.deckExternalRefReadVariables(
+      externalRef,
+      options.readState,
+      options.version
+    );
+    const key = this.cacheKey("decks", "getByExternalRef", variables);
     return this.withCache(key, "decks", options, async () => {
       const { query } = core.QueryBuilder.deckByExternalRef();
-      const result = await this.connection.execute(query, { externalRef });
+      const result = await this.connection.execute(query, variables);
       return result["deckByExternalRef"] ?? null;
     });
   }
+  /**
+   * Fetch mutable draft data by API-application external reference.
+   */
+  async getDraftByExternalRef(externalRef, options = {}) {
+    return this.getByExternalRef(externalRef, { ...options, readState: "DRAFT" });
+  }
+  /**
+   * Fetch immutable published data by API-application external reference.
+   */
+  async getPublishedByExternalRef(externalRef, options = {}) {
+    return this.getByExternalRef(externalRef, {
+      ...options,
+      readState: "PUBLISHED",
+      version: options.version
+    });
+  }
   /**
    * List decks owned by the current account or API application.
    */
@@ -1086,39 +1120,6 @@ var DecksResource = class extends BaseResource {
       nextPageLoader: async (cursor) => this.listVersions(deckId, { ...options, after: cursor })
     });
   }
-  /**
-   * Fetch current draft data using a revocable preview token.
-   */
-  async preview(token, options = {}) {
-    const key = this.cacheKey("decks", "preview", { token });
-    return this.withCache(key, "decks", options, async () => {
-      const { query } = core.QueryBuilder.deckPreview();
-      const result = await this.connection.execute(query, { token });
-      return result["deckPreview"] ?? null;
-    });
-  }
-  /**
-   * Fetch published embed data using a revocable embed token.
-   */
-  async embed(token, options = {}) {
-    const key = this.cacheKey("decks", "embed", { token });
-    return this.withCache(key, "decks", options, async () => {
-      const { query } = core.QueryBuilder.deckEmbed();
-      const result = await this.connection.execute(query, { token });
-      return result["deckEmbed"] ?? null;
-    });
-  }
-  /**
-   * Fetch token-authorized published data using an exchanged access token.
-   */
-  async access(token, options = {}) {
-    const key = this.cacheKey("decks", "access", { token });
-    return this.withCache(key, "decks", options, async () => {
-      const { query } = core.QueryBuilder.deckAccess();
-      const result = await this.connection.execute(query, { token });
-      return result["deckAccess"] ?? null;
-    });
-  }
   /**
    * Compare the current draft against the latest published version.
    */
@@ -1206,39 +1207,6 @@ var DecksResource = class extends BaseResource {
       return result["deckCollaborators"];
     });
   }
-  /**
-   * List draft preview tokens for a deck.
-   */
-  async listPreviewTokens(deckId, options = {}) {
-    const key = this.cacheKey("decks", "listPreviewTokens", { deckId });
-    return this.withCache(key, "decks", options, async () => {
-      const { query } = core.QueryBuilder.deckPreviewTokens();
-      const result = await this.connection.execute(query, { deckId });
-      return result["deckPreviewTokens"];
-    });
-  }
-  /**
-   * List published embed tokens for a deck.
-   */
-  async listEmbedTokens(deckId, options = {}) {
-    const key = this.cacheKey("decks", "listEmbedTokens", { deckId });
-    return this.withCache(key, "decks", options, async () => {
-      const { query } = core.QueryBuilder.deckEmbedTokens();
-      const result = await this.connection.execute(query, { deckId });
-      return result["deckEmbedTokens"];
-    });
-  }
-  /**
-   * List trusted access token issuers for a deck.
-   */
-  async listAccessTokenIssuers(deckId, options = {}) {
-    const key = this.cacheKey("decks", "listAccessTokenIssuers", { deckId });
-    return this.withCache(key, "decks", options, async () => {
-      const { query } = core.QueryBuilder.deckAccessTokenIssuers();
-      const result = await this.connection.execute(query, { deckId });
-      return result["deckAccessTokenIssuers"];
-    });
-  }
   /**
    * List API applications with explicit access to one owned deck.
    */
@@ -1523,63 +1491,32 @@ var DecksResource = class extends BaseResource {
     return Boolean(result["deckCollaboratorRemove"]);
   }
   /**
-   * Create a revocable draft preview token.
-   */
-  async createPreviewToken(input) {
-    const { query } = core.QueryBuilder.createDeckPreviewToken();
-    const variables = core.QueryBuilder.deckPreviewTokenCreateVariables(input);
-    const result = await this.connection.execute(query, variables);
-    return result["deckPreviewTokenCreate"];
-  }
-  /**
-   * Revoke a draft preview token.
-   */
-  async revokePreviewToken(id) {
-    const { query } = core.QueryBuilder.revokeDeckPreviewToken();
-    const result = await this.connection.execute(query, { id });
-    return Boolean(result["deckPreviewTokenRevoke"]);
-  }
-  /**
-   * Create a revocable published embed token.
+   * Create a unified deck token issuer for the current secret-key API application.
    */
-  async createEmbedToken(input) {
-    const { query } = core.QueryBuilder.createDeckEmbedToken();
-    const variables = core.QueryBuilder.deckEmbedTokenCreateVariables(input);
+  async createTokenIssuer(input) {
+    this.config.requireSecretCredential("decks.createTokenIssuer");
+    const { query } = core.QueryBuilder.createDeckTokenIssuer();
+    const variables = core.QueryBuilder.deckTokenIssuerCreateVariables(input);
     const result = await this.connection.execute(query, variables);
-    return result["deckEmbedTokenCreate"];
+    return result["deckTokenIssuerCreate"];
   }
   /**
-   * Revoke a published embed token.
+   * Revoke a unified deck token issuer.
    */
-  async revokeEmbedToken(id) {
-    const { query } = core.QueryBuilder.revokeDeckEmbedToken();
+  async revokeTokenIssuer(id) {
+    this.config.requireSecretCredential("decks.revokeTokenIssuer");
+    const { query } = core.QueryBuilder.revokeDeckTokenIssuer();
     const result = await this.connection.execute(query, { id });
-    return Boolean(result["deckEmbedTokenRevoke"]);
+    return Boolean(result["deckTokenIssuerRevoke"]);
   }
   /**
-   * Trust the current API application to exchange short-lived deck access tokens.
+   * Revoke only the direct signing key for a unified deck token issuer.
    */
-  async createAccessTokenIssuer(input) {
-    const { query } = core.QueryBuilder.createDeckAccessTokenIssuer();
-    const variables = core.QueryBuilder.deckAccessTokenIssuerCreateVariables(input);
-    const result = await this.connection.execute(query, variables);
-    return result["deckAccessTokenIssuerCreate"];
-  }
-  /**
-   * Revoke a trusted deck access token issuer.
-   */
-  async revokeAccessTokenIssuer(id) {
-    const { query } = core.QueryBuilder.revokeDeckAccessTokenIssuer();
-    const result = await this.connection.execute(query, { id });
-    return Boolean(result["deckAccessTokenIssuerRevoke"]);
-  }
-  /**
-   * Revoke only the direct signing key for a trusted deck access token issuer.
-   */
-  async revokeAccessTokenIssuerSigningKey(id) {
-    const { query } = core.QueryBuilder.revokeDeckAccessTokenIssuerSigningKey();
+  async revokeTokenIssuerSigningKey(id) {
+    this.config.requireSecretCredential("decks.revokeTokenIssuerSigningKey");
+    const { query } = core.QueryBuilder.revokeDeckTokenIssuerSigningKey();
     const result = await this.connection.execute(query, { id });
-    return result["deckAccessTokenIssuerSigningKeyRevoke"];
+    return result["deckTokenIssuerSigningKeyRevoke"];
   }
   /**
    * Grant or update one OAuth app's selected-deck access.
@@ -1600,33 +1537,23 @@ var DecksResource = class extends BaseResource {
     return Boolean(result["deckApiApplicationAccessRevoke"]);
   }
   /**
-   * Exchange the current trusted API application credential for a deck access token.
-   */
-  async exchangeAccessToken(input) {
-    this.config.requireSecretCredential("decks.exchangeAccessToken");
-    const { query } = core.QueryBuilder.exchangeDeckAccessToken();
-    const variables = core.QueryBuilder.deckAccessTokenExchangeVariables(input);
-    const result = await this.connection.execute(query, variables);
-    return result["deckAccessTokenExchange"];
-  }
-  /**
-   * Exchange the current secret API application credential for an app-owned deck session token.
+   * Exchange the current secret API application credential for a unified deck token.
    */
-  async exchangeSessionToken(input) {
-    this.config.requireSecretCredential("decks.exchangeSessionToken");
-    const { query } = core.QueryBuilder.exchangeDeckSessionToken();
-    const variables = core.QueryBuilder.deckSessionTokenExchangeVariables(input);
+  async exchangeToken(input) {
+    this.config.requireSecretCredential("decks.exchangeToken");
+    const { query } = core.QueryBuilder.exchangeDeckToken();
+    const variables = core.QueryBuilder.deckTokenExchangeVariables(input);
     const result = await this.connection.execute(query, variables);
-    return result["deckSessionTokenExchange"];
+    return result["deckTokenExchange"];
   }
   /**
-   * Revoke an exchanged deck access token.
+   * Revoke an exchanged unified deck token.
    */
-  async revokeAccessToken(id) {
-    this.config.requireSecretCredential("decks.revokeAccessToken");
-    const { query } = core.QueryBuilder.revokeDeckAccessToken();
+  async revokeToken(id) {
+    this.config.requireSecretCredential("decks.revokeToken");
+    const { query } = core.QueryBuilder.revokeDeckToken();
     const result = await this.connection.execute(query, { id });
-    return Boolean(result["deckAccessTokenRevoke"]);
+    return Boolean(result["deckTokenRevoke"]);
   }
   /**
    * Hydrate third-party-owned deck entries without storing them in CardDB.
@@ -2077,6 +2004,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);
@@ -2915,6 +3074,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 */
@@ -2941,6 +3102,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);
@@ -3042,6 +3204,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;