@adcp/sdk 16.3.0 → 16.4.0

package/dist/lib/core/account-reduction.js

@@ -0,0 +1,127 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var account_reduction_exports = {};
+__export(account_reduction_exports, {
+  accountKeySites: () => accountKeySites,
+  naturalAccountKey: () => naturalAccountKey,
+  reducedFields: () => reducedFields,
+  sameAccountKey: () => sameAccountKey,
+  valueAt: () => valueAt,
+  withReducedKeyAt: () => withReducedKeyAt
+});
+module.exports = __toCommonJS(account_reduction_exports);
+var import_account_key = require('./account-key.js');
+function isObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+const REDUCIBLE_FIELDS = ["operator_unit", "currency", "timezone"];
+function naturalAccountKey(value) {
+  if (!isObject(value) || typeof value.account_id === "string") return void 0;
+  const brand = value.brand;
+  if (!isObject(brand) || typeof brand.domain !== "string" || typeof value.operator !== "string") return void 0;
+  return {
+    brand: {
+      domain: brand.domain,
+      ...typeof brand.brand_id === "string" && { brand_id: brand.brand_id },
+      ...Array.isArray(brand.countries) && { countries: brand.countries }
+    },
+    operator: value.operator,
+    ...isObject(value.operator_unit) && { operator_unit: value.operator_unit },
+    ...typeof value.currency === "string" && { currency: value.currency },
+    ...typeof value.timezone === "string" && { timezone: value.timezone },
+    ...typeof value.sandbox === "boolean" && { sandbox: value.sandbox }
+  };
+}
+function accountKeySites(params) {
+  const sites = [];
+  const visit = (value, path, depth) => {
+    if (depth > 8) return;
+    if (Array.isArray(value)) {
+      value.forEach((item, index) => visit(item, [...path, index], depth + 1));
+      return;
+    }
+    if (!isObject(value)) return;
+    for (const [field, child] of Object.entries(value)) {
+      if (field === "account") {
+        const key = naturalAccountKey(child);
+        if (key) sites.push({ path: [...path, field], key });
+      } else if (field === "accounts" && Array.isArray(child)) {
+        child.forEach((entry, index) => {
+          const key = naturalAccountKey(entry);
+          if (key) sites.push({ path: [...path, field, index], key });
+        });
+      }
+      visit(child, [...path, field], depth + 1);
+    }
+  };
+  visit(params, [], 0);
+  return sites;
+}
+function valueAt(root, path) {
+  let current = root;
+  for (const segment of path) {
+    if (current === null || typeof current !== "object") return void 0;
+    current = current[segment];
+  }
+  return current;
+}
+function withReducedKeyAt(root, path, reduced) {
+  if (path.length === 0) {
+    if (!isObject(root) || "account_id" in reduced) return root;
+    const next = { ...root };
+    for (const field of REDUCIBLE_FIELDS) {
+      if (reduced[field] === void 0) delete next[field];
+    }
+    if (isObject(next.brand) && reduced.brand.countries === void 0 && "countries" in next.brand) {
+      const { countries: _, ...brand } = next.brand;
+      next.brand = brand;
+    }
+    return next;
+  }
+  const [head, ...rest] = path;
+  if (Array.isArray(root) && typeof head === "number") {
+    const copy = [...root];
+    copy[head] = withReducedKeyAt(copy[head], rest, reduced);
+    return copy;
+  }
+  if (isObject(root) && typeof head === "string") {
+    return { ...root, [head]: withReducedKeyAt(root[head], rest, reduced) };
+  }
+  return root;
+}
+function reducedFields(full, reduced) {
+  if ("account_id" in full || "account_id" in reduced) return [];
+  const fields = REDUCIBLE_FIELDS.filter(
+    (field) => full[field] !== void 0 && reduced[field] === void 0
+  );
+  if (full.brand.countries !== void 0 && reduced.brand.countries === void 0) fields.push("brand.countries");
+  return fields;
+}
+function sameAccountKey(left, right) {
+  return (0, import_account_key.accountReferenceKey)(left) === (0, import_account_key.accountReferenceKey)(right);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  accountKeySites,
+  naturalAccountKey,
+  reducedFields,
+  sameAccountKey,
+  valueAt,
+  withReducedKeyAt
+});

