@conduit-client/service-bindings-imperative 2.1.0

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,350 @@
+# @conduit-client/service-bindings-imperative
+
+Conduit services for imperative bindings, providing flexible data invocation strategies and patterns.
+
+## Overview
+
+This package provides imperative data fetching and mutation services for the Conduit ecosystem. It offers multiple invoker strategies to handle different data fetching patterns including GraphQL, legacy systems, and subscribable data streams. It then wraps these in services to be used as needed within an environment.
+
+## Key Features
+
+- **Multiple Invoker Strategies**: Support for various data fetching patterns
+- **GraphQL Support**: Full GraphQL query and mutation support
+- **Legacy System Integration**: Backward compatibility with legacy APIs
+- **Subscribable Data**: Real-time data subscriptions and updates
+- **Flexible Architecture**: Pluggable invoker system for custom implementations
+
+## Service Types
+
+### Available Services
+
+#### `DefaultImperativeBindingsService`
+
+Standard invoker for general-purpose data fetching.
+
+- Handles standard REST API calls
+- Provides error handling and retry logic
+- Can be used for subscribable and non-subscribable results
+
+#### `QueryImperativeBindingsService`
+
+Specialized invoker for query operations.
+
+- Supports all properties of the default invoker
+
+#### `GraphQLImperativeBindingsService`
+
+GraphQL-specific invoker for modern GraphQL APIs.
+
+- Executes GraphQL queries
+- Handles GraphQL errors
+- Supports variables and fragments
+
+#### `GraphQLMutationBindingsService`
+
+Dedicated invoker for GraphQL mutations.
+
+- Executes GraphQL mutations
+- Handles optimistic updates
+- Manages mutation side effects
+
+#### `GraphQLLegacyImperativeBindingsService`
+
+Bridge invoker for legacy GraphQL implementations.
+
+- Backward compatibility with older GraphQL systems
+- Handles legacy response formats
+
+#### `LegacyImperativeBindingsService`
+
+Compatibility invoker for legacy systems.
+
+- Supports older REST APIs
+
+#### `SubscribableImperativeBindingsService`
+
+Real-time data subscription invoker.
+
+- Specific to subscribable results
+
+## Usage Examples
+
+### Basic Data Fetching
+
+```typescript
+import { buildDefaultImperativeBindingsServiceDescriptor } from '@conduit-client/services/bindings-imperative/v1';
+
+// Build the service
+const { service: defaultImperativeBindingsService } =
+  buildDefaultImperativeBindingsServiceDescriptor();
+
+// Create a command that returns data
+const getCommand = () => ({
+  execute: () =>
+    Promise.resolve({
+      isOk: () => true,
+      value: {
+        data: { foo: 'bar' },
+        subscribe: (callback) => {
+          // Optional subscription logic
+          return () => {}; // Return unsubscribe function
+        },
+      },
+    }),
+});
+
+// Bind the command to the service
+const invoker = defaultImperativeBindingsService.bind(getCommand);
+
+// Execute and get the result
+const result = await invoker({ required: 'param' });
+console.log(result); // { foo: 'bar' }
+```
+
+### GraphQL Query
+
+```typescript
+import { buildGraphQLImperativeBindingsServiceDescriptor } from '@conduit-client/services/bindings-imperative/v1';
+
+// Build the service
+const { service: graphQLImperativeBindingsService } =
+  buildGraphQLImperativeBindingsServiceDescriptor();
+
+// Create a GraphQL command
+const getGraphQLCommand = () => ({
+  execute: () =>
+    Promise.resolve({
+      isOk: () => true,
+      value: {
+        data: {
+          data: { user: { id: '1', name: 'John' } },
+          errors: [],
+        },
+        subscribe: (callback) => {
+          // Handle GraphQL subscriptions
+          return () => {};
+        },
+        refresh: async () => {
+          // Optional refresh logic
+        },
+      },
+    }),
+});
+
+// Bind with refresh support
+const invoker = graphQLImperativeBindingsService.bind(getGraphQLCommand, true);
+
+// Execute GraphQL query
+const result = await invoker('query { user { id name } }', { id: '123' });
+console.log(result.data); // { user: { id: '1', name: 'John' } }
+console.log(result.errors); // undefined or array of errors
+console.log(result.subscribe); // Subscription function
+console.log(result.refresh); // Refresh function (if enabled)
+```
+
+### GraphQL Mutation
+
+```typescript
+import { buildGraphQLMutationBindingsServiceDescriptor } from '@conduit-client/services/bindings-imperative/v1';
+
+// Build the service
+const { service: graphQLMutationBindingsService } = buildGraphQLMutationBindingsServiceDescriptor();
+
+// Create a mutation command
+const getMutationCommand = () => ({
+  execute: (overrides) => {
+    // Note: Mutations automatically use no-cache
+    console.log(overrides.cacheControlConfig); // { type: 'no-cache' }
+    return Promise.resolve({
+      isOk: () => true,
+      value: {
+        data: {
+          data: { doThing: { id: '123' } },
+          errors: [],
+        },
+      },
+    });
+  },
+});
+
+// Bind the command
+const invoker = graphQLMutationBindingsService.bind(getMutationCommand);
+
+// Execute mutation
+const result = await invoker({
+  query: 'mutation DoThing { doThing { id } }',
+  variables: {
+    /* variables */
+  },
+});
+console.log(result); // { data: { doThing: { id: '123' } }, errors: [] }
+```
+
+### Subscribable Data
+
+```typescript
+import { buildSubscribableImperativeBindingsServiceDescriptor } from '@conduit-client/services/bindings-imperative/v1';
+
+// Build the service
+const { service: subscribableImperativeBindingsService } =
+  buildSubscribableImperativeBindingsServiceDescriptor();
+
+// Create a subscribable command
+const getSubscribableCommand = () => ({
+  execute: () =>
+    Promise.resolve({
+      isOk: () => true,
+      value: {
+        data: { foo: 'bar' },
+        subscribe: (callback) => {
+          // Set up subscription
+          const interval = setInterval(() => {
+            callback({
+              isOk: () => true,
+              value: { data: { foo: 'updated' } },
+            });
+          }, 1000);
+
+          // Return unsubscribe function
+          return () => clearInterval(interval);
+        },
+        refresh: async () => {
+          // Optional refresh logic
+          return { isOk: () => true, value: undefined };
+        },
+      },
+    }),
+});
+
+// Bind with refresh support
+const invoker = subscribableImperativeBindingsService.bind(getSubscribableCommand, true);
+
+// Get subscribable result
+const result = await invoker({ required: 'param' });
+console.log(result.data); // { foo: 'bar' }
+
+// Subscribe to updates
+const unsubscribe = result.subscribe((update) => {
+  console.log('Updated:', update);
+});
+
+// Refresh data
+if (result.refresh) {
+  await result.refresh();
+}
+
+// Later: unsubscribe
+unsubscribe();
+```
+
+### Legacy System Integration
+
+```typescript
+import { buildLegacyImperativeBindingsServiceDescriptor } from '@conduit-client/services/bindings-imperative/v1';
+
+// Build the service
+const { service: legacyImperativeBindingsService } =
+  buildLegacyImperativeBindingsServiceDescriptor();
+
+// Create a legacy command
+const getLegacyCommand = () => ({
+  execute: (overrides) => {
+    // Handle cache policy if provided
+    const cachePolicy = overrides?.cacheControlConfig;
+
+    return Promise.resolve({
+      isOk: () => true,
+      value: {
+        data: { foo: 'legacy data' },
+        subscribe: (callback) => {
+          // Legacy subscription pattern
+          return () => {};
+        },
+      },
+    });
+  },
+});
+
+// Bind the command
+const legacyAdapter = legacyImperativeBindingsService.bind(getLegacyCommand);
+
+// Use legacy invoke pattern
+legacyAdapter.invoke(
+  { test: 'param' },
+  { cachePolicy: { type: 'no-cache' } }, // Optional request context
+  (result) => {
+    console.log(result); // { data: { foo: 'legacy data' }, error: undefined }
+  }
+);
+
+// Use legacy subscribe pattern
+const unsubscribe = legacyAdapter.subscribe({ test: 'param' }, {}, (result) => {
+  console.log('Updated:', result);
+});
+
+// Later: unsubscribe
+unsubscribe();
+```
+
+### Query Service
+
+```typescript
+import { buildQueryImperativeBindingsServiceDescriptor } from '@conduit-client/services/bindings-imperative/v1';
+
+// Build the service
+const { service: queryImperativeBindingsService } = buildQueryImperativeBindingsServiceDescriptor();
+
+// Create a query command
+const getQueryCommand = () => ({
+  execute: () =>
+    Promise.resolve({
+      isOk: () => true,
+      value: { message: 'query result' },
+    }),
+});
+
+// Bind the command
+const invoker = queryImperativeBindingsService.bind(getQueryCommand);
+
+// Execute query
+const result = await invoker('queryParam', 42);
+console.log(result); // { data: { message: 'query result' } }
+```
+
+## API Reference
+
+### Service Descriptors
+
+Each service type is exported as a service descriptor builder function:
+
+- `buildDefaultImperativeBindingsServiceDescriptor()` - Returns default service descriptor
+- `buildQueryImperativeBindingsServiceDescriptor()` - Returns query service descriptor
+- `buildSubscribableImperativeBindingsServiceDescriptor()` - Returns subscribable service descriptor
+- `buildLegacyImperativeBindingsServiceDescriptor()` - Returns legacy service descriptor
+- `buildGraphQLImperativeBindingsServiceDescriptor()` - Returns GraphQL service descriptor
+- `buildGraphQLLegacyImperativeBindingsServiceDescriptor()` - Returns GraphQL legacy service descriptor
+- `buildGraphQLMutationBindingsServiceDescriptor()` - Returns GraphQL mutation service descriptor
+
+### Service Methods
+
+Each service provides a `bind` method:
+
+#### `bind<TParams extends unknown[]>(getCommand: CommandFactory, exposeRefresh?: boolean): Invoker`
+
+Binds a command factory to the service and returns an invoker function.
+
+- `getCommand`: A function that returns a command object with an `execute` method
+- `exposeRefresh`: Optional boolean to enable refresh functionality (for subscribable services)
+- Returns: An invoker function that accepts parameters and returns a promise
+
+### Command Interface
+
+Commands must implement the interface from `@conduit-client/command-base`
+
+## Dependencies
+
+- `@conduit-client/utils`: Core utility functions
+- `@conduit-client/bindings-utils`: Shared binding utilities
+- `@conduit-client/jsonschema-validate`: JSON schema validation
+- `@conduit-client/command-base`: Base command interfaces
+- `@conduit-client/onestore-graphql-parser`: GraphQL parsing utilities

