@conduit-client/lwc-bindings 5.67.0-dev1

package/LICENSE.txt

@@ -0,0 +1,27 @@
+*Attorney/Client Privileged + Confidential*
+
+Terms of Use for Public Code (Non-OSS)
+
+*NOTE:* Before publishing code under this license/these Terms of Use, please review https://salesforce.quip.com/WFfvAMKB18AL and confirm that you’ve completed all prerequisites described therein. *These Terms of Use may not be used or modified without input from IP and Product Legal.*
+
+*Terms of Use*
+
+Copyright 2022 Salesforce, Inc. All rights reserved. 
+
+These Terms of Use govern the download, installation, and/or use of this software provided by Salesforce, Inc. (“Salesforce”) (the “Software”), were last updated on April 15, 2022, ** and constitute a legally binding agreement between you and Salesforce. If you do not agree to these Terms of Use, do not install or use the Software. 
+ 
+Salesforce grants you a worldwide, non-exclusive, no-charge, royalty-free copyright license to reproduce, prepare derivative works of, publicly display, publicly perform, sublicense, and distribute the Software and derivative works subject to these Terms. These Terms shall be included in all copies or substantial portions of the Software. 
+
+Subject to the limited rights expressly granted hereunder, Salesforce reserves all rights, title, and interest in and to all intellectual property subsisting in the Software. No rights are granted to you hereunder other than as expressly set forth herein. Users residing in countries on the United States Office of Foreign Assets Control sanction list, or which are otherwise subject to a US export embargo, may not use the Software.
+ 
+Implementation of the Software may require development work, for which you are responsible. The Software may contain bugs, errors and incompatibilities and is made available on an AS IS basis without support, updates, or service level commitments. 
+ 
+Salesforce reserves the right at any time to modify, suspend, or discontinue, the Software (or any part thereof) with or without notice. You agree that Salesforce shall not be liable to you or to any third party for any modification, suspension, or discontinuance.
+
+You agree to defend Salesforce against any claim, demand, suit or proceeding made or brought against Salesforce by a third party arising out of or accruing from (a) your use of the Software, and (b) any application you develop with the Software that infringes any copyright, trademark, trade secret, trade dress, patent, or other intellectual property right of any person or defames any person or violates their rights of publicity or privacy (each a “Claim Against Salesforce”), and will indemnify Salesforce from any damages, attorney fees, and costs finally awarded against Salesforce as a result of, or for any amounts paid by Salesforce under a settlement approved by you in writing of, a Claim Against Salesforce, provided Salesforce (x) promptly gives you written notice of the Claim Against Salesforce, (y) gives you sole control of the defense and settlement of the Claim Against Salesforce (except that you may not settle any Claim Against Salesforce unless it unconditionally releases Salesforce of all liability), and (z) gives you all reasonable assistance, at your expense.
+
+WITHOUT LIMITING THE GENERALITY OF THE FOREGOING, THE SOFTWARE IS NOT SUPPORTED AND IS PROVIDED "AS IS," WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED. IN NO EVENT SHALL SALESFORCE HAVE ANY LIABILITY FOR ANY DAMAGES, INCLUDING, BUT NOT LIMITED TO, DIRECT, INDIRECT, SPECIAL, INCIDENTAL, PUNITIVE, OR CONSEQUENTIAL DAMAGES, OR DAMAGES BASED ON LOST PROFITS, DATA, OR USE, IN CONNECTION WITH THE SOFTWARE, HOWEVER CAUSED AND WHETHER IN CONTRACT, TORT, OR UNDER ANY OTHER THEORY OF LIABILITY, WHETHER OR NOT YOU HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ 
+These Terms of Use shall be governed exclusively by the internal laws of the State of California, without regard to its conflicts of laws rules. Each party hereby consents to the exclusive jurisdiction of the state and federal courts located in San Francisco County, California to adjudicate any dispute arising out of or relating to these Terms of Use and the download, installation, and/or use of the Software. Except as expressly stated herein, these Terms of Use constitute the entire agreement between the parties, and supersede all prior and contemporaneous agreements, proposals, or representations, written or oral, concerning their subject matter. No modification, amendment, or waiver of any provision of these Terms of Use shall be effective unless it is by an update to these Terms of Use that Salesforce makes available, or is in writing and signed by the party against whom the modification, amendment, or waiver is to be asserted.
+
+_*Data Privacy*_: Salesforce may collect, process, and store device, system, and other information related to your use of the Software. This information includes, but is not limited to, IP address, user metrics, and other data (“Usage Data”). Salesforce may use Usage Data for analytics, product development, and marketing purposes. You acknowledge that files generated in conjunction with the Software may contain sensitive or confidential data, and you are solely responsible for anonymizing and protecting such data.  

package/README.md

@@ -0,0 +1 @@
+This software is provided as-is with no support provided.

package/dist/index.js