package/dist/lib/core/account-reduction.mjs

@@ -0,0 +1,98 @@
+import { accountReferenceKey } from "./account-key.mjs";
+function isObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+const REDUCIBLE_FIELDS = ["operator_unit", "currency", "timezone"];
+function naturalAccountKey(value) {
+  if (!isObject(value) || typeof value.account_id === "string") return void 0;
+  const brand = value.brand;
+  if (!isObject(brand) || typeof brand.domain !== "string" || typeof value.operator !== "string") return void 0;
+  return {
+    brand: {
+      domain: brand.domain,
+      ...typeof brand.brand_id === "string" && { brand_id: brand.brand_id },
+      ...Array.isArray(brand.countries) && { countries: brand.countries }
+    },
+    operator: value.operator,
+    ...isObject(value.operator_unit) && { operator_unit: value.operator_unit },
+    ...typeof value.currency === "string" && { currency: value.currency },
+    ...typeof value.timezone === "string" && { timezone: value.timezone },
+    ...typeof value.sandbox === "boolean" && { sandbox: value.sandbox }
+  };
+}
+function accountKeySites(params) {
+  const sites = [];
+  const visit = (value, path, depth) => {
+    if (depth > 8) return;
+    if (Array.isArray(value)) {
+      value.forEach((item, index) => visit(item, [...path, index], depth + 1));
+      return;
+    }
+    if (!isObject(value)) return;
+    for (const [field, child] of Object.entries(value)) {
+      if (field === "account") {
+        const key = naturalAccountKey(child);
+        if (key) sites.push({ path: [...path, field], key });
+      } else if (field === "accounts" && Array.isArray(child)) {
+        child.forEach((entry, index) => {
+          const key = naturalAccountKey(entry);
+          if (key) sites.push({ path: [...path, field, index], key });
+        });
+      }
+      visit(child, [...path, field], depth + 1);
+    }
+  };
+  visit(params, [], 0);
+  return sites;
+}
+function valueAt(root, path) {
+  let current = root;
+  for (const segment of path) {
+    if (current === null || typeof current !== "object") return void 0;
+    current = current[segment];
+  }
+  return current;
+}
+function withReducedKeyAt(root, path, reduced) {
+  if (path.length === 0) {
+    if (!isObject(root) || "account_id" in reduced) return root;
+    const next = { ...root };
+    for (const field of REDUCIBLE_FIELDS) {
+      if (reduced[field] === void 0) delete next[field];
+    }
+    if (isObject(next.brand) && reduced.brand.countries === void 0 && "countries" in next.brand) {
+      const { countries: _, ...brand } = next.brand;
+      next.brand = brand;
+    }
+    return next;
+  }
+  const [head, ...rest] = path;
+  if (Array.isArray(root) && typeof head === "number") {
+    const copy = [...root];
+    copy[head] = withReducedKeyAt(copy[head], rest, reduced);
+    return copy;
+  }
+  if (isObject(root) && typeof head === "string") {
+    return { ...root, [head]: withReducedKeyAt(root[head], rest, reduced) };
+  }
+  return root;
+}
+function reducedFields(full, reduced) {
+  if ("account_id" in full || "account_id" in reduced) return [];
+  const fields = REDUCIBLE_FIELDS.filter(
+    (field) => full[field] !== void 0 && reduced[field] === void 0
+  );
+  if (full.brand.countries !== void 0 && reduced.brand.countries === void 0) fields.push("brand.countries");
+  return fields;
+}
+function sameAccountKey(left, right) {
+  return accountReferenceKey(left) === accountReferenceKey(right);
+}
+export {
+  accountKeySites,
+  naturalAccountKey,
+  reducedFields,
+  sameAccountKey,
+  valueAt,
+  withReducedKeyAt
+};