package/dist/main/index.js

@@ -0,0 +1,6 @@
+/*!
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+//# sourceMappingURL=index.js.map

package/dist/main/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;"}

package/dist/types/v1/__tests__/default-invoker.spec.d.ts

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

package/dist/types/v1/__tests__/graphql-invoker.spec.d.ts

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

package/dist/types/v1/__tests__/graphql-legacy-invoker.spec.d.ts

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

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

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

package/dist/types/v1/__tests__/legacy-invoker.spec.d.ts

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

package/dist/types/v1/__tests__/query-invoker.spec.d.ts

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

package/dist/types/v1/__tests__/subscribable-invoker.spec.d.ts

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

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

@@ -0,0 +1,7 @@
+import { Command } from '@conduit-client/command-base/v1';
+import { SyncOrAsync, Result, SubscribableResult } from '@conduit-client/utils';
+export declare function buildCommand<Data>(data: Data): Command<SyncOrAsync<Result<Data, unknown>>>;
+export declare function buildFailingCommand(): Command<SyncOrAsync<SubscribableResult<any, Error>>>;
+export declare function buildSubscribableCommand<Data>(data: Data): Command<SyncOrAsync<SubscribableResult<Data, Error>>>;
+export declare function buildRefreshableCommand<Data>(data: Data): Command<SyncOrAsync<SubscribableResult<Data, Error>>>;
+export declare function buildErrorRefreshableCommand<Data>(data: Data): Command<SyncOrAsync<SubscribableResult<Data, Error>>>;

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

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

package/dist/types/v1/index.d.ts

@@ -0,0 +1,7 @@
+export { buildServiceDescriptor as buildDefaultImperativeBindingsServiceDescriptor } from './invokers/default-invoker';
+export { buildServiceDescriptor as buildQueryImperativeBindingsServiceDescriptor } from './invokers/query-invoker';
+export { buildServiceDescriptor as buildSubscribableImperativeBindingsServiceDescriptor } from './invokers/subscribable-invoker';
+export { buildServiceDescriptor as buildLegacyImperativeBindingsServiceDescriptor } from './invokers/legacy-invoker';
+export { buildServiceDescriptor as buildGraphQLImperativeBindingsServiceDescriptor } from './invokers/graphql-invoker';
+export { buildServiceDescriptor as buildGraphQLLegacyImperativeBindingsServiceDescriptor } from './invokers/graphql-legacy-invoker';
+export { buildServiceDescriptor as buildGraphQLMutationBindingsServiceDescriptor } from './invokers/graphql-mutation-invoker';

package/dist/types/v1/invokers/default-invoker.d.ts

@@ -0,0 +1,11 @@
+import { ImperativeCommand, GetCommand } from '../utils';
+export type DefaultImperativeResult<Data> = PromiseLike<Data>;
+export declare class DefaultImperativeBindingsService {
+    bind<Params extends Array<any>, Data>(getCommand: GetCommand<Params, ImperativeCommand<Data>>): (...params: Params) => DefaultImperativeResult<Data>;
+}
+export interface DefaultImperativeBindingsServiceDescriptor {
+    type: 'defaultImperativeBindings';
+    version: string;
+    service: DefaultImperativeBindingsService;
+}
+export declare function buildServiceDescriptor(): DefaultImperativeBindingsServiceDescriptor;

package/dist/types/v1/invokers/graphql-invoker.d.ts

@@ -0,0 +1,17 @@
+import { type Callback, type SubscribableResult } from '@conduit-client/utils';
+import { type GraphQLCommandError, type GraphQLResponse, type GraphQLCommand } from '@conduit-client/graphql-normalization/v1';
+import { GetCommand } from '../utils';
+export type SubscribableRefreshableGraphQLImperativeResult = GraphQLResponse & {
+    subscribe?: (cb: Callback<any>) => void;
+    refresh?: () => PromiseLike<void>;
+};
+export declare class GraphQLImperativeBindingsService {
+    bind<Params extends Array<any>>(getCommand: GetCommand<Params, GraphQLCommand>, exposeRefresh?: boolean): (...params: Params) => PromiseLike<SubscribableRefreshableGraphQLImperativeResult>;
+    transformResult<Data extends GraphQLResponse<Record<string, any>>>(result: SubscribableResult<Data, GraphQLCommandError>, exposeRefresh?: boolean): SubscribableRefreshableGraphQLImperativeResult;
+}
+export interface GraphQLImperativeBindingsServiceDescriptor {
+    type: 'graphQLImperativeBindings';
+    version: string;
+    service: GraphQLImperativeBindingsService;
+}
+export declare function buildServiceDescriptor(): GraphQLImperativeBindingsServiceDescriptor;

package/dist/types/v1/invokers/graphql-legacy-invoker.d.ts

@@ -0,0 +1,25 @@
+import { Unsubscribe } from '@conduit-client/utils';
+import { JSONSchema } from '@conduit-client/jsonschema-validate';
+import { type GraphQLResponse, type GraphQLCommand } from '@conduit-client/graphql-normalization/v1';
+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 type GetGraphQLLegacyCommand<Config> = (options: {
+    config: Config;
+    assertIsValid: <T>(data: unknown, schema: JSONSchema) => asserts data is T;
+}) => Command<ReturnType<GraphQLCommand['execute']>, [LegacyExecuteOverrides?]>;
+export declare class GraphQLLegacyImperativeBindingsService {
+    bind<Config>(getCommand: GetGraphQLLegacyCommand<Config>): LegacyGraphQLImperativeShape<Config>;
+}
+export interface GraphQLLegacyImperativeBindingsServiceDescriptor {
+    type: 'graphQLLegacyImperativeBindings';
+    version: string;
+    service: GraphQLLegacyImperativeBindingsService;
+}
+export declare function buildServiceDescriptor(): GraphQLLegacyImperativeBindingsServiceDescriptor;
+export {};

package/dist/types/v1/invokers/graphql-mutation-invoker.d.ts

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

package/dist/types/v1/invokers/legacy-invoker.d.ts

@@ -0,0 +1,31 @@
+import { Unsubscribe } from '@conduit-client/utils';
+import { JSONSchema } from '@conduit-client/jsonschema-validate';
+import { LegacyExecuteOverrides } from '../utils';
+import { SubscribableResultCommand } from '@conduit-client/bindings-utils/v1';
+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 type GetLegacyCommand<Config, Data> = (options: {
+    config: Config;
+    assertIsValid: <T>(data: unknown, schema: JSONSchema) => asserts data is T;
+}) => SubscribableResultCommand<Data, unknown, [LegacyExecuteOverrides?]>;
+export declare class LegacyImperativeBindingsService {
+    bind<Config, Data>(getCommand: GetLegacyCommand<Config, Data>): LegacyImperativeShape<Config, Data>;
+}
+export interface LegacyImperativeBindingsServiceDescriptor {
+    type: 'legacyImperativeBindings';
+    version: string;
+    service: LegacyImperativeBindingsService;
+}
+export declare function buildServiceDescriptor(): LegacyImperativeBindingsServiceDescriptor;
+export {};

package/dist/types/v1/invokers/query-invoker.d.ts

@@ -0,0 +1,15 @@
+import { GetCommand, ImperativeCommand } from '../utils';
+type QueryResult<Data> = {
+    data: Data;
+};
+export type QueryImperativeResult<Data> = PromiseLike<QueryResult<Data>>;
+export declare class QueryImperativeBindingsService {
+    bind<Params extends Array<any>, Data>(getCommand: GetCommand<Params, ImperativeCommand<Data>>): (...params: Params) => QueryImperativeResult<Data>;
+}
+export interface QueryImperativeBindingsServiceDescriptor {
+    type: 'queryImperativeBindings';
+    version: string;
+    service: QueryImperativeBindingsService;
+}
+export declare function buildServiceDescriptor(): QueryImperativeBindingsServiceDescriptor;
+export {};

package/dist/types/v1/invokers/subscribable-invoker.d.ts

@@ -0,0 +1,30 @@
+import { Callback } from '@conduit-client/utils';
+import { type ResultOrSubscribableResult } from '@conduit-client/bindings-utils/v1';
+import { GetCommand, ImperativeCommand } from '../utils';
+export type SubscribableImperativeResult<Data> = {
+    data: Data;
+    subscribe: (cb: Callback<any>) => void;
+};
+export type SubscribableRefreshableImperativeResult<Data> = {
+    data: Data;
+    subscribe: (cb: Callback<any>) => void;
+    refresh: () => PromiseLike<void>;
+};
+export type MaybeRefreshableSubscribableImperativeResult<Data> = SubscribableImperativeResult<Data> | SubscribableRefreshableImperativeResult<Data>;
+export declare class SubscribableImperativeBindingsService {
+    bind<Params extends Array<any>, Data>(getCommand: GetCommand<Params, ImperativeCommand<Data>>, exposeRefresh?: boolean): (...params: Params) => PromiseLike<MaybeRefreshableSubscribableImperativeResult<Data>>;
+    transformResult<Data>(result: ResultOrSubscribableResult<Data>, exposeRefresh?: boolean): {
+        data: Data;
+        subscribe: (cb: Callback<any>) => void;
+    } | {
+        refresh: () => PromiseLike<undefined>;
+        data: Data;
+        subscribe: (cb: Callback<any>) => void;
+    };
+}
+export interface SubscribableImperativeBindingsServiceDescriptor {
+    type: 'subscribableImperativeBindings';
+    version: string;
+    service: SubscribableImperativeBindingsService;
+}
+export declare function buildServiceDescriptor(): SubscribableImperativeBindingsServiceDescriptor;

package/dist/types/v1/utils.d.ts

@@ -0,0 +1,54 @@
+import { type JSONSchema } from '@conduit-client/jsonschema-validate';
+import { SubscribableResultCommand, ResultCommand, MaybeSubscribableResultCommand, ResultOrSubscribableResult } from '@conduit-client/bindings-utils/v1';
+import type { GraphQLCommandError, GraphQLResponse } from '@conduit-client/graphql-normalization/v1';
+import { Result } from '@conduit-client/utils';
+export type ImperativeCommand<Data> = SubscribableResultCommand<Data> | ResultCommand<Data> | MaybeSubscribableResultCommand<Data>;
+export type GetCommand<Params extends Array<any>, CommandType> = (options: {
+    params: Params;
+    assertIsValid: <T>(data: unknown, schema: JSONSchema) => asserts data is T;
+}) => CommandType;
+export declare function buildBaseImperativeInvoker<Params extends Array<any>, Data, InvokerResult = Data, CommandType extends ImperativeCommand<Data> = ImperativeCommand<Data>, CommandResult extends ResultOrSubscribableResult<Data> = ResultOrSubscribableResult<Data>>(getCommand: GetCommand<Params, CommandType>, transformResult: (result: CommandResult) => InvokerResult): (...params: Params) => PromiseLike<InvokerResult>;
+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;
+export declare function handleEmit(res: Result<GraphQLResponse<Record<string, any>>, GraphQLCommandError>, callback: (result: GraphQLResponse) => void): void;
+/**
+ * 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/v1/index.js

@@ -0,0 +1,419 @@
+/*!
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+import { isUserVisibleError, logError, deepFreeze, isSubscribableResult, toError } from "@conduit-client/utils";
+import { assertIsValid } from "@conduit-client/jsonschema-validate";
+import { throwUserlandError, emitError } from "@conduit-client/bindings-utils/v1";
+import { wrapConfigAndVerify } from "@conduit-client/onestore-graphql-parser/v1";
+function buildBaseImperativeInvoker(getCommand, transformResult) {
+  return async (...params) => {
+    const command = getCommand({ params, assertIsValid });
+    try {
+      return command.execute().then((result) => transformResult(result));
+    } catch (error) {
+      throwUserlandError(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 {};
+}
+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);
+}
+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 DefaultImperativeBindingsService {
+  bind(getCommand) {
+    return buildBaseImperativeInvoker(getCommand, (result) => {
+      if (result.isOk()) {
+        deepFreeze(result.value);
+        return isSubscribableResult(result) ? result.value.data : result.value;
+      }
+      throw toError(isSubscribableResult(result) ? result.error.failure : result.error);
+    });
+  }
+}
+function buildServiceDescriptor$6() {
+  return {
+    type: "defaultImperativeBindings",
+    version: "1.0",
+    service: new DefaultImperativeBindingsService()
+  };
+}
+class QueryImperativeBindingsService {
+  bind(getCommand) {
+    return buildBaseImperativeInvoker(getCommand, (result) => {
+      if (result.isOk()) {
+        deepFreeze(result.value);
+        return isSubscribableResult(result) ? { data: result.value.data } : { data: result.value };
+      }
+      throw toError(isSubscribableResult(result) ? result.error.failure : result.error);
+    });
+  }
+}
+function buildServiceDescriptor$5() {
+  return {
+    type: "queryImperativeBindings",
+    version: "1.0",
+    service: new QueryImperativeBindingsService()
+  };
+}
+class SubscribableImperativeBindingsService {
+  bind(getCommand, exposeRefresh = false) {
+    return buildBaseImperativeInvoker(getCommand, (result) => this.transformResult(result, exposeRefresh));
+  }
+  transformResult(result, exposeRefresh = false) {
+    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 buildServiceDescriptor$4() {
+  return {
+    type: "subscribableImperativeBindings",
+    version: "1.0",
+    service: new SubscribableImperativeBindingsService()
+  };
+}
+class LegacyImperativeBindingsService {
+  bind(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 };
+  }
+}
+function buildServiceDescriptor$3() {
+  return {
+    type: "legacyImperativeBindings",
+    version: "1.0",
+    service: new LegacyImperativeBindingsService()
+  };
+}
+class GraphQLImperativeBindingsService {
+  bind(getCommand, exposeRefresh = false) {
+    return async (...params) => {
+      try {
+        if (params.length) {
+          params[0] = wrapConfigAndVerify(params[0]);
+        }
+        return await buildBaseImperativeInvoker(getCommand, (result) => this.transformResult(result, exposeRefresh))(...params);
+      } catch (error) {
+        logError(error);
+        return {
+          data: void 0,
+          errors: [
+            { message: "Internal error in GraphQL adapter occurred", locations: [] }
+          ]
+        };
+      }
+    };
+  }
+  transformResult(result, exposeRefresh = false) {
+    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;
+  }
+}
+function buildServiceDescriptor$2() {
+  return {
+    type: "graphQLImperativeBindings",
+    version: "1.0",
+    service: new GraphQLImperativeBindingsService()
+  };
+}
+class GraphQLLegacyImperativeBindingsService {
+  bind(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 buildServiceDescriptor$1() {
+  return {
+    type: "graphQLLegacyImperativeBindings",
+    version: "1.0",
+    service: new GraphQLLegacyImperativeBindingsService()
+  };
+}
+class GraphQLMutationBindingsService {
+  bind(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 buildServiceDescriptor() {
+  return {
+    type: "graphQLMutationBindings",
+    version: "1.0",
+    service: new GraphQLMutationBindingsService()
+  };
+}
+export {
+  buildServiceDescriptor$6 as buildDefaultImperativeBindingsServiceDescriptor,
+  buildServiceDescriptor$2 as buildGraphQLImperativeBindingsServiceDescriptor,
+  buildServiceDescriptor$1 as buildGraphQLLegacyImperativeBindingsServiceDescriptor,
+  buildServiceDescriptor as buildGraphQLMutationBindingsServiceDescriptor,
+  buildServiceDescriptor$3 as buildLegacyImperativeBindingsServiceDescriptor,
+  buildServiceDescriptor$5 as buildQueryImperativeBindingsServiceDescriptor,
+  buildServiceDescriptor$4 as buildSubscribableImperativeBindingsServiceDescriptor
+};
+//# sourceMappingURL=index.js.map

package/dist/v1/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../src/v1/utils.ts","../../src/v1/invokers/default-invoker.ts","../../src/v1/invokers/query-invoker.ts","../../src/v1/invokers/subscribable-invoker.ts","../../src/v1/invokers/legacy-invoker.ts","../../src/v1/invokers/graphql-invoker.ts","../../src/v1/invokers/graphql-legacy-invoker.ts","../../src/v1/invokers/graphql-mutation-invoker.ts"],"sourcesContent":["import { assertIsValid, type JSONSchema } from '@conduit-client/jsonschema-validate';\nimport {\n    SubscribableResultCommand,\n    ResultCommand,\n    MaybeSubscribableResultCommand,\n    ResultOrSubscribableResult,\n    throwUserlandError,\n} from '@conduit-client/bindings-utils/v1';\nimport type {\n    GraphQLCommandError,\n    GraphQLResponse,\n} from '@conduit-client/graphql-normalization/v1';\nimport { Result, isUserVisibleError, logError } from '@conduit-client/utils';\n\nexport type ImperativeCommand<Data> =\n    | SubscribableResultCommand<Data>\n    | ResultCommand<Data>\n    | MaybeSubscribableResultCommand<Data>;\n\nexport type GetCommand<Params extends Array<any>, CommandType> = (options: {\n    params: Params;\n    // utility to validate data against a JSONSchema\n    assertIsValid: <T>(data: unknown, schema: JSONSchema) => asserts data is T;\n}) => CommandType;\n\nexport function buildBaseImperativeInvoker<\n    Params extends Array<any>,\n    Data,\n    InvokerResult = Data,\n    CommandType extends ImperativeCommand<Data> = ImperativeCommand<Data>,\n    CommandResult extends ResultOrSubscribableResult<Data> = ResultOrSubscribableResult<Data>,\n>(\n    getCommand: GetCommand<Params, CommandType>,\n    transformResult: (result: CommandResult) => InvokerResult\n): (...params: Params) => PromiseLike<InvokerResult> {\n    return async (...params: Params) => {\n        const command = getCommand({ params, assertIsValid });\n        try {\n            return command.execute().then((result) => transformResult(result as CommandResult));\n        } catch (error) {\n            throwUserlandError(error);\n        }\n    };\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\nexport function 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\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 { isSubscribableResult, deepFreeze, toError } from '@conduit-client/utils';\nimport { buildBaseImperativeInvoker, ImperativeCommand, GetCommand } from '../utils';\n\nexport type DefaultImperativeResult<Data> = PromiseLike<Data>;\nexport class DefaultImperativeBindingsService {\n    bind<Params extends Array<any>, Data>(\n        getCommand: GetCommand<Params, ImperativeCommand<Data>>\n    ): (...params: Params) => DefaultImperativeResult<Data> {\n        return buildBaseImperativeInvoker<Params, Data>(getCommand, (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(isSubscribableResult(result) ? result.error.failure : result.error);\n        });\n    }\n}\nexport interface DefaultImperativeBindingsServiceDescriptor {\n    type: 'defaultImperativeBindings';\n    version: string;\n    service: DefaultImperativeBindingsService;\n}\n\nexport function buildServiceDescriptor(): DefaultImperativeBindingsServiceDescriptor {\n    return {\n        type: 'defaultImperativeBindings',\n        version: '1.0',\n        service: new DefaultImperativeBindingsService(),\n    };\n}\n","import { deepFreeze, isSubscribableResult, toError } from '@conduit-client/utils';\nimport { buildBaseImperativeInvoker, GetCommand, ImperativeCommand } from '../utils';\n\ntype QueryResult<Data> = { data: Data };\nexport type QueryImperativeResult<Data> = PromiseLike<QueryResult<Data>>;\n\nexport class QueryImperativeBindingsService {\n    bind<Params extends Array<any>, Data>(\n        getCommand: GetCommand<Params, ImperativeCommand<Data>>\n    ): (...params: Params) => QueryImperativeResult<Data> {\n        return buildBaseImperativeInvoker<Params, Data, QueryResult<Data>>(getCommand, (result) => {\n            if (result.isOk()) {\n                deepFreeze(result.value);\n                return isSubscribableResult(result)\n                    ? { data: result.value.data }\n                    : { data: result.value };\n            }\n\n            throw toError(isSubscribableResult(result) ? result.error.failure : result.error);\n        });\n    }\n}\n\nexport interface QueryImperativeBindingsServiceDescriptor {\n    type: 'queryImperativeBindings';\n    version: string;\n    service: QueryImperativeBindingsService;\n}\n\nexport function buildServiceDescriptor(): QueryImperativeBindingsServiceDescriptor {\n    return {\n        type: 'queryImperativeBindings',\n        version: '1.0',\n        service: new QueryImperativeBindingsService(),\n    };\n}\n","import { Callback, deepFreeze, isSubscribableResult, toError } from '@conduit-client/utils';\nimport { type ResultOrSubscribableResult } from '@conduit-client/bindings-utils/v1';\nimport { buildBaseImperativeInvoker, GetCommand, ImperativeCommand } from '../utils';\n\nexport type SubscribableImperativeResult<Data> = {\n    data: Data;\n    subscribe: (cb: Callback<any>) => void;\n};\n\nexport type SubscribableRefreshableImperativeResult<Data> = {\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\nexport class SubscribableImperativeBindingsService {\n    bind<Params extends Array<any>, Data>(\n        getCommand: GetCommand<Params, ImperativeCommand<Data>>,\n        exposeRefresh = false\n    ): (...params: Params) => PromiseLike<MaybeRefreshableSubscribableImperativeResult<Data>> {\n        return buildBaseImperativeInvoker<\n            Params,\n            Data,\n            MaybeRefreshableSubscribableImperativeResult<Data>\n        >(getCommand, (result) => this.transformResult(result, exposeRefresh));\n    }\n\n    transformResult<Data>(result: ResultOrSubscribableResult<Data>, exposeRefresh = false) {\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\nexport interface SubscribableImperativeBindingsServiceDescriptor {\n    type: 'subscribableImperativeBindings';\n    version: string;\n    service: SubscribableImperativeBindingsService;\n}\n\nexport function buildServiceDescriptor(): SubscribableImperativeBindingsServiceDescriptor {\n    return {\n        type: 'subscribableImperativeBindings',\n        version: '1.0',\n        service: new SubscribableImperativeBindingsService(),\n    };\n}\n","import { Result, deepFreeze, toError, Unsubscribe } from '@conduit-client/utils';\nimport { JSONSchema, assertIsValid } from '@conduit-client/jsonschema-validate';\nimport { LegacyExecuteOverrides, getOverridesForLegacyRequestContext } from '../utils';\nimport { emitError, SubscribableResultCommand } from '@conduit-client/bindings-utils/v1';\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 type GetLegacyCommand<Config, Data> = (options: {\n    config: Config;\n    assertIsValid: <T>(data: unknown, schema: JSONSchema) => asserts data is T;\n}) => SubscribableResultCommand<Data, unknown, [LegacyExecuteOverrides?]>;\n\nexport class LegacyImperativeBindingsService {\n    bind<Config, Data>(\n        getCommand: GetLegacyCommand<Config, Data>\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}\n\nexport interface LegacyImperativeBindingsServiceDescriptor {\n    type: 'legacyImperativeBindings';\n    version: string;\n    service: LegacyImperativeBindingsService;\n}\n\nexport function buildServiceDescriptor(): LegacyImperativeBindingsServiceDescriptor {\n    return {\n        type: 'legacyImperativeBindings',\n        version: '1.0',\n        service: new LegacyImperativeBindingsService(),\n    };\n}\n","import {\n    deepFreeze,\n    type Callback,\n    type SubscribableResult,\n    logError,\n    isUserVisibleError,\n} from '@conduit-client/utils';\nimport {\n    type GraphQLCommandError,\n    type GraphQLResponse,\n    type GraphQLCommand,\n} from '@conduit-client/graphql-normalization/v1';\nimport { wrapConfigAndVerify } from '@conduit-client/onestore-graphql-parser/v1';\nimport { buildBaseImperativeInvoker, GetCommand, toGraphQLResponseFromFailure } from '../utils';\n\nexport type SubscribableRefreshableGraphQLImperativeResult = GraphQLResponse & {\n    subscribe?: (cb: Callback<any>) => void;\n    refresh?: () => PromiseLike<void>;\n};\n\nexport class GraphQLImperativeBindingsService {\n    bind<Params extends Array<any>>(\n        getCommand: GetCommand<Params, GraphQLCommand>,\n        exposeRefresh = false\n    ): (...params: Params) => PromiseLike<SubscribableRefreshableGraphQLImperativeResult> {\n        return async (...params: Params) => {\n            try {\n                if (params.length) {\n                    params[0] = wrapConfigAndVerify(params[0]);\n                }\n                return await buildBaseImperativeInvoker<\n                    Params,\n                    GraphQLResponse<Record<string, any>>,\n                    SubscribableRefreshableGraphQLImperativeResult,\n                    GraphQLCommand,\n                    SubscribableResult<GraphQLResponse<Record<string, any>>, GraphQLCommandError>\n                >(getCommand, (result) => this.transformResult(result, exposeRefresh))(...params);\n            } catch (error) {\n                logError(error);\n                return {\n                    data: undefined,\n                    errors: [\n                        { message: 'Internal error in GraphQL adapter occurred', locations: [] },\n                    ],\n                };\n            }\n        };\n    }\n\n    transformResult<Data extends GraphQLResponse<Record<string, any>>>(\n        result: SubscribableResult<Data, GraphQLCommandError>,\n        exposeRefresh = false\n    ): SubscribableRefreshableGraphQLImperativeResult {\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    }\n}\n\nexport interface GraphQLImperativeBindingsServiceDescriptor {\n    type: 'graphQLImperativeBindings';\n    version: string;\n    service: GraphQLImperativeBindingsService;\n}\n\nexport function buildServiceDescriptor(): GraphQLImperativeBindingsServiceDescriptor {\n    return {\n        type: 'graphQLImperativeBindings',\n        version: '1.0',\n        service: new GraphQLImperativeBindingsService(),\n    };\n}\n","import { deepFreeze, Result, Unsubscribe, logError } from '@conduit-client/utils';\nimport { JSONSchema, assertIsValid } from '@conduit-client/jsonschema-validate';\nimport {\n    type GraphQLCommandError,\n    type GraphQLResponse,\n    type GraphQLCommand,\n} from '@conduit-client/graphql-normalization/v1';\nimport { wrapConfigAndVerify } from '@conduit-client/onestore-graphql-parser/v1';\nimport type { Command } from '@conduit-client/command-base/v1';\nimport { getOverridesForLegacyRequestContext, handleEmit } from '../utils';\nimport { type LegacyExecuteOverrides, toGraphQLResponseFromFailure } 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 type GetGraphQLLegacyCommand<Config> = (options: {\n    config: Config;\n    assertIsValid: <T>(data: unknown, schema: JSONSchema) => asserts data is T;\n}) => Command<ReturnType<GraphQLCommand['execute']>, [LegacyExecuteOverrides?]>;\n\nexport class GraphQLLegacyImperativeBindingsService {\n    bind<Config>(\n        getCommand: GetGraphQLLegacyCommand<Config>\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: [\n                        { message: 'Internal error in GraphQL adapter occurred', locations: [] },\n                    ],\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\n                .execute(overrides)\n                .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                            (\n                                res: Result<\n                                    GraphQLResponse<Record<string, any>>,\n                                    GraphQLCommandError\n                                >\n                            ) => {\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                            (\n                                res: Result<\n                                    GraphQLResponse<Record<string, any>>,\n                                    GraphQLCommandError\n                                >\n                            ) => {\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}\n\nexport interface GraphQLLegacyImperativeBindingsServiceDescriptor {\n    type: 'graphQLLegacyImperativeBindings';\n    version: string;\n    service: GraphQLLegacyImperativeBindingsService;\n}\n\nexport function buildServiceDescriptor(): GraphQLLegacyImperativeBindingsServiceDescriptor {\n    return {\n        type: 'graphQLLegacyImperativeBindings',\n        version: '1.0',\n        service: new GraphQLLegacyImperativeBindingsService(),\n    };\n}\n","import { deepFreeze, logError } from '@conduit-client/utils';\nimport { JSONSchema, assertIsValid } from '@conduit-client/jsonschema-validate';\nimport {\n    type GraphQLResponse,\n    type GraphQLCommand,\n} from '@conduit-client/graphql-normalization/v1';\nimport { wrapConfigAndVerify } from '@conduit-client/onestore-graphql-parser/v1';\nimport type { Command } from '@conduit-client/command-base/v1';\nimport { type LegacyExecuteOverrides, toGraphQLResponseFromFailure } from '../utils';\n\nexport type GraphQLMutationResult = Promise<GraphQLResponse>;\ntype GetGraphQLCommand<Params> = (options: {\n    params: Params;\n    assertIsValid: <T>(data: unknown, schema: JSONSchema) => asserts data is T;\n}) => Command<ReturnType<GraphQLCommand['execute']>, [LegacyExecuteOverrides?]>;\n\nexport class GraphQLMutationBindingsService {\n    bind<Params extends Array<any>>(\n        getCommand: GetGraphQLCommand<Params>\n    ): (...params: Params) => GraphQLMutationResult {\n        return async (...params: Params) => {\n            try {\n                if (params.length) {\n                    params[0] = wrapConfigAndVerify(params[0], {\n                        acceptedOperations: ['mutation'],\n                    });\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: [\n                        { message: 'Internal error in GraphQL adapter occurred', locations: [] },\n                    ],\n                } satisfies GraphQLResponse;\n            }\n        };\n    }\n}\n\nexport interface GraphQLMutationBindingsServiceDescriptor {\n    type: 'graphQLMutationBindings';\n    version: string;\n    service: GraphQLMutationBindingsService;\n}\n\nexport function buildServiceDescriptor(): GraphQLMutationBindingsServiceDescriptor {\n    return {\n        type: 'graphQLMutationBindings',\n        version: '1.0',\n        service: new GraphQLMutationBindingsService(),\n    };\n}\n"],"names":["buildServiceDescriptor","result","consumerEmittedData"],"mappings":"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"}

package/package.json

@@ -0,0 +1,52 @@
+{
+    "name": "@conduit-client/service-bindings-imperative",
+    "version": "2.1.0",
+    "private": false,
+    "description": "Conduit services for imperative bindings",
+    "type": "module",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/salesforce-experience-platform-emu/onestore.git",
+        "directory": "packages/@conduit-client/services/bindings-imperative"
+    },
+    "license": "SEE LICENSE IN LICENSE.txt",
+    "exports": {
+        "./v1": {
+            "import": "./dist/v1/index.js",
+            "types": "./dist/types/v1/index.d.ts",
+            "require": "./dist/v1/index.js"
+        }
+    },
+    "main": "./dist/main/index.js",
+    "module": "./dist/main/index.js",
+    "types": "./dist/main/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/bindings-utils": "2.1.0",
+        "@conduit-client/command-base": "2.1.0",
+        "@conduit-client/jsonschema-validate": "2.1.0",
+        "@conduit-client/onestore-graphql-parser": "2.1.0",
+        "@conduit-client/utils": "2.1.0"
+    },
+    "devDependencies": {
+        "@conduit-client/graphql-normalization": "2.1.0"
+    },
+    "volta": {
+        "extends": "../../../../package.json"
+    },
+    "size-limit": [
+        {
+            "path": "./dist/v1/index.js",
+            "limit": "2.1 kB"
+        }
+    ]
+}