@@ -0,0 +1,719 @@
+/*!
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+import { isSubscribableResult, deepFreeze, ok, toError } from "@conduit-client/utils";
+import { assertIsValid, MissingRequiredPropertyError, JsonSchemaViolationError } from "@conduit-client/jsonschema-validate";
+import { astResolver, Kind } from "@conduit-client/onestore-graphql-parser/v1";
+class Sanitizer {
+  constructor(obj) {
+    this.obj = obj;
+    this.copy = {};
+    this.currentPath = {
+      key: "",
+      value: obj,
+      parent: null,
+      data: this.copy
+    };
+  }
+  sanitize() {
+    const sanitizer = this;
+    JSON.stringify(this.obj, function(key, value) {
+      if (key === "") {
+        return value;
+      }
+      const parent = this;
+      if (parent !== sanitizer.currentPath.value) {
+        sanitizer.exit(parent);
+      }
+      if (typeof value === "object" && value !== null) {
+        sanitizer.enter(key, value);
+        return value;
+      }
+      sanitizer.currentPath.data[key] = value;
+      return value;
+    });
+    return this.copy;
+  }
+  enter(key, value) {
+    const { currentPath: parentPath } = this;
+    const data = parentPath.data[key] = Array.isArray(value) ? [] : {};
+    this.currentPath = {
+      key,
+      value,
+      parent: parentPath,
+      data
+    };
+  }
+  exit(parent) {
+    while (this.currentPath.value !== parent) {
+      this.currentPath = this.currentPath.parent || this.currentPath;
+    }
+  }
+}
+function sanitize(obj) {
+  return new Sanitizer(obj).sanitize();
+}
+function isUserVisibleError(error) {
+  return error instanceof Error && "type" in error && error.type === "user-visible";
+}
+function throwUserlandError(error) {
+  logError(error);
+  throw buildUserlandError(error);
+}
+function emitError(callback, error) {
+  logError(error);
+  callback({ data: void 0, error: buildUserlandError(error) });
+}
+function buildUserlandError(error) {
+  if (isUserVisibleError(error)) {
+    return error.data;
+  }
+  return new Error("Internal error in Lightning Data Service adapter occurred.");
+}
+function logError(error) {
+  if (isUserVisibleError(error)) {
+    return;
+  }
+  console.error("OneStore Command threw an error that we did not expect", error);
+}
+const supportedCachePolicyTypes = ["no-cache", "only-if-cached"];
+function requestContextIsSupportedCachePolicy(requestContext) {
+  return typeof requestContext === "object" && requestContext !== null && "cachePolicy" in requestContext && typeof requestContext.cachePolicy === "object" && requestContext.cachePolicy !== null && "type" in requestContext.cachePolicy && typeof requestContext.cachePolicy.type === "string" && supportedCachePolicyTypes.includes(
+    requestContext.cachePolicy.type
+  );
+}
+function getOverridesForLegacyRequestContext(requestContext) {
+  if (requestContextIsSupportedCachePolicy(requestContext)) {
+    return { cacheControlConfig: { type: requestContext.cachePolicy.type } };
+  }
+  return {};
+}
+class CommandWireAdapterConstructor {
+  constructor(callback, sourceContext, options) {
+    this.callback = callback;
+    this.connected = false;
+    this.exposeRefresh = false;
+    if (!(options == null ? void 0 : options.skipEmptyEmit)) {
+      this.emit();
+    }
+  }
+  connect() {
+    this.connected = true;
+    this.invokeAdapter();
+  }
+  disconnect() {
+    this.unsubscribe();
+    this.connected = false;
+  }
+  update(config, _context) {
+    this.unsubscribe();
+    this.config = sanitize(config);
+    this.invokeAdapter();
+  }
+  emit(result) {
+    try {
+      if (result === void 0) {
+        this.callback({ data: void 0, error: void 0 });
+      } else {
+        const consumerEmittedRefresh = () => {
+          if (!this.refresh) {
+            return Promise.resolve();
+          }
+          return new Promise((resolve, reject) => {
+            if (!this.refresh) {
+              resolve();
+              return;
+            }
+            this.refresh().then((res) => {
+              if (res.isOk()) {
+                resolve();
+              } else {
+                reject(
+                  new Error(
+                    "Internal error in Lightning Data Service adapter occurred: Failed to refresh data"
+                  )
+                );
+              }
+            });
+          });
+        };
+        let consumerEmittedData = {
+          data: void 0,
+          error: void 0
+        };
+        if (this.exposeRefresh && this.refresh) {
+          consumerEmittedData.refresh = consumerEmittedRefresh;
+        }
+        if (result.isErr()) {
+          if (isSubscribableResult(result)) {
+            consumerEmittedData.error = result.error.failure;
+          } else {
+            consumerEmittedData.error = result.error;
+          }
+        } else {
+          if (isSubscribableResult(result)) {
+            deepFreeze(result.value.data);
+            consumerEmittedData.data = result.value.data;
+          } else {
+            deepFreeze(result.value);
+            consumerEmittedData.data = result.value;
+          }
+        }
+        this.callback(consumerEmittedData);
+      }
+    } catch (e) {
+      this.handleExecutionThrow(e);
+    }
+  }
+  invokeAdapter() {
+    if (!this.connected || this.config === void 0) {
+      return;
+    }
+    if (this.configSchema) {
+      try {
+        assertIsValid(this.config, this.configSchema);
+      } catch (err2) {
+        if (isIncompleteConfigError(err2)) {
+          return;
+        }
+        throw err2;
+      }
+    }
+    const initialConfig = this.config;
+    const command = this.getCommand();
+    try {
+      command.execute().then((result) => {
+        if (!this.connected || this.config !== initialConfig) {
+          return;
+        }
+        this.refresh = void 0;
+        if (result.isOk()) {
+          if (isSubscribableResult(result)) {
+            const value = result.value;
+            this.unsubscriber = value.subscribe((updatedResult) => {
+              if (!this.connected || this.config !== initialConfig) {
+                this.unsubscribe();
+                return;
+              }
+              this.emit(updatedResult);
+            });
+            this.refresh = value.refresh;
+            this.emit(ok(value.data));
+          } else {
+            this.emit(result);
+          }
+        } else {
+          if (isSubscribableResult(result)) {
+            const value = result.error;
+            this.unsubscriber = value.subscribe((updatedResult) => {
+              if (!this.connected || this.config !== initialConfig) {
+                this.unsubscribe();
+                return;
+              }
+              this.emit(updatedResult);
+            });
+            this.refresh = value.refresh;
+            this.emit(result);
+          } else {
+            this.unsubscriber = () => {
+            };
+            this.emit(result);
+          }
+        }
+      });
+    } catch (e) {
+      this.handleExecutionThrow(e);
+    }
+  }
+  handleExecutionThrow(error) {
+    emitError(this.callback, error);
+  }
+  unsubscribe() {
+    if (this.unsubscriber) {
+      this.unsubscriber();
+      delete this.unsubscriber;
+    }
+  }
+}
+function isIncompleteConfigError(err2) {
+  return err2 instanceof MissingRequiredPropertyError || err2 instanceof JsonSchemaViolationError && err2.validationErrors.find(
+    (validationError) => validationError instanceof MissingRequiredPropertyError
+  ) !== void 0;
+}
+function buildAsyncImperativeInvoker(getCommand) {
+  return async (...params) => {
+    const command = getCommand({ params, assertIsValid });
+    try {
+      return command.execute().then(
+        (result) => {
+          if (result.isOk()) {
+            deepFreeze(result.value);
+            return isSubscribableResult(result) ? result.value.data : result.value;
+          }
+          throw toError(
+            isSubscribableResult(result) ? result.error.failure : result.error
+          );
+        },
+        (e) => {
+          throwUserlandError(e);
+        }
+      );
+    } catch (e) {
+      throwUserlandError(e);
+    }
+  };
+}
+function buildAsyncQueryImperativeInvoker(getCommand) {
+  const baseInvoker = buildAsyncImperativeInvoker(getCommand);
+  return async (...params) => ({ data: await baseInvoker(...params) });
+}
+function buildAsyncImperativeSubscribableInvoker(getCommand, exposeRefresh = false) {
+  return async (...params) => {
+    const command = getCommand({ params, assertIsValid });
+    let result;
+    try {
+      result = await command.execute();
+    } catch (e) {
+      throwUserlandError(e);
+    }
+    if (!isSubscribableResult(result)) {
+      console.error(
+        "Non-subscribable result encountered - please use correct operation type"
+      );
+      throw new Error("Internal error in Lightning Data Service adapter occurred");
+    }
+    if (result.isOk()) {
+      deepFreeze(result.value.data);
+      const api = {
+        data: result.value.data,
+        subscribe: (cb) => {
+          result.value.subscribe((result2) => {
+            if (result2.isErr()) {
+              return cb({ data: void 0, error: toError(result2.error) });
+            }
+            return cb({ data: result2.value, error: void 0 });
+          });
+        }
+      };
+      if (exposeRefresh) {
+        return {
+          ...api,
+          refresh: () => {
+            return result.value.refresh().then((res) => {
+              if (res.isOk()) {
+                return void 0;
+              }
+              throw res.error;
+            });
+          }
+        };
+      } else {
+        return api;
+      }
+    } else {
+      throw toError(result.error.failure);
+    }
+  };
+}
+function buildAsyncImperativeLegacyInvoker(getCommand) {
+  const invoke = async (config, requestContext, callback) => {
+    const command = getCommand({ config, assertIsValid });
+    try {
+      const overrides = getOverridesForLegacyRequestContext(requestContext);
+      const result = await command.execute(overrides);
+      if (result.isOk()) {
+        deepFreeze(result.value);
+        callback({ data: result.value.data, error: void 0 });
+      } else {
+        callback({ data: void 0, error: toError(result.error.failure) });
+      }
+    } catch (error) {
+      emitError(callback, error);
+    }
+  };
+  const subscribe = (config, requestContext, callback) => {
+    const command = getCommand({ config, assertIsValid });
+    let unsubscribe = () => {
+    };
+    try {
+      const overrides = getOverridesForLegacyRequestContext(requestContext);
+      command.execute(overrides).then(
+        (result) => {
+          if (!result.isOk()) {
+            callback({ data: void 0, error: toError(result.error.failure) });
+            return;
+          }
+          unsubscribe = result.value.subscribe((res) => {
+            if (res.isOk()) {
+              callback({ data: res.value, error: void 0 });
+            } else {
+              callback({ data: void 0, error: toError(res.error) });
+            }
+          });
+          callback({ data: result.value.data, error: void 0 });
+        },
+        (e) => {
+          emitError(callback, e);
+        }
+      );
+    } catch (e) {
+      emitError(callback, e);
+    }
+    return () => {
+      unsubscribe();
+    };
+  };
+  return { invoke, subscribe };
+}
+class GraphQLCommandErrorWithData extends Error {
+  constructor(data) {
+    super();
+    this.data = data;
+  }
+}
+function throwGraphQLError(error) {
+  logError(error);
+  if (isUserVisibleError(error)) {
+    throw new GraphQLCommandErrorWithData(error.data);
+  }
+  throw new Error("Internal error in GraphQL adapter occurred");
+}
+function findExecutableOperation(document, operationName) {
+  const operations = document.definitions.filter(
+    (def) => def.kind === Kind.OPERATION_DEFINITION
+  );
+  if (operations.length === 0) {
+    return void 0;
+  }
+  if (operations.length === 1 && !operationName) {
+    return operations[0];
+  }
+  if (operationName) {
+    return operations.find((op) => {
+      var _a;
+      return ((_a = op.name) == null ? void 0 : _a.value) === operationName;
+    });
+  }
+  return void 0;
+}
+function validateGraphQLOperations(config, options) {
+  const executableOperation = findExecutableOperation(config.query, config.operationName);
+  if (executableOperation) {
+    const operationType = executableOperation.operation;
+    if (!options.acceptedOperations.includes(operationType)) {
+      const operationTypeCapitalized = operationType.charAt(0).toUpperCase() + operationType.slice(1);
+      throw new Error(
+        `${operationTypeCapitalized} operations are not supported in this context`
+      );
+    }
+  }
+}
+function resolveAst(ast) {
+  if (ast === null || ast === void 0) {
+    return;
+  }
+  const result = astResolver(ast);
+  if (result === void 0) {
+    throw new Error("Could not resolve AST. Did you parse the query with gql?");
+  }
+  return result;
+}
+function wrapConfigAndVerify(config, options) {
+  if (config == null ? void 0 : config.query) {
+    config = { ...config, query: resolveAst(config.query) };
+    if (config.query === void 0) {
+      throw new Error("Internal error in GraphQL adapter occurred: Unable to resolve query");
+    }
+    validateGraphQLOperations(config, {
+      acceptedOperations: (options == null ? void 0 : options.acceptedOperations) ?? ["query"]
+    });
+  }
+  return config;
+}
+function toGraphQLResponseFromFailure(failure) {
+  if (isUserVisibleError(failure)) {
+    return {
+      data: failure.data.data,
+      errors: failure.data.errors
+    };
+  }
+  logError(failure);
+  return {
+    data: void 0,
+    errors: [{ message: "Internal error in GraphQL adapter occurred", locations: [] }]
+  };
+}
+class GraphQLCommandWireAdapterConstructor extends CommandWireAdapterConstructor {
+  emit(result) {
+    try {
+      if (result === void 0) {
+        this.callback({ data: void 0, errors: void 0 });
+      } else {
+        const consumerEmittedRefresh = () => {
+          if (!this.refresh) {
+            return Promise.resolve();
+          }
+          return new Promise((resolve, reject) => {
+            if (!this.refresh) {
+              resolve();
+              return;
+            }
+            this.refresh().then((res) => {
+              if (res.isOk()) {
+                resolve();
+              } else {
+                reject(
+                  new Error(
+                    "Internal error in GraphQL adapter occurred: Failed to refresh GraphQL data"
+                  )
+                );
+              }
+            });
+          });
+        };
+        let consumerEmittedData = {
+          data: void 0,
+          errors: void 0
+        };
+        if (this.exposeRefresh && this.refresh) {
+          consumerEmittedData.refresh = consumerEmittedRefresh;
+        }
+        if (result.isErr()) {
+          const failure = isSubscribableResult(result) ? result.error.failure : result.error;
+          const resp = toGraphQLResponseFromFailure(failure);
+          consumerEmittedData.data = resp.data;
+          consumerEmittedData.errors = resp.errors;
+        } else {
+          consumerEmittedData.data = result.value.data;
+        }
+        deepFreeze(consumerEmittedData);
+        this.callback(consumerEmittedData);
+      }
+    } catch (e) {
+      logError(e);
+      this.handleExecutionThrow(e);
+    }
+  }
+  handleExecutionThrow(e) {
+    logError(e);
+    this.callback({
+      data: void 0,
+      errors: [{ message: "Internal error in GraphQL adapter occurred", locations: [] }]
+    });
+  }
+  update(config, _context) {
+    this.unsubscribe();
+    const resolvedQuery = resolveAst(config.query);
+    if (resolvedQuery) {
+      validateGraphQLOperations(
+        { query: resolvedQuery, operationName: config == null ? void 0 : config.operationName },
+        { acceptedOperations: ["query"] }
+      );
+    }
+    this.config = {
+      ...sanitize(config),
+      query: resolvedQuery
+    };
+    this.invokeAdapter();
+  }
+}
+function buildAsyncGraphQLImperativeInvoker(getCommand, exposeRefresh = false) {
+  return async (...params) => {
+    try {
+      if (params.length) {
+        params[0] = wrapConfigAndVerify(params[0]);
+      }
+      const command = getCommand({ params, assertIsValid });
+      const result = await command.execute();
+      const consumerEmittedData = {
+        data: void 0,
+        errors: void 0
+      };
+      if (result.isOk()) {
+        deepFreeze(result.value);
+        consumerEmittedData.data = result.value.data.data;
+        consumerEmittedData.subscribe = (cb) => {
+          result.value.subscribe((res) => {
+            const consumerEmittedData2 = {
+              data: void 0,
+              errors: void 0
+            };
+            if (res.isOk()) {
+              consumerEmittedData2.data = res.value.data;
+            } else {
+              if (isUserVisibleError(res.error)) {
+                consumerEmittedData2.data = res.error.data.data;
+                consumerEmittedData2.errors = res.error.data.errors;
+              } else {
+                logError(res.error);
+                consumerEmittedData2.errors = [
+                  {
+                    message: "Internal error in GraphQL adapter occurred",
+                    locations: []
+                  }
+                ];
+              }
+            }
+            cb(consumerEmittedData2);
+          });
+        };
+        if (exposeRefresh) {
+          consumerEmittedData.refresh = () => {
+            return new Promise((resolve, reject) => {
+              try {
+                result.value.refresh().then((res) => {
+                  if (res.isOk()) {
+                    resolve();
+                  } else {
+                    reject(
+                      new Error(
+                        "Internal error in GraphQL adapter occurred: Failed to refresh GraphQL data"
+                      )
+                    );
+                  }
+                });
+              } catch (error) {
+                logError(error);
+                reject(
+                  new Error(
+                    "Internal error in GraphQL adapter occurred: Failed to refresh GraphQL data"
+                  )
+                );
+              }
+            });
+          };
+        }
+      } else {
+        const resp = toGraphQLResponseFromFailure(result.error.failure);
+        consumerEmittedData.data = resp.data;
+        consumerEmittedData.errors = resp.errors;
+      }
+      return consumerEmittedData;
+    } catch (error) {
+      logError(error);
+      return {
+        data: void 0,
+        errors: [{ message: "Internal error in GraphQL adapter occurred", locations: [] }]
+      };
+    }
+  };
+}
+function buildAsyncGraphQLMutationInvoker(getCommand) {
+  return async (...params) => {
+    try {
+      if (params.length) {
+        params[0] = wrapConfigAndVerify(params[0], { acceptedOperations: ["mutation"] });
+      }
+      const command = getCommand({ params, assertIsValid });
+      const result = await command.execute({ cacheControlConfig: { type: "no-cache" } });
+      if (result.isOk()) {
+        deepFreeze(result.value);
+        return result.value.data;
+      } else {
+        return toGraphQLResponseFromFailure(result.error.failure);
+      }
+    } catch (error) {
+      logError(error);
+      return {
+        data: void 0,
+        errors: [{ message: "Internal error in GraphQL adapter occurred", locations: [] }]
+      };
+    }
+  };
+}
+function buildAsyncGraphQLImperativeLegacyInvoker(getCommand) {
+  const invoke = async (config, requestContext, callback) => {
+    config = wrapConfigAndVerify(config);
+    const command = getCommand({ config, assertIsValid });
+    try {
+      const overrides = getOverridesForLegacyRequestContext(requestContext);
+      const result = await command.execute(overrides);
+      const consumerEmittedData = {
+        data: void 0,
+        errors: void 0
+      };
+      if (result.isOk()) {
+        deepFreeze(result.value);
+        consumerEmittedData.data = result.value.data.data;
+      } else {
+        const { data, errors } = toGraphQLResponseFromFailure(result.error.failure);
+        consumerEmittedData.data = data;
+        consumerEmittedData.errors = errors;
+      }
+      callback(consumerEmittedData);
+    } catch (error) {
+      logError(error);
+      callback({
+        data: void 0,
+        errors: [{ message: "Internal error in GraphQL adapter occurred", locations: [] }]
+      });
+    }
+  };
+  const subscribe = (config, requestContext, callback) => {
+    config = wrapConfigAndVerify(config);
+    const command = getCommand({ config, assertIsValid });
+    let unsubscribe = () => {
+    };
+    const overrides = getOverridesForLegacyRequestContext(requestContext);
+    command.execute(overrides).then((result) => {
+      const consumerEmittedData = {
+        data: void 0,
+        errors: void 0
+      };
+      if (result.isOk()) {
+        deepFreeze(result.value);
+        consumerEmittedData.data = result.value.data.data;
+        unsubscribe = result.value.subscribe(
+          (res) => {
+            handleEmit(res, callback);
+          }
+        );
+      } else {
+        const { data, errors } = toGraphQLResponseFromFailure(result.error.failure);
+        consumerEmittedData.data = data;
+        consumerEmittedData.errors = errors;
+        unsubscribe = result.error.subscribe(
+          (res) => {
+            handleEmit(res, callback);
+          }
+        );
+      }
+      callback(consumerEmittedData);
+    });
+    return () => {
+      unsubscribe();
+    };
+  };
+  return { invoke, subscribe };
+}
+function handleEmit(res, callback) {
+  const consumerEmittedData = {
+    data: void 0,
+    errors: void 0
+  };
+  if (res.isOk()) {
+    consumerEmittedData.data = res.value.data;
+  } else {
+    const { data, errors } = toGraphQLResponseFromFailure(res.error);
+    consumerEmittedData.data = data;
+    consumerEmittedData.errors = errors;
+  }
+  callback(consumerEmittedData);
+}
+export {
+  CommandWireAdapterConstructor,
+  GraphQLCommandErrorWithData,
+  GraphQLCommandWireAdapterConstructor,
+  buildAsyncGraphQLImperativeInvoker,
+  buildAsyncGraphQLImperativeLegacyInvoker,
+  buildAsyncGraphQLMutationInvoker,
+  buildAsyncImperativeInvoker,
+  buildAsyncImperativeLegacyInvoker,
+  buildAsyncImperativeSubscribableInvoker,
+  buildAsyncQueryImperativeInvoker,
+  resolveAst,
+  throwGraphQLError
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../src/sanitize.ts","../src/utils.ts","../src/CommandWireAdapterConstructor.ts","../src/imperative.ts","../src/graphql-utils.ts","../src/graphql-wire.ts","../src/graphql-imperative.ts","../src/graphql-mutation.ts","../src/graphql-imperative-legacy.ts"],"sourcesContent":["interface CurrentPath {\n    key: string;\n    value: object;\n    parent: CurrentPath | null;\n    data: any;\n}\n\nclass Sanitizer<T extends object> {\n    obj: T;\n    copy: T;\n    currentPath: CurrentPath;\n\n    constructor(obj: T) {\n        this.obj = obj;\n        this.copy = {} as T;\n\n        this.currentPath = {\n            key: '',\n            value: obj,\n            parent: null,\n            data: this.copy,\n        };\n    }\n\n    sanitize(): T {\n        const sanitizer = this;\n\n        JSON.stringify(this.obj, function (key, value) {\n            if (key === '') {\n                return value;\n            }\n\n            const parent = this;\n            if (parent !== sanitizer.currentPath.value) {\n                sanitizer.exit(parent);\n            }\n            if (typeof value === 'object' && value !== null) {\n                sanitizer.enter(key, value);\n                return value;\n            }\n            sanitizer.currentPath.data[key] = value;\n\n            return value;\n        });\n\n        return this.copy;\n    }\n\n    private enter(key: string, value: any) {\n        const { currentPath: parentPath } = this;\n        const data = (parentPath.data[key] = Array.isArray(value) ? [] : {});\n        this.currentPath = {\n            key,\n            value,\n            parent: parentPath,\n            data,\n        };\n    }\n\n    private exit(parent: any) {\n        while (this.currentPath.value !== parent) {\n            this.currentPath = this.currentPath.parent || this.currentPath;\n        }\n    }\n}\n\n/**\n * Returns a sanitized version of an object by recursively unwrapping the Proxies.\n *\n * All the data coming from LWC-land need to be sanitized first.\n */\nexport default function sanitize<T extends object>(obj: T): T {\n    return new Sanitizer(obj).sanitize();\n}\n","import type { Callback, IInternalError, IUserVisibleError } from '@conduit-client/utils';\n\nexport function isInternalError<Data = undefined>(error: unknown): error is IInternalError<Data> {\n    return error instanceof Error && 'type' in error && error.type === 'internal';\n}\n\nexport function isUserVisibleError<Data = undefined>(\n    error: unknown\n): error is IUserVisibleError<Data> {\n    return error instanceof Error && 'type' in error && error.type === 'user-visible';\n}\n\nexport function throwUserlandError(error: unknown): never {\n    logError(error);\n    throw buildUserlandError(error);\n}\n\nexport function emitError(callback: Callback<any>, error: unknown): void {\n    logError(error);\n    callback({ data: undefined, error: buildUserlandError(error) });\n}\n\nexport function buildUserlandError(error: unknown): Error {\n    if (isUserVisibleError<Error>(error)) {\n        return error.data;\n    }\n\n    return new Error('Internal error in Lightning Data Service adapter occurred.');\n}\n\nexport function logError(error: unknown): void {\n    if (isUserVisibleError(error)) {\n        return;\n    }\n\n    console.error('OneStore Command threw an error that we did not expect', error);\n}\n\nexport const supportedCachePolicyTypes = ['no-cache', 'only-if-cached'] as const;\nexport type SupportedCachePolicyType = (typeof supportedCachePolicyTypes)[number];\n\nexport type CachePolicy = {\n    cachePolicy: {\n        type: SupportedCachePolicyType;\n    };\n};\n\n/**\n * Type guard for legacy requestContext objects used with imperative-legacy bindings.\n *\n * When this function returns true, it indicates the caller requested a supported\n * cache policy override. Currently the only supported policy is `no-cache`.\n *\n * This helper is intentionally low-level; prefer using\n * {@link getOverridesForLegacyRequestContext} at call sites to construct the\n * proper `execute` overrides for Commands.\n */\nexport function requestContextIsSupportedCachePolicy(\n    requestContext: unknown\n): requestContext is CachePolicy {\n    return (\n        typeof requestContext === 'object' &&\n        requestContext !== null &&\n        'cachePolicy' in requestContext &&\n        typeof requestContext.cachePolicy === 'object' &&\n        requestContext.cachePolicy !== null &&\n        'type' in requestContext.cachePolicy &&\n        typeof requestContext.cachePolicy.type === 'string' &&\n        supportedCachePolicyTypes.includes(\n            requestContext.cachePolicy.type as SupportedCachePolicyType\n        )\n    );\n}\n\nexport type LegacyExecuteOverrides = {\n    cacheControlConfig?: { type: SupportedCachePolicyType };\n};\n\n/**\n * Builds the `execute` overrides for legacy imperative invokers based on the\n * provided requestContext. Encapsulates all hard-coded knowledge of supported\n * cache policies for legacy adapters.\n *\n * - If {@link requestContextIsSupportedCachePolicy} matches `no-cache`, returns\n *   `{ cacheControlConfig: { type: 'no-cache' } }`.\n * - Otherwise returns `{}`.\n *\n * Use this in `buildAsyncImperativeLegacyInvoker` and GraphQL legacy invokers\n * to centralize override behavior.\n */\nexport function getOverridesForLegacyRequestContext(\n    requestContext: unknown\n): LegacyExecuteOverrides {\n    if (requestContextIsSupportedCachePolicy(requestContext)) {\n        return { cacheControlConfig: { type: requestContext.cachePolicy.type } };\n    }\n    return {};\n}\n","import { type Command } from '@conduit-client/command-base/v1';\nimport {\n    toError,\n    deepFreeze,\n    type Result,\n    ok,\n    isSubscribableResult,\n    err,\n} from '@conduit-client/utils';\nimport {\n    type WireAdapter,\n    type WireConfigValue,\n    type WireContextValue,\n    type WireDataCallback,\n} from '@conduit-client/lwc-types';\nimport {\n    assertIsValid,\n    MissingRequiredPropertyError,\n    type JSONSchema,\n    JsonSchemaViolationError,\n} from '@conduit-client/jsonschema-validate';\nimport sanitize from './sanitize';\nimport type {\n    SyncOrAsync,\n    Unsubscribe,\n    SubscribableResult,\n    CommandError,\n} from '@conduit-client/utils';\nimport { emitError } from './utils';\n\ntype MaybeSubscribableResultCommand<Data, Error> = Command<\n    SyncOrAsync<Result<Data, Error> | SubscribableResult<Data, Error>>\n>;\nexport type SubscribableResultCommand<Data, Error> = Command<\n    SyncOrAsync<SubscribableResult<Data, Error>>\n>;\nexport type ResultCommand<Data, Error> = Command<SyncOrAsync<Result<Data, Error>>>;\nexport type WireAdapterCompatibleCommand<Data, Error> =\n    | SubscribableResultCommand<Data, Error>\n    | ResultCommand<Data, Error>\n    | MaybeSubscribableResultCommand<Data, Error>;\n\n/**\n * Binds a Command to a LWC wire adapter.\n * @see https://lwc.dev/guide/wire_adapter\n */\nexport abstract class CommandWireAdapterConstructor<\n    Data,\n    Config extends WireConfigValue = WireConfigValue,\n    CommandType extends WireAdapterCompatibleCommand<\n        Data,\n        CommandError\n    > = WireAdapterCompatibleCommand<Data, CommandError>,\n> implements WireAdapter\n{\n    connected = false;\n    config?: Config;\n    unsubscriber?: Unsubscribe;\n    exposeRefresh = false;\n\n    abstract configSchema?: JSONSchema;\n    abstract getCommand(): CommandType;\n    protected refresh?: () => SyncOrAsync<Result<void, unknown>>;\n\n    constructor(\n        protected callback: WireDataCallback,\n        sourceContext?: {\n            tagName?: string;\n        },\n        options?: {\n            skipEmptyEmit?: true;\n        }\n    ) {\n        if (!options?.skipEmptyEmit) {\n            this.emit();\n        }\n    }\n\n    connect(): void {\n        this.connected = true;\n        this.invokeAdapter();\n    }\n\n    disconnect(): void {\n        this.unsubscribe();\n        this.connected = false;\n    }\n\n    update(config: Config, _context?: WireContextValue): void {\n        this.unsubscribe();\n        this.config = sanitize<Config>(config);\n        this.invokeAdapter();\n    }\n\n    protected emit(result?: Result<Data, unknown> | SubscribableResult<Data, unknown>) {\n        try {\n            if (result === undefined) {\n                this.callback({ data: undefined, error: undefined });\n            } else {\n                const consumerEmittedRefresh = (): Promise<void> => {\n                    if (!this.refresh) {\n                        return Promise.resolve();\n                    }\n                    return new Promise((resolve, reject) => {\n                        if (!this.refresh) {\n                            resolve();\n                            return;\n                        }\n                        this.refresh().then((res) => {\n                            if (res.isOk()) {\n                                resolve();\n                            } else {\n                                reject(\n                                    new Error(\n                                        'Internal error in Lightning Data Service adapter occurred: Failed to refresh data'\n                                    )\n                                );\n                            }\n                        });\n                    });\n                };\n\n                let consumerEmittedData = {\n                    data: undefined,\n                    error: undefined,\n                } as {\n                    data: Data | undefined;\n                    error: unknown | undefined;\n                    refresh?: () => Promise<void>;\n                };\n\n                if (this.exposeRefresh && this.refresh) {\n                    consumerEmittedData.refresh = consumerEmittedRefresh;\n                }\n\n                if (result.isErr()) {\n                    if (isSubscribableResult(result)) {\n                        consumerEmittedData.error = result.error.failure;\n                    } else {\n                        consumerEmittedData.error = result.error;\n                    }\n                } else {\n                    if (isSubscribableResult(result)) {\n                        deepFreeze(result.value.data);\n                        consumerEmittedData.data = result.value.data;\n                    } else {\n                        deepFreeze(result.value);\n                        consumerEmittedData.data = result.value;\n                    }\n                }\n\n                this.callback(consumerEmittedData);\n            }\n        } catch (e) {\n            this.handleExecutionThrow(e);\n        }\n    }\n\n    protected invokeAdapter() {\n        if (!this.connected || this.config === undefined) {\n            return;\n        }\n\n        if (this.configSchema) {\n            try {\n                assertIsValid<unknown>(this.config, this.configSchema);\n            } catch (err) {\n                if (isIncompleteConfigError(err)) {\n                    // config is incomplete, wait for updated config\n                    return;\n                }\n\n                throw err;\n            }\n        }\n\n        const initialConfig = this.config;\n        const command = this.getCommand();\n\n        try {\n            command.execute().then((result) => {\n                // config changed or component disconnected before result came back, ignore result\n                if (!this.connected || this.config !== initialConfig) {\n                    return;\n                }\n\n                this.refresh = undefined;\n\n                if (result.isOk()) {\n                    if (isSubscribableResult<Data, unknown>(result)) {\n                        const value = result.value;\n                        this.unsubscriber = value.subscribe((updatedResult) => {\n                            if (!this.connected || this.config !== initialConfig) {\n                                this.unsubscribe();\n                                return;\n                            }\n\n                            this.emit(updatedResult);\n                        });\n                        this.refresh = value.refresh;\n                        this.emit(ok(value.data));\n                    } else {\n                        this.emit(result);\n                    }\n                } else {\n                    if (isSubscribableResult(result)) {\n                        const value = result.error;\n                        this.unsubscriber = value.subscribe((updatedResult) => {\n                            if (!this.connected || this.config !== initialConfig) {\n                                this.unsubscribe();\n                                return;\n                            }\n\n                            this.emit(updatedResult);\n                        });\n                        this.refresh = value.refresh;\n                        this.emit(result);\n                    } else {\n                        this.unsubscriber = () => {};\n                        this.emit(result);\n                    }\n                }\n            });\n        } catch (e: unknown) {\n            this.handleExecutionThrow(e);\n        }\n    }\n\n    protected handleExecutionThrow(error: unknown) {\n        emitError(this.callback, error);\n    }\n\n    protected unsubscribe() {\n        if (this.unsubscriber) {\n            this.unsubscriber();\n            delete this.unsubscriber;\n        }\n    }\n}\n\nfunction isIncompleteConfigError(err: unknown): boolean {\n    return (\n        err instanceof MissingRequiredPropertyError ||\n        (err instanceof JsonSchemaViolationError &&\n            err.validationErrors.find(\n                (validationError) => validationError instanceof MissingRequiredPropertyError\n            ) !== undefined)\n    );\n}\n","import { assertIsValid, type JSONSchema } from '@conduit-client/jsonschema-validate';\nimport { type Command } from '@conduit-client/command-base/v1';\nimport { toError, deepFreeze, isSubscribableResult } from '@conduit-client/utils';\nimport type {\n    SyncOrAsync,\n    Result,\n    SubscribableResult,\n    Unsubscribe,\n    Callback,\n} from '@conduit-client/utils';\nimport { emitError, throwUserlandError, getOverridesForLegacyRequestContext } from './utils';\nimport type { LegacyExecuteOverrides } from './utils';\n\ntype MaybeSubscribableResultCommand<Data> = Command<\n    SyncOrAsync<Result<Data, unknown> | SubscribableResult<Data, unknown>>\n>;\ntype SubscribableResultCommand<Data, Params extends Array<any> = []> = Command<\n    SyncOrAsync<SubscribableResult<Data, unknown>>,\n    Params\n>;\ntype ResultCommand<Data> = Command<SyncOrAsync<Result<Data, unknown>>>;\ntype ImperativeCommand<Data> =\n    | SubscribableResultCommand<Data>\n    | ResultCommand<Data>\n    | MaybeSubscribableResultCommand<Data>;\n\n/**\n * Returns an async function wrapper around an `ImperativeCommand`.  Handles\n * both subscribable and non-subscribable commands, but only returns regular data.\n *\n * @typeParam Params parameters accepted by the generated function\n * @typeParam Config Command config type\n * @typeParam Data data returned by the Command\n * @param getCommand utility function that constructs an instance of the Command from\n *     the supplied parameters; the function should do any necessary parameter checking\n *     and throw errors as appropriate\n * @returns A PromiseLike containing the result of command execution\n */\nexport function buildAsyncImperativeInvoker<Params extends Array<any>, Data>(\n    getCommand: (options: {\n        params: Params;\n        // utility to validate data against a JSONSchema\n        assertIsValid: <T>(data: unknown, schema: JSONSchema) => asserts data is T;\n    }) => ImperativeCommand<Data>\n): (...params: Params) => DefaultImperativeResult<Data> {\n    return async (...params: Params) => {\n        const command = getCommand({ params, assertIsValid });\n        try {\n            return command.execute().then(\n                (result) => {\n                    if (result.isOk()) {\n                        deepFreeze(result.value);\n                        // For subscribable results processed by this invoker, only return data\n                        return isSubscribableResult(result) ? result.value.data : result.value;\n                    }\n\n                    throw toError(\n                        isSubscribableResult(result) ? result.error.failure : result.error\n                    );\n                },\n                (e) => {\n                    throwUserlandError(e);\n                }\n            );\n        } catch (e) {\n            throwUserlandError(e);\n        }\n    };\n}\n\n/**\n * Returns an async function wrapper around a query `Command`.  Handles\n * both subscribable and non-subscribable commands, but only returns regular data.\n *\n * @typeParam Params parameters accepted by the generated function\n * @typeParam Config Command config type\n * @typeParam Data data returned by the Command\n * @param getCommand utility function that constructs an instance of the Command from\n *     the supplied parameters; the function should do any necessary parameter checking\n *     and throw errors as appropriate\n * @returns A PromiseLike containing the result of command execution\n */\nexport function buildAsyncQueryImperativeInvoker<Params extends Array<any>, Data>(\n    getCommand: (options: {\n        params: Params;\n        // utility to validate data against a JSONSchema\n        assertIsValid: <T>(data: unknown, schema: JSONSchema) => asserts data is T;\n    }) => ImperativeCommand<Data>\n): (...params: Params) => QueryImperativeResult<Data> {\n    const baseInvoker = buildAsyncImperativeInvoker(getCommand);\n    return async (...params: Params) => ({ data: await baseInvoker(...params) });\n}\n\nexport type DefaultImperativeResult<Data> = PromiseLike<Data>;\nexport type QueryImperativeResult<Data> = PromiseLike<{ data: Data }>;\n\nexport type SubscribableImperativeResult<Data> = PromiseLike<{\n    data: Data;\n    subscribe: (cb: Callback<any>) => void;\n}>;\n\nexport type SubscribableRefreshableImperativeResult<Data> = PromiseLike<{\n    data: Data;\n    subscribe: (cb: Callback<any>) => void;\n    refresh: () => PromiseLike<void>;\n}>;\n\nexport type MaybeRefreshableSubscribableImperativeResult<Data> =\n    | SubscribableImperativeResult<Data>\n    | SubscribableRefreshableImperativeResult<Data>;\n\n/**\n * Returns an async function wrapper around an `ImperativeCommand`.  Handles\n * only subscribable commands and returns a subscribable result.\n *\n * @typeParam Params parameters accepted by the generated function\n * @typeParam Config Command config type\n * @typeParam Data data returned by the Command\n * @param getCommand utility function that constructs an instance of the Command from\n *     the supplied parameters; the function should do any necessary parameter checking\n *     and throw errors as appropriate\n * @param exposeRefresh whether to expose a `refresh` method on the result returned by\n *     the generated function.  The default is `false`.\n * @returns A PromiseLike containing the subscribable result of command execution\n */\nexport function buildAsyncImperativeSubscribableInvoker<Params extends Array<any>, Data>(\n    getCommand: (options: {\n        params: Params;\n        // utility to validate data against a JSONSchema\n        assertIsValid: <T>(data: unknown, schema: JSONSchema) => asserts data is T;\n    }) => ImperativeCommand<Data>,\n    exposeRefresh = false\n): (...params: Params) => MaybeRefreshableSubscribableImperativeResult<Data> {\n    return async (...params: Params) => {\n        const command = getCommand({ params, assertIsValid });\n        let result: Result<Data, unknown> | SubscribableResult<Data, unknown>;\n        try {\n            result = await command.execute();\n        } catch (e) {\n            throwUserlandError(e);\n        }\n\n        if (!isSubscribableResult(result)) {\n            console.error(\n                'Non-subscribable result encountered - please use correct operation type'\n            );\n            throw new Error('Internal error in Lightning Data Service adapter occurred');\n        }\n        if (result.isOk()) {\n            deepFreeze(result.value.data);\n\n            const api = {\n                data: result.value.data,\n                subscribe: (cb: Callback<any>) => {\n                    result.value.subscribe((result) => {\n                        if (result.isErr()) {\n                            return cb({ data: undefined, error: toError(result.error) });\n                        }\n\n                        return cb({ data: result.value, error: undefined });\n                    });\n                },\n            };\n\n            if (exposeRefresh) {\n                return {\n                    ...api,\n                    refresh: () => {\n                        return result.value.refresh().then((res) => {\n                            if (res.isOk()) {\n                                return undefined;\n                            }\n                            throw res.error;\n                        });\n                    },\n                };\n            } else {\n                return api;\n            }\n        } else {\n            throw toError(result.error.failure);\n        }\n    };\n}\n\ntype LegacyImperativeCallbackResult<Data> =\n    | { data: Data; error: undefined }\n    | { data: undefined; error: Error };\n\ntype LegacyImperativeAdapterInvokeType<Config, Data> = (\n    config: Config,\n    context: unknown,\n    callback: (result: LegacyImperativeCallbackResult<Data>) => void\n) => void;\n\ntype LegacyImperativeAdapterSubscribeType<Config, Data> = (\n    config: Config,\n    context: unknown,\n    callback: (result: LegacyImperativeCallbackResult<Data>) => void\n) => Unsubscribe;\n\nexport type LegacyImperativeShape<Config, Data> = {\n    invoke: LegacyImperativeAdapterInvokeType<Config, Data>;\n    subscribe: LegacyImperativeAdapterSubscribeType<Config, Data>;\n};\n\nexport function buildAsyncImperativeLegacyInvoker<Config, Data>(\n    getCommand: (options: {\n        config: Config;\n        assertIsValid: <T>(data: unknown, schema: JSONSchema) => asserts data is T;\n    }) => SubscribableResultCommand<Data, [LegacyExecuteOverrides?]>\n): LegacyImperativeShape<Config, Data> {\n    const invoke: LegacyImperativeAdapterInvokeType<Config, Data> = async (\n        config: Config,\n        requestContext: unknown,\n        callback: (result: LegacyImperativeCallbackResult<Data>) => void\n    ) => {\n        const command = getCommand({ config, assertIsValid });\n\n        try {\n            const overrides = getOverridesForLegacyRequestContext(requestContext);\n            const result = await command.execute(overrides);\n            if (result.isOk()) {\n                deepFreeze(result.value);\n                callback({ data: result.value.data, error: undefined });\n            } else {\n                callback({ data: undefined, error: toError(result.error.failure) });\n            }\n        } catch (error) {\n            emitError(callback, error);\n        }\n    };\n\n    const subscribe: LegacyImperativeAdapterSubscribeType<Config, Data> = (\n        config: Config,\n        requestContext: unknown,\n        callback: (result: LegacyImperativeCallbackResult<Data>) => void\n    ) => {\n        const command = getCommand({ config, assertIsValid });\n\n        let unsubscribe: Unsubscribe = () => {};\n\n        try {\n            const overrides = getOverridesForLegacyRequestContext(requestContext);\n            command.execute(overrides).then(\n                (result: Awaited<ReturnType<typeof command.execute>>) => {\n                    if (!result.isOk()) {\n                        callback({ data: undefined, error: toError(result.error.failure) });\n                        return;\n                    }\n\n                    unsubscribe = result.value.subscribe((res: Result<Data, unknown>) => {\n                        if (res.isOk()) {\n                            callback({ data: res.value, error: undefined });\n                        } else {\n                            callback({ data: undefined, error: toError(res.error) });\n                        }\n                    });\n\n                    callback({ data: result.value.data, error: undefined });\n                },\n                (e: unknown) => {\n                    emitError(callback, e);\n                }\n            );\n        } catch (e) {\n            emitError(callback, e);\n        }\n\n        return () => {\n            unsubscribe();\n        };\n    };\n\n    return { invoke, subscribe };\n}\n","import { SubscribableResultCommand } from './CommandWireAdapterConstructor';\nimport {\n    Callback,\n    deepFreeze,\n    Result,\n    SubscribableResult,\n    IErrorWithData,\n    isSubscribableResult,\n} from '@conduit-client/utils';\nimport {\n    type GraphQLCommandError,\n    type GraphQLResponse,\n} from '@conduit-client/graphql-normalization/v1';\nimport {\n    astResolver,\n    DocumentNode,\n    Kind,\n    OperationDefinitionNode,\n} from '@conduit-client/onestore-graphql-parser/v1';\nimport { isUserVisibleError, logError } from './utils';\n\nexport type GraphQLCommand = SubscribableResultCommand<GraphQLResponse, GraphQLCommandError>;\n\nexport class GraphQLCommandErrorWithData extends Error implements IErrorWithData<GraphQLResponse> {\n    constructor(public data: GraphQLResponse) {\n        super();\n    }\n}\n\nexport function throwGraphQLError(error: unknown): never {\n    logError(error);\n    if (isUserVisibleError<GraphQLResponse>(error)) {\n        throw new GraphQLCommandErrorWithData(error.data);\n    }\n    throw new Error('Internal error in GraphQL adapter occurred');\n}\n\n/**\n * Finds the executable operation from a GraphQL document based on operationName\n * @param document The GraphQL DocumentNode\n * @param operationName Optional operation name to select specific operation\n * @returns The executable operation or undefined if none found\n */\nfunction findExecutableOperation(\n    document: DocumentNode,\n    operationName?: string\n): OperationDefinitionNode | undefined {\n    const operations = document.definitions.filter(\n        (def) => def.kind === Kind.OPERATION_DEFINITION\n    ) as OperationDefinitionNode[];\n\n    if (operations.length === 0) {\n        return undefined;\n    }\n\n    if (operations.length === 1 && !operationName) {\n        return operations[0];\n    }\n\n    if (operationName) {\n        return operations.find((op) => op.name?.value === operationName);\n    }\n\n    // Multiple operations found but no operation name provided\n    // In this case, we can't determine which operation will be executed\n    // so we can't validate. Let GraphQL execution handle this error.\n    return undefined;\n}\n\n/**\n * Validates a GraphQL config and rejects operations not in the accepted list\n * @param config The GraphQL config containing query and operationName\n * @param options Options containing acceptedOperations array\n * @throws Error if the executable operation is not in acceptedOperations\n */\nexport function validateGraphQLOperations(\n    config: { query: DocumentNode; operationName?: string },\n    options: { acceptedOperations: ('query' | 'mutation' | 'subscription')[] }\n): void {\n    const executableOperation = findExecutableOperation(config.query, config.operationName);\n\n    if (executableOperation) {\n        const operationType = executableOperation.operation;\n        if (!options.acceptedOperations.includes(operationType)) {\n            const operationTypeCapitalized =\n                operationType.charAt(0).toUpperCase() + operationType.slice(1);\n            throw new Error(\n                `${operationTypeCapitalized} operations are not supported in this context`\n            );\n        }\n    }\n}\n\nexport function resolveAst(ast: any): DocumentNode | undefined {\n    if (ast === null || ast === undefined) {\n        return;\n    }\n    const result = astResolver(ast);\n    if (result === undefined) {\n        throw new Error('Could not resolve AST. Did you parse the query with gql?');\n    }\n    return result;\n}\n\nexport function wrapConfigAndVerify(\n    config: any,\n    options?: { acceptedOperations?: ('query' | 'mutation' | 'subscription')[] }\n): any {\n    if (config?.query) {\n        config = { ...config, query: resolveAst(config.query) };\n        if (config.query === undefined) {\n            throw new Error('Internal error in GraphQL adapter occurred: Unable to resolve query');\n        }\n        // Validate the resolved query for operation types, considering operationName\n        validateGraphQLOperations(config, {\n            acceptedOperations: options?.acceptedOperations ?? ['query'],\n        });\n    }\n    return config;\n}\n\nexport function formatGraphQLData(data: GraphQLResponse): GraphQLResponse {\n    // extensions should always be omitted\n    // errors should be omitted when there are no errors\n\n    if (data.errors === undefined || data.errors.length === 0) {\n        return {\n            data: data.data,\n            errors: undefined,\n        } satisfies GraphQLResponse;\n    }\n\n    return {\n        data: data.data,\n        errors: data.errors,\n    } satisfies GraphQLResponse;\n}\n\n/**\n * Maps a command failure (unknown or user-visible) into a GraphQLResponse suitable for consumers.\n */\nexport function toGraphQLResponseFromFailure(failure: unknown): {\n    data: GraphQLResponse['data'];\n    errors: GraphQLResponse['errors'];\n} {\n    if (isUserVisibleError<GraphQLResponse>(failure)) {\n        return {\n            data: failure.data.data,\n            errors: failure.data.errors,\n        };\n    }\n    logError(failure);\n    return {\n        data: undefined,\n        errors: [{ message: 'Internal error in GraphQL adapter occurred', locations: [] }],\n    };\n}\n","import { WireConfigValue, WireContextValue } from '@conduit-client/lwc-types';\nimport { CommandWireAdapterConstructor } from './CommandWireAdapterConstructor';\nimport {\n    Result,\n    SubscribableResult,\n    deepFreeze,\n    err,\n    isSubscribableResult,\n} from '@conduit-client/utils';\nimport {\n    type GraphQLCommandError,\n    type GraphQLResponse,\n} from '@conduit-client/graphql-normalization/v1';\nimport {\n    GraphQLCommand,\n    resolveAst,\n    validateGraphQLOperations,\n    toGraphQLResponseFromFailure,\n} from './graphql-utils';\nimport sanitize from './sanitize';\nimport { logError } from './utils';\n\nexport abstract class GraphQLCommandWireAdapterConstructor<\n    Config extends WireConfigValue = WireConfigValue,\n> extends CommandWireAdapterConstructor<GraphQLResponse, Config, GraphQLCommand> {\n    protected emit(\n        result?:\n            | SubscribableResult<GraphQLResponse, GraphQLCommandError>\n            | Result<GraphQLResponse, GraphQLCommandError>\n            | undefined\n    ): void {\n        try {\n            if (result === undefined) {\n                this.callback({ data: undefined, errors: undefined });\n            } else {\n                const consumerEmittedRefresh = (): Promise<void> => {\n                    if (!this.refresh) {\n                        return Promise.resolve();\n                    }\n                    return new Promise((resolve, reject) => {\n                        if (!this.refresh) {\n                            resolve();\n                            return;\n                        }\n                        this.refresh().then((res) => {\n                            if (res.isOk()) {\n                                resolve();\n                            } else {\n                                reject(\n                                    new Error(\n                                        'Internal error in GraphQL adapter occurred: Failed to refresh GraphQL data'\n                                    )\n                                );\n                            }\n                        });\n                    });\n                };\n\n                let consumerEmittedData = {\n                    data: undefined,\n                    errors: undefined,\n                } as {\n                    data: GraphQLResponse | undefined;\n                    errors: unknown | undefined;\n                    refresh?: () => Promise<void>;\n                };\n\n                if (this.exposeRefresh && this.refresh) {\n                    consumerEmittedData.refresh = consumerEmittedRefresh;\n                }\n\n                if (result.isErr()) {\n                    const failure = isSubscribableResult(result)\n                        ? result.error.failure\n                        : result.error;\n                    const resp = toGraphQLResponseFromFailure(failure);\n                    consumerEmittedData.data = resp.data;\n                    consumerEmittedData.errors = resp.errors;\n                } else {\n                    consumerEmittedData.data = result.value.data;\n                }\n\n                deepFreeze(consumerEmittedData);\n                this.callback(consumerEmittedData);\n            }\n        } catch (e) {\n            logError(e);\n            this.handleExecutionThrow(e);\n        }\n    }\n\n    protected handleExecutionThrow(e: unknown): void {\n        logError(e);\n        this.callback({\n            data: undefined,\n            errors: [{ message: 'Internal error in GraphQL adapter occurred', locations: [] }],\n        } satisfies GraphQLResponse);\n    }\n\n    update(config: Config, _context?: WireContextValue): void {\n        this.unsubscribe();\n\n        const resolvedQuery = resolveAst(config.query);\n        if (resolvedQuery) {\n            // Validate the resolved query for operation types, considering operationName\n            validateGraphQLOperations(\n                { query: resolvedQuery, operationName: (config as any)?.operationName },\n                { acceptedOperations: ['query'] }\n            );\n        }\n\n        this.config = {\n            ...sanitize<Config>(config),\n            query: resolvedQuery,\n        };\n        this.invokeAdapter();\n    }\n}\n","import { Callback, deepFreeze } from '@conduit-client/utils';\nimport { JSONSchema, assertIsValid } from '@conduit-client/jsonschema-validate';\nimport { type GraphQLResponse } from '@conduit-client/graphql-normalization/v1';\nimport { GraphQLCommand, wrapConfigAndVerify, toGraphQLResponseFromFailure } from './graphql-utils';\nimport { isUserVisibleError, logError } from './utils';\n\nexport type SubscribableRefreshableGraphQLImperativeResult = Promise<\n    GraphQLResponse & {\n        subscribe?: (cb: Callback<any>) => void;\n        refresh?: () => PromiseLike<void>;\n    }\n>;\n\nexport function buildAsyncGraphQLImperativeInvoker<Params extends Array<any>>(\n    getCommand: (options: {\n        params: Params;\n        assertIsValid: <T>(data: unknown, schema: JSONSchema) => asserts data is T;\n    }) => GraphQLCommand,\n    exposeRefresh = false\n): (...params: Params) => SubscribableRefreshableGraphQLImperativeResult {\n    return async (...params: Params) => {\n        try {\n            if (params.length) {\n                params[0] = wrapConfigAndVerify(params[0]);\n            }\n            const command = getCommand({ params, assertIsValid });\n            const result = await command.execute();\n\n            const consumerEmittedData = {\n                data: undefined,\n                errors: undefined,\n            } as {\n                data: GraphQLResponse | undefined;\n                errors: any | undefined;\n                subscribe: (cb: Callback<any>) => void;\n                refresh: () => PromiseLike<void>;\n            };\n\n            if (result.isOk()) {\n                deepFreeze(result.value);\n                consumerEmittedData.data = result.value.data.data;\n                consumerEmittedData.subscribe = (cb: Callback<any>) => {\n                    result.value.subscribe((res) => {\n                        const consumerEmittedData = {\n                            data: undefined,\n                            errors: undefined,\n                        } as {\n                            data: GraphQLResponse | undefined;\n                            errors: any | undefined;\n                        };\n                        if (res.isOk()) {\n                            consumerEmittedData.data = res.value.data;\n                        } else {\n                            if (isUserVisibleError<GraphQLResponse>(res.error)) {\n                                consumerEmittedData.data = res.error.data.data;\n                                consumerEmittedData.errors = res.error.data.errors;\n                            } else {\n                                logError(res.error);\n                                consumerEmittedData.errors = [\n                                    {\n                                        message: 'Internal error in GraphQL adapter occurred',\n                                        locations: [],\n                                    },\n                                ];\n                            }\n                        }\n                        cb(consumerEmittedData);\n                    });\n                };\n                if (exposeRefresh) {\n                    consumerEmittedData.refresh = () => {\n                        return new Promise((resolve, reject) => {\n                            try {\n                                result.value.refresh().then((res) => {\n                                    if (res.isOk()) {\n                                        resolve();\n                                    } else {\n                                        reject(\n                                            new Error(\n                                                'Internal error in GraphQL adapter occurred: Failed to refresh GraphQL data'\n                                            )\n                                        );\n                                    }\n                                });\n                            } catch (error) {\n                                logError(error);\n                                reject(\n                                    new Error(\n                                        'Internal error in GraphQL adapter occurred: Failed to refresh GraphQL data'\n                                    )\n                                );\n                            }\n                        });\n                    };\n                }\n            } else {\n                const resp = toGraphQLResponseFromFailure(result.error.failure);\n                consumerEmittedData.data = resp.data;\n                consumerEmittedData.errors = resp.errors;\n            }\n\n            return consumerEmittedData;\n        } catch (error) {\n            logError(error);\n            return {\n                data: undefined,\n                errors: [{ message: 'Internal error in GraphQL adapter occurred', locations: [] }],\n            };\n        }\n    };\n}\n","import { deepFreeze } from '@conduit-client/utils';\nimport { JSONSchema, assertIsValid } from '@conduit-client/jsonschema-validate';\nimport { type GraphQLResponse } from '@conduit-client/graphql-normalization/v1';\nimport { GraphQLCommand, wrapConfigAndVerify, toGraphQLResponseFromFailure } from './graphql-utils';\nimport { logError, type LegacyExecuteOverrides } from './utils';\nimport type { Command } from '@conduit-client/command-base/v1';\n\nexport type GraphQLMutationResult = Promise<GraphQLResponse>;\n\nexport function buildAsyncGraphQLMutationInvoker<Params extends Array<any>>(\n    getCommand: (options: {\n        params: Params;\n        assertIsValid: <T>(data: unknown, schema: JSONSchema) => asserts data is T;\n    }) => Command<ReturnType<GraphQLCommand['execute']>, [LegacyExecuteOverrides?]>\n): (...params: Params) => GraphQLMutationResult {\n    return async (...params: Params) => {\n        try {\n            if (params.length) {\n                params[0] = wrapConfigAndVerify(params[0], { acceptedOperations: ['mutation'] });\n            }\n            const command = getCommand({ params, assertIsValid });\n            const result = await command.execute({ cacheControlConfig: { type: 'no-cache' } });\n\n            if (result.isOk()) {\n                deepFreeze(result.value);\n                return result.value.data;\n            } else {\n                return toGraphQLResponseFromFailure(result.error.failure);\n            }\n        } catch (error) {\n            logError(error);\n            return {\n                data: undefined,\n                errors: [{ message: 'Internal error in GraphQL adapter occurred', locations: [] }],\n            } satisfies GraphQLResponse;\n        }\n    };\n}\n","import { deepFreeze, Result, Unsubscribe } from '@conduit-client/utils';\nimport { JSONSchema, assertIsValid } from '@conduit-client/jsonschema-validate';\nimport {\n    GraphQLCommandError,\n    type GraphQLResponse,\n} from '@conduit-client/graphql-normalization/v1';\nimport { GraphQLCommand, wrapConfigAndVerify, toGraphQLResponseFromFailure } from './graphql-utils';\nimport type { Command } from '@conduit-client/command-base/v1';\nimport { isUserVisibleError, logError, getOverridesForLegacyRequestContext } from './utils';\nimport type { LegacyExecuteOverrides } from './utils';\n\ntype LegacyGraphQLImperativeAdapterInvokeType<Config> = (\n    config: Config,\n    context: unknown,\n    callback: (result: GraphQLResponse) => void\n) => void;\n\ntype LegacyGraphQLImperativeAdapterSubscribeType<Config> = (\n    config: Config,\n    context: unknown,\n    callback: (result: GraphQLResponse) => void\n) => Unsubscribe;\n\nexport type LegacyGraphQLImperativeShape<Config> = {\n    invoke: LegacyGraphQLImperativeAdapterInvokeType<Config>;\n    subscribe: LegacyGraphQLImperativeAdapterSubscribeType<Config>;\n};\n\nexport function buildAsyncGraphQLImperativeLegacyInvoker<Config>(\n    getCommand: (options: {\n        config: Config;\n        assertIsValid: <T>(data: unknown, schema: JSONSchema) => asserts data is T;\n    }) => Command<ReturnType<GraphQLCommand['execute']>, [LegacyExecuteOverrides?]>\n): LegacyGraphQLImperativeShape<Config> {\n    const invoke: LegacyGraphQLImperativeAdapterInvokeType<Config> = async (\n        config: Config,\n        requestContext: unknown,\n        callback: (result: GraphQLResponse) => void\n    ) => {\n        config = wrapConfigAndVerify(config);\n        const command = getCommand({ config, assertIsValid });\n\n        try {\n            const overrides = getOverridesForLegacyRequestContext(requestContext);\n            const result: Awaited<ReturnType<typeof command.execute>> =\n                await command.execute(overrides);\n\n            const consumerEmittedData = {\n                data: undefined,\n                errors: undefined,\n            } as {\n                data: GraphQLResponse | undefined;\n                errors: any | undefined;\n            };\n\n            if (result.isOk()) {\n                deepFreeze(result.value);\n                consumerEmittedData.data = result.value.data.data;\n            } else {\n                const { data, errors } = toGraphQLResponseFromFailure(result.error.failure);\n                consumerEmittedData.data = data;\n                consumerEmittedData.errors = errors;\n            }\n\n            callback(consumerEmittedData);\n        } catch (error) {\n            logError(error);\n            callback({\n                data: undefined,\n                errors: [{ message: 'Internal error in GraphQL adapter occurred', locations: [] }],\n            } satisfies GraphQLResponse);\n        }\n    };\n\n    const subscribe: LegacyGraphQLImperativeAdapterSubscribeType<Config> = (\n        config: Config,\n        requestContext: unknown,\n        callback: (result: GraphQLResponse) => void\n    ) => {\n        config = wrapConfigAndVerify(config);\n        const command = getCommand({ config, assertIsValid });\n\n        let unsubscribe: Unsubscribe = () => {};\n\n        const overrides = getOverridesForLegacyRequestContext(requestContext);\n        command.execute(overrides).then((result: Awaited<ReturnType<typeof command.execute>>) => {\n            const consumerEmittedData = {\n                data: undefined,\n                errors: undefined,\n            } as {\n                data: GraphQLResponse | undefined;\n                errors: any | undefined;\n            };\n\n            if (result.isOk()) {\n                deepFreeze(result.value);\n                consumerEmittedData.data = result.value.data.data;\n                unsubscribe = result.value.subscribe(\n                    (res: Result<GraphQLResponse<Record<string, any>>, GraphQLCommandError>) => {\n                        handleEmit(res, callback);\n                    }\n                );\n            } else {\n                const { data, errors } = toGraphQLResponseFromFailure(result.error.failure);\n                consumerEmittedData.data = data;\n                consumerEmittedData.errors = errors;\n                unsubscribe = result.error.subscribe(\n                    (res: Result<GraphQLResponse<Record<string, any>>, GraphQLCommandError>) => {\n                        handleEmit(res, callback);\n                    }\n                );\n            }\n\n            callback(consumerEmittedData);\n        });\n\n        return () => {\n            unsubscribe();\n        };\n    };\n\n    return { invoke, subscribe };\n}\n\nfunction handleEmit(\n    res: Result<GraphQLResponse<Record<string, any>>, GraphQLCommandError>,\n    callback: (result: GraphQLResponse) => void\n) {\n    const consumerEmittedData = {\n        data: undefined,\n        errors: undefined,\n    } as {\n        data: GraphQLResponse | undefined;\n        errors: any | undefined;\n    };\n    if (res.isOk()) {\n        consumerEmittedData.data = res.value.data;\n    } else {\n        const { data, errors } = toGraphQLResponseFromFailure(res.error);\n        consumerEmittedData.data = data;\n        consumerEmittedData.errors = errors;\n    }\n    callback(consumerEmittedData);\n}\n"],"names":["err","result","consumerEmittedData"],"mappings":"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"}

package/dist/types/CommandWireAdapterConstructor.d.ts

@@ -0,0 +1,36 @@
+import { type Command } from '@conduit-client/command-base/v1';
+import { type Result } from '@conduit-client/utils';
+import { type WireAdapter, type WireConfigValue, type WireContextValue, type WireDataCallback } from '@conduit-client/lwc-types';
+import { type JSONSchema } from '@conduit-client/jsonschema-validate';
+import type { SyncOrAsync, Unsubscribe, SubscribableResult, CommandError } from '@conduit-client/utils';
+type MaybeSubscribableResultCommand<Data, Error> = Command<SyncOrAsync<Result<Data, Error> | SubscribableResult<Data, Error>>>;
+export type SubscribableResultCommand<Data, Error> = Command<SyncOrAsync<SubscribableResult<Data, Error>>>;
+export type ResultCommand<Data, Error> = Command<SyncOrAsync<Result<Data, Error>>>;
+export type WireAdapterCompatibleCommand<Data, Error> = SubscribableResultCommand<Data, Error> | ResultCommand<Data, Error> | MaybeSubscribableResultCommand<Data, Error>;
+/**
+ * Binds a Command to a LWC wire adapter.
+ * @see https://lwc.dev/guide/wire_adapter
+ */
+export declare abstract class CommandWireAdapterConstructor<Data, Config extends WireConfigValue = WireConfigValue, CommandType extends WireAdapterCompatibleCommand<Data, CommandError> = WireAdapterCompatibleCommand<Data, CommandError>> implements WireAdapter {
+    protected callback: WireDataCallback;
+    connected: boolean;
+    config?: Config;
+    unsubscriber?: Unsubscribe;
+    exposeRefresh: boolean;
+    abstract configSchema?: JSONSchema;
+    abstract getCommand(): CommandType;
+    protected refresh?: () => SyncOrAsync<Result<void, unknown>>;
+    constructor(callback: WireDataCallback, sourceContext?: {
+        tagName?: string;
+    }, options?: {
+        skipEmptyEmit?: true;
+    });
+    connect(): void;
+    disconnect(): void;
+    update(config: Config, _context?: WireContextValue): void;
+    protected emit(result?: Result<Data, unknown> | SubscribableResult<Data, unknown>): void;
+    protected invokeAdapter(): void;
+    protected handleExecutionThrow(error: unknown): void;
+    protected unsubscribe(): void;
+}
+export {};

package/dist/types/__tests__/CommandWireAdapterConstructor.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/__tests__/graphql-mutation.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/__tests__/graphql-operation-rejection.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/__tests__/graphql-wire.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/__tests__/graphql.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/__tests__/imperative.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/__tests__/sanitize.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/__tests__/utils.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/graphql-imperative-legacy.d.ts

@@ -0,0 +1,17 @@
+import { Unsubscribe } from '@conduit-client/utils';
+import { JSONSchema } from '@conduit-client/jsonschema-validate';
+import { type GraphQLResponse } from '@conduit-client/graphql-normalization/v1';
+import { GraphQLCommand } from './graphql-utils';
+import type { Command } from '@conduit-client/command-base/v1';
+import type { LegacyExecuteOverrides } from './utils';
+type LegacyGraphQLImperativeAdapterInvokeType<Config> = (config: Config, context: unknown, callback: (result: GraphQLResponse) => void) => void;
+type LegacyGraphQLImperativeAdapterSubscribeType<Config> = (config: Config, context: unknown, callback: (result: GraphQLResponse) => void) => Unsubscribe;
+export type LegacyGraphQLImperativeShape<Config> = {
+    invoke: LegacyGraphQLImperativeAdapterInvokeType<Config>;
+    subscribe: LegacyGraphQLImperativeAdapterSubscribeType<Config>;
+};
+export declare function buildAsyncGraphQLImperativeLegacyInvoker<Config>(getCommand: (options: {
+    config: Config;
+    assertIsValid: <T>(data: unknown, schema: JSONSchema) => asserts data is T;
+}) => Command<ReturnType<GraphQLCommand['execute']>, [LegacyExecuteOverrides?]>): LegacyGraphQLImperativeShape<Config>;
+export {};

package/dist/types/graphql-imperative.d.ts

@@ -0,0 +1,12 @@
+import { Callback } from '@conduit-client/utils';
+import { JSONSchema } from '@conduit-client/jsonschema-validate';
+import { type GraphQLResponse } from '@conduit-client/graphql-normalization/v1';
+import { GraphQLCommand } from './graphql-utils';
+export type SubscribableRefreshableGraphQLImperativeResult = Promise<GraphQLResponse & {
+    subscribe?: (cb: Callback<any>) => void;
+    refresh?: () => PromiseLike<void>;
+}>;
+export declare function buildAsyncGraphQLImperativeInvoker<Params extends Array<any>>(getCommand: (options: {
+    params: Params;
+    assertIsValid: <T>(data: unknown, schema: JSONSchema) => asserts data is T;
+}) => GraphQLCommand, exposeRefresh?: boolean): (...params: Params) => SubscribableRefreshableGraphQLImperativeResult;

package/dist/types/graphql-mutation.d.ts

@@ -0,0 +1,10 @@
+import { JSONSchema } from '@conduit-client/jsonschema-validate';
+import { type GraphQLResponse } from '@conduit-client/graphql-normalization/v1';
+import { GraphQLCommand } from './graphql-utils';
+import { type LegacyExecuteOverrides } from './utils';
+import type { Command } from '@conduit-client/command-base/v1';
+export type GraphQLMutationResult = Promise<GraphQLResponse>;
+export declare function buildAsyncGraphQLMutationInvoker<Params extends Array<any>>(getCommand: (options: {
+    params: Params;
+    assertIsValid: <T>(data: unknown, schema: JSONSchema) => asserts data is T;
+}) => Command<ReturnType<GraphQLCommand['execute']>, [LegacyExecuteOverrides?]>): (...params: Params) => GraphQLMutationResult;

package/dist/types/graphql-utils.d.ts

@@ -0,0 +1,34 @@
+import { SubscribableResultCommand } from './CommandWireAdapterConstructor';
+import { IErrorWithData } from '@conduit-client/utils';
+import { type GraphQLCommandError, type GraphQLResponse } from '@conduit-client/graphql-normalization/v1';
+import { DocumentNode } from '@conduit-client/onestore-graphql-parser/v1';
+export type GraphQLCommand = SubscribableResultCommand<GraphQLResponse, GraphQLCommandError>;
+export declare class GraphQLCommandErrorWithData extends Error implements IErrorWithData<GraphQLResponse> {
+    data: GraphQLResponse;
+    constructor(data: GraphQLResponse);
+}
+export declare function throwGraphQLError(error: unknown): never;
+/**
+ * Validates a GraphQL config and rejects operations not in the accepted list
+ * @param config The GraphQL config containing query and operationName
+ * @param options Options containing acceptedOperations array
+ * @throws Error if the executable operation is not in acceptedOperations
+ */
+export declare function validateGraphQLOperations(config: {
+    query: DocumentNode;
+    operationName?: string;
+}, options: {
+    acceptedOperations: ('query' | 'mutation' | 'subscription')[];
+}): void;
+export declare function resolveAst(ast: any): DocumentNode | undefined;
+export declare function wrapConfigAndVerify(config: any, options?: {
+    acceptedOperations?: ('query' | 'mutation' | 'subscription')[];
+}): any;
+export declare function formatGraphQLData(data: GraphQLResponse): GraphQLResponse;
+/**
+ * Maps a command failure (unknown or user-visible) into a GraphQLResponse suitable for consumers.
+ */
+export declare function toGraphQLResponseFromFailure(failure: unknown): {
+    data: GraphQLResponse['data'];
+    errors: GraphQLResponse['errors'];
+};

package/dist/types/graphql-wire.d.ts

@@ -0,0 +1,10 @@
+import { WireConfigValue, WireContextValue } from '@conduit-client/lwc-types';
+import { CommandWireAdapterConstructor } from './CommandWireAdapterConstructor';
+import { Result, SubscribableResult } from '@conduit-client/utils';
+import { type GraphQLCommandError, type GraphQLResponse } from '@conduit-client/graphql-normalization/v1';
+import { GraphQLCommand } from './graphql-utils';
+export declare abstract class GraphQLCommandWireAdapterConstructor<Config extends WireConfigValue = WireConfigValue> extends CommandWireAdapterConstructor<GraphQLResponse, Config, GraphQLCommand> {
+    protected emit(result?: SubscribableResult<GraphQLResponse, GraphQLCommandError> | Result<GraphQLResponse, GraphQLCommandError> | undefined): void;
+    protected handleExecutionThrow(e: unknown): void;
+    update(config: Config, _context?: WireContextValue): void;
+}

package/dist/types/imperative.d.ts

@@ -0,0 +1,90 @@
+import { type JSONSchema } from '@conduit-client/jsonschema-validate';
+import { type Command } from '@conduit-client/command-base/v1';
+import type { SyncOrAsync, Result, SubscribableResult, Unsubscribe, Callback } from '@conduit-client/utils';
+import type { LegacyExecuteOverrides } from './utils';
+type MaybeSubscribableResultCommand<Data> = Command<SyncOrAsync<Result<Data, unknown> | SubscribableResult<Data, unknown>>>;
+type SubscribableResultCommand<Data, Params extends Array<any> = []> = Command<SyncOrAsync<SubscribableResult<Data, unknown>>, Params>;
+type ResultCommand<Data> = Command<SyncOrAsync<Result<Data, unknown>>>;
+type ImperativeCommand<Data> = SubscribableResultCommand<Data> | ResultCommand<Data> | MaybeSubscribableResultCommand<Data>;
+/**
+ * Returns an async function wrapper around an `ImperativeCommand`.  Handles
+ * both subscribable and non-subscribable commands, but only returns regular data.
+ *
+ * @typeParam Params parameters accepted by the generated function
+ * @typeParam Config Command config type
+ * @typeParam Data data returned by the Command
+ * @param getCommand utility function that constructs an instance of the Command from
+ *     the supplied parameters; the function should do any necessary parameter checking
+ *     and throw errors as appropriate
+ * @returns A PromiseLike containing the result of command execution
+ */
+export declare function buildAsyncImperativeInvoker<Params extends Array<any>, Data>(getCommand: (options: {
+    params: Params;
+    assertIsValid: <T>(data: unknown, schema: JSONSchema) => asserts data is T;
+}) => ImperativeCommand<Data>): (...params: Params) => DefaultImperativeResult<Data>;
+/**
+ * Returns an async function wrapper around a query `Command`.  Handles
+ * both subscribable and non-subscribable commands, but only returns regular data.
+ *
+ * @typeParam Params parameters accepted by the generated function
+ * @typeParam Config Command config type
+ * @typeParam Data data returned by the Command
+ * @param getCommand utility function that constructs an instance of the Command from
+ *     the supplied parameters; the function should do any necessary parameter checking
+ *     and throw errors as appropriate
+ * @returns A PromiseLike containing the result of command execution
+ */
+export declare function buildAsyncQueryImperativeInvoker<Params extends Array<any>, Data>(getCommand: (options: {
+    params: Params;
+    assertIsValid: <T>(data: unknown, schema: JSONSchema) => asserts data is T;
+}) => ImperativeCommand<Data>): (...params: Params) => QueryImperativeResult<Data>;
+export type DefaultImperativeResult<Data> = PromiseLike<Data>;
+export type QueryImperativeResult<Data> = PromiseLike<{
+    data: Data;
+}>;
+export type SubscribableImperativeResult<Data> = PromiseLike<{
+    data: Data;
+    subscribe: (cb: Callback<any>) => void;
+}>;
+export type SubscribableRefreshableImperativeResult<Data> = PromiseLike<{
+    data: Data;
+    subscribe: (cb: Callback<any>) => void;
+    refresh: () => PromiseLike<void>;
+}>;
+export type MaybeRefreshableSubscribableImperativeResult<Data> = SubscribableImperativeResult<Data> | SubscribableRefreshableImperativeResult<Data>;
+/**
+ * Returns an async function wrapper around an `ImperativeCommand`.  Handles
+ * only subscribable commands and returns a subscribable result.
+ *
+ * @typeParam Params parameters accepted by the generated function
+ * @typeParam Config Command config type
+ * @typeParam Data data returned by the Command
+ * @param getCommand utility function that constructs an instance of the Command from
+ *     the supplied parameters; the function should do any necessary parameter checking
+ *     and throw errors as appropriate
+ * @param exposeRefresh whether to expose a `refresh` method on the result returned by
+ *     the generated function.  The default is `false`.
+ * @returns A PromiseLike containing the subscribable result of command execution
+ */
+export declare function buildAsyncImperativeSubscribableInvoker<Params extends Array<any>, Data>(getCommand: (options: {
+    params: Params;
+    assertIsValid: <T>(data: unknown, schema: JSONSchema) => asserts data is T;
+}) => ImperativeCommand<Data>, exposeRefresh?: boolean): (...params: Params) => MaybeRefreshableSubscribableImperativeResult<Data>;
+type LegacyImperativeCallbackResult<Data> = {
+    data: Data;
+    error: undefined;
+} | {
+    data: undefined;
+    error: Error;
+};
+type LegacyImperativeAdapterInvokeType<Config, Data> = (config: Config, context: unknown, callback: (result: LegacyImperativeCallbackResult<Data>) => void) => void;
+type LegacyImperativeAdapterSubscribeType<Config, Data> = (config: Config, context: unknown, callback: (result: LegacyImperativeCallbackResult<Data>) => void) => Unsubscribe;
+export type LegacyImperativeShape<Config, Data> = {
+    invoke: LegacyImperativeAdapterInvokeType<Config, Data>;
+    subscribe: LegacyImperativeAdapterSubscribeType<Config, Data>;
+};
+export declare function buildAsyncImperativeLegacyInvoker<Config, Data>(getCommand: (options: {
+    config: Config;
+    assertIsValid: <T>(data: unknown, schema: JSONSchema) => asserts data is T;
+}) => SubscribableResultCommand<Data, [LegacyExecuteOverrides?]>): LegacyImperativeShape<Config, Data>;
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1,8 @@
+export * from './CommandWireAdapterConstructor';
+export * from './imperative';
+export type { WireAdapterConstructor } from '@conduit-client/lwc-types';
+export { GraphQLCommandWireAdapterConstructor } from './graphql-wire';
+export { buildAsyncGraphQLImperativeInvoker, type SubscribableRefreshableGraphQLImperativeResult, } from './graphql-imperative';
+export { buildAsyncGraphQLMutationInvoker, type GraphQLMutationResult } from './graphql-mutation';
+export { buildAsyncGraphQLImperativeLegacyInvoker, type LegacyGraphQLImperativeShape, } from './graphql-imperative-legacy';
+export { type GraphQLCommand, GraphQLCommandErrorWithData, throwGraphQLError, resolveAst, } from './graphql-utils';

package/dist/types/sanitize.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Returns a sanitized version of an object by recursively unwrapping the Proxies.
+ *
+ * All the data coming from LWC-land need to be sanitized first.
+ */
+export default function sanitize<T extends object>(obj: T): T;

package/dist/types/utils.d.ts

@@ -0,0 +1,43 @@
+import type { Callback, IInternalError, IUserVisibleError } from '@conduit-client/utils';
+export declare function isInternalError<Data = undefined>(error: unknown): error is IInternalError<Data>;
+export declare function isUserVisibleError<Data = undefined>(error: unknown): error is IUserVisibleError<Data>;
+export declare function throwUserlandError(error: unknown): never;
+export declare function emitError(callback: Callback<any>, error: unknown): void;
+export declare function buildUserlandError(error: unknown): Error;
+export declare function logError(error: unknown): void;
+export declare const supportedCachePolicyTypes: readonly ["no-cache", "only-if-cached"];
+export type SupportedCachePolicyType = (typeof supportedCachePolicyTypes)[number];
+export type CachePolicy = {
+    cachePolicy: {
+        type: SupportedCachePolicyType;
+    };
+};
+/**
+ * Type guard for legacy requestContext objects used with imperative-legacy bindings.
+ *
+ * When this function returns true, it indicates the caller requested a supported
+ * cache policy override. Currently the only supported policy is `no-cache`.
+ *
+ * This helper is intentionally low-level; prefer using
+ * {@link getOverridesForLegacyRequestContext} at call sites to construct the
+ * proper `execute` overrides for Commands.
+ */
+export declare function requestContextIsSupportedCachePolicy(requestContext: unknown): requestContext is CachePolicy;
+export type LegacyExecuteOverrides = {
+    cacheControlConfig?: {
+        type: SupportedCachePolicyType;
+    };
+};
+/**
+ * Builds the `execute` overrides for legacy imperative invokers based on the
+ * provided requestContext. Encapsulates all hard-coded knowledge of supported
+ * cache policies for legacy adapters.
+ *
+ * - If {@link requestContextIsSupportedCachePolicy} matches `no-cache`, returns
+ *   `{ cacheControlConfig: { type: 'no-cache' } }`.
+ * - Otherwise returns `{}`.
+ *
+ * Use this in `buildAsyncImperativeLegacyInvoker` and GraphQL legacy invokers
+ * to centralize override behavior.
+ */
+export declare function getOverridesForLegacyRequestContext(requestContext: unknown): LegacyExecuteOverrides;

package/package.json

@@ -0,0 +1,47 @@
+{
+    "name": "@conduit-client/lwc-bindings",
+    "version": "5.67.0-dev1",
+    "private": false,
+    "description": "Luvio LWC Bindings",
+    "type": "module",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/salesforce-experience-platform-emu/luvio-next.git",
+        "directory": "packages/@conduit-client/lwc-bindings"
+    },
+    "license": "SEE LICENSE IN LICENSE.txt",
+    "main": "dist/index.js",
+    "types": "dist/types/index.d.ts",
+    "files": [
+        "dist/"
+    ],
+    "scripts": {
+        "build": "vite build && tsc --build --emitDeclarationOnly",
+        "clean": "rm -rf dist",
+        "test": "vitest run",
+        "test:size": "size-limit",
+        "watch": "npm run build --watch"
+    },
+    "dependencies": {
+        "@conduit-client/command-base": "5.67.0-dev1",
+        "@conduit-client/jsonschema-validate": "5.67.0-dev1",
+        "@conduit-client/lwc-types": "5.67.0-dev1",
+        "@conduit-client/service-cache-control": "5.67.0-dev1",
+        "@conduit-client/utils": "5.67.0-dev1"
+    },
+    "devDependencies": {
+        "@conduit-client/command-cache-control": "5.67.0-dev1",
+        "@conduit-client/graphql-normalization": "5.67.0-dev1",
+        "@conduit-client/service-cache": "5.67.0-dev1",
+        "@conduit-client/service-pubsub": "5.67.0-dev1"
+    },
+    "volta": {
+        "extends": "../../../package.json"
+    },
+    "size-limit": [
+        {
+            "path": "./dist/index.js",
+            "limit": "4 kB"
+        }
+    ]
+}