package/dist/lib/core/buyer-account-registry.d.mts

@@ -24,6 +24,17 @@ export interface ProvisionedAccount {
         idempotencyKey: string;
         startedAt: string;
     };
+    /**
+     * Set on a buyer key that reached the seller reduced to an older release's
+     * account key (`accountIdentityDowngrade: 'reduce'`): the key the seller
+     * knows the account by, and the release it was reduced for.
+     */
+    reduction?: {
+        account: AccountReference;
+        adcpVersion: string;
+    };
+    /** Set on a reduced seller key: the one buyer key allowed to use it. */
+    reducedFrom?: AccountReference;
 }
 /** Partitioned by seller and caller scope. Implementations must provide read-your-writes. */
 export interface BuyerAccountStorage {
@@ -61,6 +72,8 @@ export declare class BuyerAccountRegistry {
     private repair?;
     private readonly registryOptions;
     private entries;
+    /** Reduction bindings when no storage is configured (never evicted). */
+    private reductions;
     private pending;
     private writes;
     private repairs;
@@ -96,4 +109,43 @@ export declare class BuyerAccountRegistry {
     }, options?: TaskOptions): Promise<void>;
     private repairStatus;
     private runRepair;
+    private reductionKey;
+    private readReduction;
+    /** Insert-if-absent; returns false when another writer already holds the key. */
+    private insertReduction;
+    private replaceReduction;
+    /**
+     * Bind reduced account keys to the buyer keys they came from, before a
+     * request carrying them is sent to a seller on an older release. Each
+     * reduced key serves one buyer key only. A key sent unreduced claims itself
+     * (`account` and `reduced` equal), so a plain key and a reduced one can never
+     * land on the same seller account in either order.
+     *
+     * All-or-nothing: every claim is checked, against storage and against the
+     * other claims in the same request, before any is written. On a conflict
+     * nothing is written and the index and owner of the first conflicting claim
+     * are returned. A claim lost to a concurrent writer rolls back the claims
+     * this call already wrote.
+     */
+    claimReductions(claims: ReadonlyArray<{
+        account: AccountReference;
+        reduced: AccountReference;
+        adcpVersion: string;
+    }>): Promise<{
+        index: number;
+        owner: AccountReference;
+    } | undefined>;
+    /** The buyer key a reduced seller key was claimed for, if any. */
+    reductionOwner(reduced: AccountReference): Promise<AccountReference | undefined>;
+    /** The reduced key a buyer key reached an older seller with, if any. */
+    reductionFor(account: AccountReference): Promise<ProvisionedAccount['reduction']>;
+    /**
+     * Forget that `account` reached this seller under a reduced key. Call once
+     * the account has moved to its full key: after a `sync_accounts` settings
+     * update rekeys `operator_unit` in place, or after opening a new account
+     * under the full key when the reduced fields (`currency`, `timezone`,
+     * `brand.countries`) cannot change on an existing account. Until then the
+     * client keeps addressing the seller account by its reduced key.
+     */
+    clearReduction(account: AccountReference): Promise<void>;
 }

package/dist/lib/core/buyer-account-registry.d.ts

@@ -24,6 +24,17 @@ export interface ProvisionedAccount {
         idempotencyKey: string;
         startedAt: string;
     };
