@salesforce/platform-sdk 9.14.0 → 9.16.0

package/dist/data/index.js

@@ -0,0 +1,628 @@
+import { w as L, g as x, S as d } from "../sdk-promise-7SpSqah5.js";
+import { buildServiceDescriptor as _, setHeader as y } from "@conduit-client/service-fetch-network/v1";
+import { resolvedPromiseLike as u, ok as w, err as C, stableJSONStringify as V, DataNotFoundError as Q, UserVisibleError as H, deepFreeze as b, isUserVisibleError as G } from "@conduit-client/utils";
+import { print as D, parse as K } from "@conduit-client/onestore-graphql-parser/v1";
+import { RetryPolicy as z, buildServiceDescriptor as W } from "@conduit-client/service-retry/v1";
+import { buildServiceDescriptor as j } from "@conduit-client/service-cache/v1";
+import { buildServiceDescriptor as B } from "@conduit-client/service-cache-control/v1";
+import { buildInMemoryCacheInclusionPolicyService as J } from "@conduit-client/service-cache-inclusion-policy/v1";
+import { buildServiceDescriptor as X } from "@conduit-client/service-pubsub/v1";
+import { HttpCacheControlCommand as Y } from "@conduit-client/command-http-cache-control/v1";
+function Z(t) {
+  return (e) => {
+    const [r, n] = e;
+    if (typeof r == "string" && !r.startsWith("http")) {
+      const s = r.startsWith("/") ? r : `/${r}`;
+      return u([`${t}${s}`, n]);
+    }
+    return u(e);
+  };
+}
+function ee(t) {
+  return (e) => u(y("Authorization", `Bearer ${t}`, e));
+}
+function re(t, e) {
+  const r = [];
+  return t && r.push(Z(t)), e && r.push(ee(e)), _({
+    request: r
+  }).service;
+}
+const v = () => {
+}, E = async () => {
+};
+function q(t) {
+  try {
+    return w(K(t));
+  } catch (e) {
+    return C(l(e));
+  }
+}
+function k(t, e) {
+  const r = t.definitions.filter(
+    (n) => n.kind === "OperationDefinition"
+  );
+  return r.length === 0 ? "unknown" : r.length === 1 ? e === void 0 || r[0].name?.value === e ? r[0].operation : "unknown" : e === void 0 ? "unknown" : r.find((n) => n.name?.value === e)?.operation ?? "unknown";
+}
+function l(t) {
+  if (t && typeof t == "object" && "data" in t) {
+    const e = t.data;
+    if (e && typeof e == "object" && "errors" in e && Array.isArray(e.errors))
+      return e.errors;
+  }
+  return t instanceof Error ? [{ message: t.message }] : typeof t == "string" ? [{ message: t }] : [{ message: "Unknown error" }];
+}
+async function R(t, { mutation: e, variables: r, operationName: n }) {
+  const s = q(e);
+  if (s.isErr()) return { data: void 0, errors: s.error };
+  const a = s.value, o = k(a, n);
+  if (o !== "mutation")
+    return {
+      data: void 0,
+      errors: [
+        {
+          message: `DataSDK.graphql.mutate() requires a GraphQL mutation, received ${o}.`
+        }
+      ]
+    };
+  try {
+    const i = await t({
+      query: D(a),
+      variables: r,
+      operationName: n
+    });
+    return {
+      data: i.data ?? void 0,
+      errors: i.errors
+    };
+  } catch (i) {
+    return { data: void 0, errors: l(i) };
+  }
+}
+function M(t) {
+  function e(n, s, a) {
+    return t({
+      query: D(n),
+      variables: s,
+      operationName: a
+    }).then(
+      (o) => ({
+        data: o.data ?? void 0,
+        errors: o.errors
+      }),
+      (o) => ({ data: void 0, errors: l(o) })
+    );
+  }
+  async function r({
+    query: n,
+    variables: s,
+    operationName: a
+  }) {
+    const o = q(n);
+    if (o.isErr())
+      return {
+        data: void 0,
+        errors: o.error,
+        subscribe: () => v,
+        refresh: E
+      };
+    const i = o.value, p = k(i, a);
+    if (p !== "query")
+      return {
+        data: void 0,
+        errors: [
+          {
+            message: `DataSDK.graphql.query() requires a GraphQL query, received ${p}.`
+          }
+        ],
+        subscribe: () => v,
+        refresh: E
+      };
+    const c = /* @__PURE__ */ new Set(), f = s, m = await e(i, f, a);
+    return {
+      data: m.data,
+      errors: m.errors,
+      subscribe(h) {
+        return c.add(h), () => {
+          c.delete(h);
+        };
+      },
+      async refresh() {
+        const h = await e(i, f, a);
+        for (const S of c) S(h);
+      }
+    };
+  }
+  return {
+    query: r,
+    mutate: (n) => R(t, n)
+  };
+}
+const te = typeof __SF_API_VERSION__ < "u" ? __SF_API_VERSION__ : "65.0";
+function $(t = te) {
+  return `/services/data/v${t}`;
+}
+class ne {
+  clientFetch;
+  pathData;
+  graphql;
+  constructor(e) {
+    const r = se(), n = ae(e?.instanceUrl ?? r.instanceUrl), s = e?.accessToken ?? r.accessToken;
+    this.pathData = $(e?.apiVersion ?? r.apiVersion), this.clientFetch = re(n || void 0, s), this.graphql = M(this.executeRawGraphQL.bind(this));
+  }
+  async executeRawGraphQL({
+    query: e,
+    variables: r,
+    operationName: n
+  }) {
+    return (await this.clientFetch(`${this.pathData}/graphql`, {
+      method: "POST",
+      body: JSON.stringify({ query: e, variables: r, operationName: n }),
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json"
+      }
+    })).json();
+  }
+}
+function se() {
+  const t = globalThis.MOSAIC_ENV;
+  return {
+    instanceUrl: t?.instanceUrl,
+    accessToken: t?.accessToken,
+    apiVersion: t?.apiVersion
+  };
+}
+function ae(t) {
+  if (!t || t === "/") return "";
+  let e = t;
+  return !e.startsWith("/") && !e.startsWith("http") && (e = `/${e}`), e.endsWith("/") && (e = e.slice(0, -1)), e;
+}
+const oe = "graphqlQuery";
+class ie {
+  graphql;
+  constructor() {
+    this.graphql = M(this.executeRawGraphQL.bind(this));
+  }
+  async executeRawGraphQL({
+    query: e,
+    variables: r,
+    operationName: n
+  }) {
+    return (await window.openai.callTool(oe, {
+      query: e,
+      ...r != null ? { variables: r } : {},
+      ...n != null ? { operationName: n } : {}
+    })).structuredContent;
+  }
+}
+const ce = "X-SFDC-Client-Name", ue = "X-SFDC-Client-Version", he = "@salesforce/platform-sdk", le = "9.16.0", de = (t) => {
+  let e = y(ce, he, t);
+  return e = y(ue, le, e), u(e);
+}, pe = "X-CSRF-Token";
+function fe(t, e = {}) {
+  const { protectedUrls: r = [], alwaysProtectedUrls: n = [] } = e;
+  return async (s) => {
+    const [a, o] = s, i = new Request(a, o);
+    if (P(n, i.url) || me(i.method) && P(r, i.url)) {
+      const c = await t.getToken();
+      s = y(pe, c, s);
+    }
+    return u(s);
+  };
+}
+function me(t) {
+  const e = t.toLowerCase();
+  return e === "post" || e === "put" || e === "patch" || e === "delete";
+}
+function P(t, e) {
+  const r = new URL(e);
+  return t.some((n) => r.pathname.includes(n));
+}
+function ye(t, e = {}) {
+  const r = fe(t, e);
+  async function n(s) {
+    const a = await r(s);
+    return fetch(a[0], a[1]);
+  }
+  return (s, a) => a ? a.applyRetry(async () => n(s)) : n(s);
+}
+const be = [400, 401, 403];
+class ve extends z {
+  constructor(e) {
+    super(e), this.csrfTokenManager = e;
+  }
+  /**
+   * Determines if a failed request should be retried due to CSRF token issues.
+   */
+  async shouldRetry(e, r) {
+    return r.attempt >= 1 ? !1 : be.includes(e.status);
+  }
+  /**
+   * CSRF token refresh should happen immediately with no delay.
+   */
+  async calculateDelay(e, r) {
+    return 0;
+  }
+  /**
+   * Called by retry service before each retry attempt.
+   *
+   * @param _result - The failed response that triggered the retry (unused, already validated)
+   * @param _context - Current retry context (unused but part of interface)
+   */
+  async prepareRetry(e, r) {
+    await this.csrfTokenManager.refreshToken();
+  }
+}
+class Se {
+  constructor(e, r) {
+    this.endpoint = e, this.cacheName = r, this.tokenPromise = this.obtainToken();
+  }
+  tokenPromise;
+  refreshPromise;
+  /**
+   * Returns the current token value as a Promise.
+   * Lazy-loads the token on first call (from cache or by fetching).
+   */
+  async getToken() {
+    return this.tokenPromise;
+  }
+  /**
+   * Obtains and returns a new token value as a promise.
+   * This will clear the cached token and fetch a fresh one.
+   * If a refresh is already in progress, all callers share the same in-flight promise.
+   */
+  refreshToken() {
+    return this.refreshPromise || (this.refreshPromise = this.withCache((e) => e.delete(this.endpoint)).then(() => (this.tokenPromise = this.obtainToken(), this.tokenPromise)).finally(() => {
+      this.refreshPromise = void 0;
+    })), this.refreshPromise;
+  }
+  /**
+   * Obtains a CSRF token, using cache when available or fetching a new one.
+   *
+   * @returns Promise that resolves to the CSRF token string
+   */
+  async obtainToken() {
+    let e = await this.withCache((s) => s.match(this.endpoint)), r = !1;
+    e || (e = await fetch(this.endpoint, { method: "get" }), r = !0);
+    const n = (await e.clone().json()).csrfToken;
+    return r && await this.withCache((s) => s.put(this.endpoint, e)), n;
+  }
+  /**
+   * Provides a safe way to interact with the Cache API with fallback for unsupported environments.
+   *
+   * @param callback - Function that receives the cache instance and returns a promise
+   * @returns The result of the callback, or undefined if caches API is not available
+   */
+  async withCache(e) {
+    if (this.cacheName && caches) {
+      const r = await caches.open(this.cacheName);
+      return e(r);
+    } else
+      return;
+  }
+}
+const T = /* @__PURE__ */ new Map();
+function ge(t) {
+  const { endpoint: e, cacheName: r, ...n } = t.csrf;
+  let s = T.get(e);
+  return s || (s = new Se(e, r), T.set(e, s)), _(
+    {
+      retry: ye(s, n),
+      request: [de]
+    },
+    W(new ve(s)).service
+  ).service;
+}
+const A = /* @__PURE__ */ new Map();
+function we(t) {
+  let e = A.get(t);
+  if (!e) {
+    const r = j().service, n = J(r).service, s = B(r, n).service, a = X().service;
+    e = { cache: r, cacheController: s, pubSub: a }, A.set(t, e);
+  }
+  return e;
+}
+function Ce(t, e) {
+  const r = we(t);
+  return {
+    shared: r,
+    services: {
+      cacheController: r.cacheController,
+      pubSub: r.pubSub,
+      fetch: e
+    }
+  };
+}
+function I() {
+  return {
+    "Content-Type": "application/json",
+    Accept: "application/json",
+    "X-Chatter-Entity-Encoding": "false"
+  };
+}
+const N = 300;
+function Ee(t, e) {
+  try {
+    return JSON.parse(JSON.stringify(t));
+  } catch (r) {
+    const n = e || "(anonymous)", s = new TypeError(
+      `HttpGraphQLResourceCacheControlCommand: variables for operation "${n}" must be JSON-serializable. ${r.message}`
+    );
+    throw s.cause = r, s;
+  }
+}
+function De(t) {
+  if (typeof t == "object" && t.type === "max-age") {
+    const e = t.maxAge;
+    return Number.isFinite(e) && e >= 0 ? e : N;
+  }
+  return N;
+}
+class qe extends Y {
+  constructor(e, r, n) {
+    super(r), this.url = n, this.query = e.query, this.normalizedOperationName = e.operationName ?? "", this.normalizedVariables = Ee(
+      e.variables ?? {},
+      this.normalizedOperationName
+    ), this.cacheControl = e.cacheControl, this.resolvedMaxAge = De(e.cacheControl);
+  }
+  query;
+  normalizedVariables;
+  normalizedOperationName;
+  cacheControl;
+  resolvedMaxAge;
+  get fetchParams() {
+    return [
+      this.url,
+      {
+        method: "POST",
+        headers: I(),
+        body: JSON.stringify({
+          query: this.query,
+          variables: this.normalizedVariables,
+          operationName: this.normalizedOperationName
+        })
+      }
+    ];
+  }
+  buildKey() {
+    return V({
+      query: this.query,
+      variables: this.normalizedVariables,
+      operationName: this.normalizedOperationName
+    });
+  }
+  /**
+   * Reads from the cache and returns the cache result or error
+   *
+   * In case of a missing or partial result, this should return either a DataNotFoundError or
+   * DataIncompleteError, respectively, in the Error response
+   *
+   * Note that any subclass should JUST try to read the data from the cache here; it should
+   * NOT try to take metadata (eg cache control semantics) into account while reading the
+   * data. The CacheController is responsible for enforcing those semantics.
+   *
+   * @param cache source of cached data
+   * @returns result or error from the cache
+   */
+  readFromCache(e) {
+    const r = this.buildKey(), n = e.get(r)?.value;
+    return n === void 0 ? u(C(new Q())) : u(w(n));
+  }
+  writeToCache(e, r) {
+    if (r.isOk() && r.value.data != null && Object.keys(r.value.data).length > 0) {
+      const n = Math.floor(Date.now() / 1e3);
+      e.set(this.buildKey(), {
+        value: r.value.data,
+        metadata: {
+          cacheControl: {
+            type: "max-age",
+            maxAge: this.resolvedMaxAge,
+            generatedTime: n
+          }
+        }
+      });
+    }
+    return u(void 0);
+  }
+  get cacheControlStrategyConfig() {
+    const e = Math.floor(Date.now() / 1e3);
+    return this.cacheControl === "no-cache" ? { type: "no-cache", now: e } : this.cacheControl === "only-if-cached" ? { type: "only-if-cached", now: e } : {
+      type: "max-age",
+      requestMaxAge: this.resolvedMaxAge,
+      now: e
+    };
+  }
+  responseHasErrors(e) {
+    return e.errors && e.errors.length > 0;
+  }
+  processFetchReturnValue(e) {
+    return this.responseHasErrors(e) ? C(new H(e)) : w(e);
+  }
+}
+function U(t) {
+  if (G(t) && t.data && typeof t.data == "object") {
+    const e = t.data;
+    if (e.data != null)
+      return e.data;
+  }
+}
+function ke(t) {
+  return (e) => {
+    if (e.isOk()) {
+      const r = e.value;
+      b(r), t({ data: r, errors: void 0 });
+    } else {
+      const r = U(e.error);
+      r && b(r), t({ data: r, errors: l(e.error) });
+    }
+  };
+}
+async function Pe(t) {
+  let e, r, n;
+  try {
+    const s = await t.execute();
+    s.isOk() ? (e = s.value.data, b(e), n = (a) => s.value.subscribe(a)) : (e = U(s.error.failure), e && b(e), r = l(s.error.failure), n = (a) => s.error.subscribe(a));
+  } catch (s) {
+    r = l(s);
+  }
+  return {
+    data: e,
+    errors: r,
+    subscribe(s) {
+      return n ? n(ke(s)) : v;
+    },
+    async refresh() {
+      await t.refresh();
+    }
+  };
+}
+function g(t) {
+  return {
+    data: void 0,
+    errors: t,
+    subscribe: () => v,
+    refresh: E
+  };
+}
+function Te({
+  bundle: t,
+  url: e,
+  executeRaw: r
+}) {
+  const { services: n } = t;
+  async function s({
+    query: a,
+    variables: o,
+    operationName: i,
+    cacheControl: p
+  }) {
+    const c = q(a);
+    if (c.isErr()) return g(c.error);
+    const f = c.value, m = k(f, i);
+    if (m !== "query")
+      return g([
+        {
+          message: `DataSDK.graphql.query() requires a GraphQL query, received ${m}.`
+        }
+      ]);
+    let h;
+    try {
+      h = new qe(
+        {
+          query: D(f),
+          variables: o,
+          operationName: i,
+          cacheControl: p
+        },
+        n,
+        e
+      );
+    } catch (S) {
+      return g(l(S));
+    }
+    return Pe(h);
+  }
+  return {
+    query: s,
+    mutate: (a) => R(r, a)
+  };
+}
+const Ae = 1, Ne = `@salesforce/platform-sdk-data_v${Ae}`, F = $(), Oe = `${F}/ui-api`, O = `${F}/graphql`;
+class _e {
+  baseUrl;
+  clientFetch;
+  onStatus;
+  graphql;
+  constructor(e) {
+    const r = Re();
+    this.baseUrl = Me(e?.basePath ?? r.apiPath), this.onStatus = e?.onStatus ?? {}, this.clientFetch = ge({
+      csrf: {
+        endpoint: `${this.baseUrl}${Oe}/session/csrf`,
+        cacheName: Ne,
+        protectedUrls: ["services/data/v", "services/apexrest"],
+        alwaysProtectedUrls: ["services/apexrest"]
+      }
+    });
+    const n = (a, o) => this.fetch(a, o), s = Ce(this.baseUrl, n);
+    this.graphql = Te({
+      bundle: s,
+      url: O,
+      executeRaw: this.executeRawGraphQL.bind(this)
+    });
+  }
+  async fetch(e, r) {
+    const n = this.applySalesforceBase(e), s = await this.clientFetch(n, r);
+    return await this.onStatus[s.status]?.(), s;
+  }
+  /**
+   * Raw GraphQL POST. Used internally by `graphql.mutate` (which has no
+   * cache concern) and transitively by `graphql.query` on cache miss
+   * (the OneStore cache command's fetch service is bound to this same
+   * SDK's `fetch`, which in turn calls this method's caller patterns).
+   */
+  async executeRawGraphQL({
+    query: e,
+    variables: r,
+    operationName: n
+  }) {
+    return (await this.fetch(O, {
+      method: "POST",
+      body: JSON.stringify({ query: e, variables: r, operationName: n }),
+      headers: I()
+    })).json();
+  }
+  /**
+   * If the url is relative, convert to it to an absolute Salesforce URL.  This is due to the way Code
+   * Builder deployments structure the url for Salesforce
+   */
+  applySalesforceBase(e) {
+    if (typeof e == "string") {
+      if (e.startsWith("http"))
+        return e;
+      const r = e.startsWith("/") ? e : `/${e}`;
+      return `${this.baseUrl}${r}`;
+    }
+    return e;
+  }
+}
+function Re() {
+  return {
+    apiPath: globalThis.SFDC_ENV?.apiPath
+  };
+}
+function Me(t) {
+  if (!t || t === "/") return "";
+  let e = t;
+  return e.startsWith("/") || (e = `/${e}`), e.endsWith("/") && (e = e.slice(0, -1)), e;
+}
+function Ke(t, ...e) {
+  let r = t[0] ?? "";
+  for (let n = 0; n < e.length; n += 1)
+    r += String(e[n]) + (t[n + 1] ?? "");
+  return r;
+}
+function ze(t) {
+  return L(
+    (async () => {
+      switch (x(t?.surface)) {
+        case d.OpenAI:
+          return new ie();
+        case d.WebApp:
+        case d.MicroFrontend:
+          return new _e(t?.webapp);
+        case d.Mosaic:
+          return new ne(t?.mosaic);
+        case d.SalesforceACC:
+        case d.MCPApps:
+          return {};
+        default:
+          return {};
+      }
+    })(),
+    "createDataSDK"
+  );
+}
+export {
+  ze as createDataSDK,
+  Ke as gql
+};