+    /**
+     * Set on a buyer key that reached the seller reduced to an older release's
+     * account key (`accountIdentityDowngrade: 'reduce'`): the key the seller
+     * knows the account by, and the release it was reduced for.
+     */
+    reduction?: {
+        account: AccountReference;
+        adcpVersion: string;
+    };
+    /** Set on a reduced seller key: the one buyer key allowed to use it. */
+    reducedFrom?: AccountReference;
 }
 /** Partitioned by seller and caller scope. Implementations must provide read-your-writes. */
 export interface BuyerAccountStorage {
@@ -61,6 +72,8 @@ export declare class BuyerAccountRegistry {
     private repair?;
     private readonly registryOptions;
     private entries;
+    /** Reduction bindings when no storage is configured (never evicted). */
+    private reductions;
     private pending;
     private writes;
     private repairs;
@@ -96,4 +109,43 @@ export declare class BuyerAccountRegistry {
     }, options?: TaskOptions): Promise<void>;
     private repairStatus;
     private runRepair;
+    private reductionKey;
+    private readReduction;
+    /** Insert-if-absent; returns false when another writer already holds the key. */
+    private insertReduction;
+    private replaceReduction;
+    /**
+     * Bind reduced account keys to the buyer keys they came from, before a
+     * request carrying them is sent to a seller on an older release. Each
+     * reduced key serves one buyer key only. A key sent unreduced claims itself
+     * (`account` and `reduced` equal), so a plain key and a reduced one can never
+     * land on the same seller account in either order.
+     *
+     * All-or-nothing: every claim is checked, against storage and against the
+     * other claims in the same request, before any is written. On a conflict
+     * nothing is written and the index and owner of the first conflicting claim
+     * are returned. A claim lost to a concurrent writer rolls back the claims
+     * this call already wrote.
+     */
+    claimReductions(claims: ReadonlyArray<{
+        account: AccountReference;
+        reduced: AccountReference;
+        adcpVersion: string;
+    }>): Promise<{
+        index: number;
+        owner: AccountReference;
+    } | undefined>;
+    /** The buyer key a reduced seller key was claimed for, if any. */
+    reductionOwner(reduced: AccountReference): Promise<AccountReference | undefined>;
+    /** The reduced key a buyer key reached an older seller with, if any. */
+    reductionFor(account: AccountReference): Promise<ProvisionedAccount['reduction']>;
+    /**
+     * Forget that `account` reached this seller under a reduced key. Call once
+     * the account has moved to its full key: after a `sync_accounts` settings
+     * update rekeys `operator_unit` in place, or after opening a new account
+     * under the full key when the reduced fields (`currency`, `timezone`,
+     * `brand.countries`) cannot change on an existing account. Until then the
+     * client keeps addressing the seller account by its reduced key.
+     */
+    clearReduction(account: AccountReference): Promise<void>;
 }

package/dist/lib/core/buyer-account-registry.js

@@ -45,6 +45,10 @@ function isDefinitiveRejection(result) {
     result.adcpError && !result.adcpError.synthetic && !result.adcpError.code.startsWith("IDEMPOTENCY_") && ["terminal", "correctable"].includes(result.adcpError.recovery ?? "")
   );
 }
+function rowMatchesReference(ref, row) {
+  if ("account_id" in ref) return row.account_id === ref.account_id;
+  return row.brand?.domain === ref.brand.domain && row.operator === ref.operator && (!ref.brand.brand_id || row.brand.brand_id === ref.brand.brand_id) && (0, import_account_resolution.sameCountrySet)(ref.brand.countries, row.brand.countries) && (!ref.operator_unit || row.operator_unit?.id === ref.operator_unit.id) && (!ref.currency || row.currency === ref.currency) && (!ref.timezone || row.timezone === ref.timezone) && (row.sandbox === void 0 || row.sandbox === true === (ref.sandbox === true));
+}
 class BuyerAccountRegistry {
   constructor(scope, provision, storage, repair, registryOptions = {}) {
     this.scope = scope;
@@ -63,6 +67,8 @@ class BuyerAccountRegistry {
   repair;
   registryOptions;
   entries = /* @__PURE__ */ new Map();
+  /** Reduction bindings when no storage is configured (never evicted). */
+  reductions = /* @__PURE__ */ new Map();
   pending = /* @__PURE__ */ new Map();
   writes = Promise.resolve();
   repairs = /* @__PURE__ */ new Map();
@@ -444,12 +450,13 @@ class BuyerAccountRegistry {
     return this.enqueue(async () => {
       if (scope !== this.scope()) return;
       for (const ref of refs) {
-        const candidates = rows.filter((value) => {
-          if (!value || typeof value !== "object") return false;
-          const row2 = value;
-          if ("account_id" in ref) return row2.account_id === ref.account_id;
-          return row2.brand?.domain === ref.brand.domain && row2.operator === ref.operator && (!ref.brand.brand_id || row2.brand.brand_id === ref.brand.brand_id) && (0, import_account_resolution.sameCountrySet)(ref.brand.countries, row2.brand.countries) && (!ref.operator_unit || row2.operator_unit?.id === ref.operator_unit.id) && (!ref.currency || row2.currency === ref.currency) && (!ref.timezone || row2.timezone === ref.timezone) && (row2.sandbox === void 0 || row2.sandbox === true === (ref.sandbox === true));
-        });
+        const isRow = (value) => !!value && typeof value === "object";
+        let candidates = rows.filter((value) => isRow(value) && rowMatchesReference(ref, value));
+        if (candidates.length === 0 && !("account_id" in ref)) {
+          const reduction = (await this.reductionFor(ref))?.account;
+          if (scope !== this.scope()) return;
+          if (reduction) candidates = rows.filter((value) => isRow(value) && rowMatchesReference(reduction, value));
+        }
         if (candidates.length !== 1) continue;
         let row = candidates[0];
         if (row.action === "failed" || typeof row.status !== "string") continue;
@@ -614,6 +621,135 @@ class BuyerAccountRegistry {
       }
     }
   }
+  reductionKey(kind, account, scope = this.scope()) {
+    return `${scope}:${kind}:${(0, import_account_key.accountReferenceKey)(account)}`;
+  }
+  async readReduction(key) {
+    const entry = this.storage ? await this.storage.get(key) : this.reductions.get(key);
+    return entry && entry.status === "reduced" ? structuredClone(entry) : void 0;
+  }
+  /** Insert-if-absent; returns false when another writer already holds the key. */
+  async insertReduction(key, entry) {
+    const prior = this.storage ? await this.storage.get(key) : this.reductions.get(key);
+    if (prior && prior.status === "reduced") return false;
+    if (this.storage?.compareAndSet) {
+      return this.storage.compareAndSet(key, prior?.revision, { ...entry, revision: (prior?.revision ?? 0) + 1 });
+    }
+    if (this.storage) await this.storage.set(key, structuredClone(entry));
+    else this.reductions.set(key, structuredClone(entry));
+    return true;
+  }
+  async replaceReduction(key, entry) {
+    const prior = this.storage ? await this.storage.get(key) : this.reductions.get(key);
+    if (this.storage?.compareAndSet) {
+      const next = { ...entry, revision: (prior?.revision ?? 0) + 1 };
+      if (!await this.storage.compareAndSet(key, prior?.revision, next))
+        throw new import_errors.AccountSetupRequiredError("Account storage revision changed. Reload and reconcile before retrying.");
+    } else if (this.storage) await this.storage.set(key, structuredClone(entry));
+    else this.reductions.set(key, structuredClone(entry));
+  }
+  /**
+   * Bind reduced account keys to the buyer keys they came from, before a
+   * request carrying them is sent to a seller on an older release. Each
+   * reduced key serves one buyer key only. A key sent unreduced claims itself
+   * (`account` and `reduced` equal), so a plain key and a reduced one can never
+   * land on the same seller account in either order.
+   *
+   * All-or-nothing: every claim is checked, against storage and against the
+   * other claims in the same request, before any is written. On a conflict
+   * nothing is written and the index and owner of the first conflicting claim
+   * are returned. A claim lost to a concurrent writer rolls back the claims
+   * this call already wrote.
+   */
+  async claimReductions(claims) {
+    const scope = this.scope();
+    let conflict;
+    await this.enqueue(async () => {
+      const pending = /* @__PURE__ */ new Map();
+      const toInsert = [];
+      for (const [index, claim] of claims.entries()) {
+        const reducedKey = (0, import_account_key.accountReferenceKey)(claim.reduced);
+        const inRequest = pending.get(reducedKey);
+        if (inRequest && (0, import_account_key.accountReferenceKey)(inRequest) !== (0, import_account_key.accountReferenceKey)(claim.account)) {
+          conflict = { index, owner: inRequest };
+          return;
+        }
+        pending.set(reducedKey, claim.account);
+        const owner = (await this.readReduction(this.reductionKey("reduced", claim.reduced, scope)))?.reducedFrom;
+        if (owner && (0, import_account_key.accountReferenceKey)(owner) !== (0, import_account_key.accountReferenceKey)(claim.account)) {
+          conflict = { index, owner };
+          return;
+        }
+        if (!owner && !inRequest) toInsert.push(index);
+      }
+      const inserted = [];
+      for (const index of toInsert) {
+        const claim = claims[index];
+        const reverseKey = this.reductionKey("reduced", claim.reduced, scope);
+        const ok = await this.insertReduction(reverseKey, {
+          account: structuredClone(claim.reduced),
+          status: "reduced",
+          reducedFrom: structuredClone(claim.account)
+        });
+        const winner = ok ? void 0 : (await this.readReduction(reverseKey))?.reducedFrom;
+        if (!ok && winner && (0, import_account_key.accountReferenceKey)(winner) !== (0, import_account_key.accountReferenceKey)(claim.account)) {
+          for (const done of inserted) {
+            const doneClaim = claims[done];
+            await this.replaceReduction(this.reductionKey("reduced", doneClaim.reduced, scope), {
+              account: structuredClone(doneClaim.reduced),
+              status: "released"
+            });
+          }
+          conflict = { index, owner: winner };
+          return;
+        }
+        if (ok) inserted.push(index);
+      }
+      for (const claim of claims) {
+        if ((0, import_account_key.accountReferenceKey)(claim.account) === (0, import_account_key.accountReferenceKey)(claim.reduced)) continue;
+        const forwardKey = this.reductionKey("reduction", claim.account, scope);
+        const current = await this.readReduction(forwardKey);
+        const reduction = { account: claim.reduced, adcpVersion: claim.adcpVersion };
+        if (current?.reduction && (0, import_node_util.isDeepStrictEqual)(current.reduction, reduction)) continue;
+        await this.replaceReduction(forwardKey, {
+          account: structuredClone(claim.account),
+          status: "reduced",
+          reduction: structuredClone(reduction)
+        });
+      }
+    });
+    return conflict;
+  }
+  /** The buyer key a reduced seller key was claimed for, if any. */
+  async reductionOwner(reduced) {
+    return (await this.readReduction(this.reductionKey("reduced", reduced)))?.reducedFrom;
+  }
+  /** The reduced key a buyer key reached an older seller with, if any. */
+  async reductionFor(account) {
+    return (await this.readReduction(this.reductionKey("reduction", account)))?.reduction;
+  }
+  /**
+   * Forget that `account` reached this seller under a reduced key. Call once
+   * the account has moved to its full key: after a `sync_accounts` settings
+   * update rekeys `operator_unit` in place, or after opening a new account
+   * under the full key when the reduced fields (`currency`, `timezone`,
+   * `brand.countries`) cannot change on an existing account. Until then the
+   * client keeps addressing the seller account by its reduced key.
+   */
+  async clearReduction(account) {
+    const scope = this.scope();
+    await this.enqueue(async () => {
+      const forwardKey = this.reductionKey("reduction", account, scope);
+      const forward = await this.readReduction(forwardKey);
+      if (!forward?.reduction) return;
+      const reverseKey = this.reductionKey("reduced", forward.reduction.account, scope);
+      const reverse = await this.readReduction(reverseKey);
+      if (reverse?.reducedFrom && (0, import_account_key.accountReferenceKey)(reverse.reducedFrom) === (0, import_account_key.accountReferenceKey)(account)) {
+        await this.replaceReduction(reverseKey, { account: reverse.account, status: "released" });
+      }
+      await this.replaceReduction(forwardKey, { account: forward.account, status: "released" });
+    });
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {