@salesforce/lds-adapters-platform-external-connectivity 1.364.0 → 1.366.0

package/dist/es/es2018/platform-external-connectivity.js

@@ -4,10 +4,10 @@
  * For full license text, see the LICENSE.txt file
  */
 
-import { serializeStructuredKey, ingestShape, deepFreeze, buildNetworkSnapshotCachePolicy as buildNetworkSnapshotCachePolicy$7, StoreKeyMap, createResourceParams as createResourceParams$c, typeCheckConfig as typeCheckConfig$c } from '@luvio/engine';
+import { serializeStructuredKey, ingestShape, deepFreeze, buildNetworkSnapshotCachePolicy as buildNetworkSnapshotCachePolicy$7, typeCheckConfig as typeCheckConfig$c, StoreKeyMap, createResourceParams as createResourceParams$c } from '@luvio/engine';
 
 const { hasOwnProperty: ObjectPrototypeHasOwnProperty } = Object.prototype;
-const { keys: ObjectKeys, create: ObjectCreate } = Object;
+const { keys: ObjectKeys$1, create: ObjectCreate$1 } = Object;
 const { isArray: ArrayIsArray$1 } = Array;
 /**
  * Validates an adapter config is well-formed.
@@ -31,7 +31,7 @@ function validateConfig(config, adapter, oneOf) {
         throw new TypeError(`adapter ${displayName} does not yet support ${unsupported.sort().join(', ')}`);
     }
     const supported = required.concat(optional);
-    if (ObjectKeys(config).some(key => !supported.includes(key))) {
+    if (ObjectKeys$1(config).some(key => !supported.includes(key))) {
         throw new TypeError(`adapter ${displayName} configuration supports only ${supported.sort().join(', ')}`);
     }
 }
@@ -71,6 +71,7 @@ function buildAdapterValidationConfig(displayName, paramsMeta) {
 }
 const keyPrefix = 'external-connectivity';
 
+const { keys: ObjectKeys, create: ObjectCreate, assign: ObjectAssign } = Object;
 const { isArray: ArrayIsArray } = Array;
 const { stringify: JSONStringify } = JSON;
 function equalsArray(a, b, equalsItem) {
@@ -526,7 +527,7 @@ function getTypeCacheKeys$c(rootKeySet, luvio, input, fullPathFactory) {
 }
 
 const TTL$b = 500;
-const VERSION$b = "20bb37f8c88f1dd513107a5128a6f4a5";
+const VERSION$b = "b5d13b1fd1ba9a2eccd69af50a915654";
 function validate$i(obj, path = 'ExternalConnectivityConnectionListRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
@@ -544,10 +545,45 @@ function validate$i(obj, path = 'ExternalConnectivityConnectionListRepresentatio
                 return new TypeError('Expected "object" but received "' + typeof obj_connections_item + '" (at "' + path_connections_item + '")');
             }
         }
+        const obj_connectorDeveloperName = obj.connectorDeveloperName;
+        const path_connectorDeveloperName = path + '.connectorDeveloperName';
+        let obj_connectorDeveloperName_union0 = null;
+        const obj_connectorDeveloperName_union0_error = (() => {
+            if (typeof obj_connectorDeveloperName !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_connectorDeveloperName + '" (at "' + path_connectorDeveloperName + '")');
+            }
+        })();
+        if (obj_connectorDeveloperName_union0_error != null) {
+            obj_connectorDeveloperName_union0 = obj_connectorDeveloperName_union0_error.message;
+        }
+        let obj_connectorDeveloperName_union1 = null;
+        const obj_connectorDeveloperName_union1_error = (() => {
+            if (obj_connectorDeveloperName !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_connectorDeveloperName + '" (at "' + path_connectorDeveloperName + '")');
+            }
+        })();
+        if (obj_connectorDeveloperName_union1_error != null) {
+            obj_connectorDeveloperName_union1 = obj_connectorDeveloperName_union1_error.message;
+        }
+        if (obj_connectorDeveloperName_union0 && obj_connectorDeveloperName_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_connectorDeveloperName + '")';
+            message += '\n' + obj_connectorDeveloperName_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_connectorDeveloperName_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
     })();
     return v_error === undefined ? null : v_error;
 }
 const RepresentationType$b = 'ExternalConnectivityConnectionListRepresentation';
+function keyBuilder$j(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$b + ':' + (config.connectorDeveloperName === null ? '' : config.connectorDeveloperName);
+}
+function keyBuilderFromType$5(luvio, object) {
+    const keyParams = {
+        connectorDeveloperName: object.connectorDeveloperName
+    };
+    return keyBuilder$j(luvio, keyParams);
+}
 function normalize$b(input, existing, path, luvio, store, timestamp) {
     const input_connections = input.connections;
     const input_connections_id = path.fullPath + '__connections';
@@ -578,6 +614,10 @@ const select$n = function ExternalConnectivityConnectionListRepresentationSelect
                 kind: 'Link',
                 plural: true,
                 fragment: select$o()
+            },
+            {
+                name: 'connectorDeveloperName',
+                kind: 'Scalar'
             }
         ]
     };
@@ -593,6 +633,11 @@ function equals$b(existing, incoming) {
     if (equals_connections_items === false) {
         return false;
     }
+    const existing_connectorDeveloperName = existing.connectorDeveloperName;
+    const incoming_connectorDeveloperName = incoming.connectorDeveloperName;
+    if (!(existing_connectorDeveloperName === incoming_connectorDeveloperName)) {
+        return false;
+    }
     return true;
 }
 const ingest$b = function ExternalConnectivityConnectionListRepresentationIngest(input, path, luvio, store, timestamp) {
@@ -602,14 +647,14 @@ const ingest$b = function ExternalConnectivityConnectionListRepresentationIngest
             throw validateError;
         }
     }
-    const key = path.fullPath;
+    const key = keyBuilderFromType$5(luvio, input);
     const ttlToUse = TTL$b;
     ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$b, "external-connectivity", VERSION$b, RepresentationType$b, equals$b);
     return createLink(key);
 };
 function getTypeCacheKeys$b(rootKeySet, luvio, input, fullPathFactory) {
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
-    const rootKey = fullPathFactory();
+    const rootKey = keyBuilderFromType$5(luvio, input);
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
         representationName: RepresentationType$b,
@@ -620,19 +665,35 @@ function getTypeCacheKeys$b(rootKeySet, luvio, input, fullPathFactory) {
         getTypeCacheKeys$c(rootKeySet, luvio, input.connections[i], () => '');
     }
 }
+const notifyUpdateAvailableFactory = (luvio) => {
+    return function notifyConnectionListUpdateAvailable(configs) {
+        if (process.env.NODE_ENV !== 'production') {
+            const requiredKeyParams = ['connectorDeveloperName'];
+            configs.forEach(config => {
+                if (false === requiredKeyParams.every(req => req in config)) {
+                    throw new Error(`one of the configs did not contain all required parameters: ${JSONStringify(ObjectKeys(config))}`);
+                }
+            });
+        }
+        const keys = configs.map(c => keyBuilder$j(luvio, c));
+        return luvio.notifyStoreUpdateAvailable(keys);
+    };
+};
 
 function select$m(luvio, params) {
     return select$n();
 }
 function keyBuilder$i(luvio, params) {
-    return keyPrefix + '::ExternalConnectivityConnectionListRepresentation:(' + ')';
+    return keyBuilder$j(luvio, {
+        connectorDeveloperName: params.queryParams.connectorDeveloperName || ''
+    });
 }
 function getResponseCacheKeys$b(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$b(storeKeyMap, luvio, response, () => keyBuilder$i());
+    getTypeCacheKeys$b(storeKeyMap, luvio, response);
 }
 function ingestSuccess$b(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$i();
+    const key = keyBuilder$i(luvio, resourceParams);
     luvio.storeIngest(key, ingest$b, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
@@ -648,7 +709,7 @@ function ingestSuccess$b(luvio, resourceParams, response, snapshotRefresh) {
     return snapshot;
 }
 function ingestError$6(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$i();
+    const key = keyBuilder$i(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     const storeMetadataParams = {
         ttl: TTL$b,
@@ -667,22 +728,25 @@ function createResourceRequest$b(config) {
         method: 'get',
         body: null,
         urlParams: {},
-        queryParams: {},
+        queryParams: config.queryParams,
         headers,
         priority: 'normal',
     };
 }
 
 const adapterName$b = 'getConnections';
-const getConnections_ConfigPropertyMetadata = [];
+const getConnections_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('connectorDeveloperName', false, 1 /* QueryParameter */, 0 /* String */),
+];
 const getConnections_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$b, getConnections_ConfigPropertyMetadata);
 const createResourceParams$b = /*#__PURE__*/ createResourceParams$c(getConnections_ConfigPropertyMetadata);
 function keyBuilder$h(luvio, config) {
-    createResourceParams$b(config);
-    return keyBuilder$i();
+    const resourceParams = createResourceParams$b(config);
+    return keyBuilder$i(luvio, resourceParams);
 }
 function typeCheckConfig$b(untrustedConfig) {
     const config = {};
+    typeCheckConfig$c(untrustedConfig, config, getConnections_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$b(untrustedConfig, configPropertyNames) {
@@ -692,7 +756,7 @@ function validateAdapterConfig$b(untrustedConfig, configPropertyNames) {
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$b();
+    const config = typeCheckConfig$b(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
@@ -718,7 +782,7 @@ function onFetchResponseError$6(luvio, config, resourceParams, response) {
 }
 function buildNetworkSnapshot$b(luvio, config, options) {
     const resourceParams = createResourceParams$b(config);
-    const request = createResourceRequest$b();
+    const request = createResourceRequest$b(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => onFetchResponseSuccess$6(luvio, config, resourceParams, response), () => {
@@ -3764,4 +3828,4 @@ const getInvocableActionsAdapterFactory = (luvio) => function externalConnectivi
     buildCachedSnapshotCachePolicy, buildNetworkSnapshotCachePolicy);
 };
 
-export { createConnectionAdapterFactory, deleteConnectionAdapterFactory, getConnectionDetailsAdapterFactory, getConnectionsAdapterFactory, getConnectorDetailsAdapterFactory, getConnectorsAdapterFactory, getExternalConnectivityConnectionReferencedFlowsAdapterFactory, getExternalIdentityProvidersAdapterFactory, getInvocableActionsAdapterFactory, refreshMetadataAdapterFactory, testConnectionAdapterFactory, updateConnectionAdapterFactory };
+export { createConnectionAdapterFactory, deleteConnectionAdapterFactory, getConnectionDetailsAdapterFactory, getConnectionsAdapterFactory, getConnectorDetailsAdapterFactory, getConnectorsAdapterFactory, getExternalConnectivityConnectionReferencedFlowsAdapterFactory, getExternalIdentityProvidersAdapterFactory, getInvocableActionsAdapterFactory, notifyUpdateAvailableFactory as notifyConnectionListUpdateAvailableFactory, refreshMetadataAdapterFactory, testConnectionAdapterFactory, updateConnectionAdapterFactory };

package/dist/es/es2018/types/src/generated/adapters/getConnections.d.ts

@@ -6,6 +6,7 @@ export declare const adapterName = "getConnections";
 export declare const getConnections_ConfigPropertyMetadata: $64$luvio_engine_AdapterConfigMetadata[];
 export declare const getConnections_ConfigPropertyNames: adapter$45$utils_AdapterValidationConfig;
 export interface GetConnectionsConfig {
+    connectorDeveloperName?: string;
 }
 export declare const createResourceParams: (config: GetConnectionsConfig) => resources_getExternalConnectivityConnections_ResourceRequestConfig;
 export declare function keyBuilder(luvio: $64$luvio_engine_Luvio, config: GetConnectionsConfig): string;

package/dist/es/es2018/types/src/generated/artifacts/main.d.ts

@@ -10,3 +10,4 @@ export { getConnectorsAdapterFactory } from '../adapters/getConnectors';
 export { getConnectorDetailsAdapterFactory } from '../adapters/getConnectorDetails';
 export { getExternalIdentityProvidersAdapterFactory } from '../adapters/getExternalIdentityProviders';
 export { getInvocableActionsAdapterFactory } from '../adapters/getInvocableActions';
+export { notifyUpdateAvailableFactory as notifyConnectionListUpdateAvailableFactory } from '../types/ExternalConnectivityConnectionListRepresentation';

package/dist/es/es2018/types/src/generated/artifacts/sfdc.d.ts

@@ -17,4 +17,6 @@ declare let getConnectors_imperative: any;
 declare let getExternalConnectivityConnectionReferencedFlows_imperative: any;
 declare let getExternalIdentityProviders_imperative: any;
 declare let getInvocableActions_imperative: any;
+declare let notifyConnectionListUpdateAvailable: any;
 export { createConnection, deleteConnection, getConnectionDetails, getConnections, getConnectorDetails, getConnectors, getExternalConnectivityConnectionReferencedFlows, getExternalIdentityProviders, getInvocableActions, refreshMetadata, testConnection, updateConnection, getConnectionDetails_imperative, getConnections_imperative, getConnectorDetails_imperative, getConnectors_imperative, getExternalConnectivityConnectionReferencedFlows_imperative, getExternalIdentityProviders_imperative, getInvocableActions_imperative, };
+export { notifyConnectionListUpdateAvailable };

package/dist/es/es2018/types/src/generated/resources/getExternalConnectivityConnections.d.ts

@@ -1,6 +1,9 @@
 import { Luvio as $64$luvio_engine_Luvio, Fragment as $64$luvio_engine_Fragment, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, FetchResponse as $64$luvio_engine_FetchResponse, SnapshotRefresh as $64$luvio_engine_SnapshotRefresh, FulfilledSnapshot as $64$luvio_engine_FulfilledSnapshot, StaleSnapshot as $64$luvio_engine_StaleSnapshot, PendingSnapshot as $64$luvio_engine_PendingSnapshot, ErrorResponse as $64$luvio_engine_ErrorResponse, ErrorSnapshot as $64$luvio_engine_ErrorSnapshot, ResourceRequest as $64$luvio_engine_ResourceRequest } from '@luvio/engine';
 import { ExternalConnectivityConnectionListRepresentation as types_ExternalConnectivityConnectionListRepresentation_ExternalConnectivityConnectionListRepresentation } from '../types/ExternalConnectivityConnectionListRepresentation';
 export interface ResourceRequestConfig {
+    queryParams: {
+        connectorDeveloperName?: string;
+    };
 }
 export declare function select(luvio: $64$luvio_engine_Luvio, params: ResourceRequestConfig): $64$luvio_engine_Fragment;
 export declare function keyBuilder(luvio: $64$luvio_engine_Luvio, params: ResourceRequestConfig): string;

package/dist/es/es2018/types/src/generated/types/ExternalConnectivityConnectionListRepresentation.d.ts

@@ -1,9 +1,18 @@
-import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, ResourceIngest as $64$luvio_engine_ResourceIngest, FragmentSelection as $64$luvio_engine_FragmentSelection, LinkSelection as $64$luvio_engine_LinkSelection, StoreLink as $64$luvio_engine_StoreLink, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+import { KeyMetadata as $64$luvio_engine_KeyMetadata, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, Luvio as $64$luvio_engine_Luvio, IngestPath as $64$luvio_engine_IngestPath, Store as $64$luvio_engine_Store, ResourceIngest as $64$luvio_engine_ResourceIngest, FragmentSelection as $64$luvio_engine_FragmentSelection, LinkSelection as $64$luvio_engine_LinkSelection, StoreLink as $64$luvio_engine_StoreLink, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
 import { ExternalConnectivityConnectionRepresentation as ExternalConnectivityConnectionRepresentation_ExternalConnectivityConnectionRepresentation } from './ExternalConnectivityConnectionRepresentation';
 export declare const TTL = 500;
-export declare const VERSION = "20bb37f8c88f1dd513107a5128a6f4a5";
+export declare const VERSION = "b5d13b1fd1ba9a2eccd69af50a915654";
 export declare function validate(obj: any, path?: string): TypeError | null;
 export declare const RepresentationType: string;
+export interface KeyParams extends $64$luvio_engine_KeyMetadata {
+    connectorDeveloperName: string | null;
+}
+export type ExternalConnectivityConnectionListRepresentationNormalizedKeyMetadata = KeyParams & $64$luvio_engine_NormalizedKeyMetadata;
+export type PartialExternalConnectivityConnectionListRepresentationNormalizedKeyMetadata = Partial<KeyParams> & $64$luvio_engine_NormalizedKeyMetadata;
+export declare function keyBuilder(luvio: $64$luvio_engine_Luvio, config: KeyParams): string;
+export declare function keyBuilder_StructuredKey(luvio: $64$luvio_engine_Luvio, config: KeyParams): ExternalConnectivityConnectionListRepresentationNormalizedKeyMetadata;
+export declare function keyBuilderFromType(luvio: $64$luvio_engine_Luvio, object: ExternalConnectivityConnectionListRepresentation): string;
+export declare function keyBuilderFromType_StructuredKey(luvio: $64$luvio_engine_Luvio, object: ExternalConnectivityConnectionListRepresentation): $64$luvio_engine_NormalizedKeyMetadata;
 export declare function normalize(input: ExternalConnectivityConnectionListRepresentation, existing: ExternalConnectivityConnectionListRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): ExternalConnectivityConnectionListRepresentationNormalized;
 export interface DynamicIngestParams {
     connections: $64$luvio_engine_ResourceIngest;
@@ -22,18 +31,22 @@ export declare function dynamicIngest(ingestParams: DynamicIngestParams): $64$lu
  * Output representation for External Connectivity Connection List
  *
  * Keys:
- *    (none)
+ *    connectorDeveloperName (string | null): connectorDeveloperName
  */
 export interface ExternalConnectivityConnectionListRepresentationNormalized {
     /** List of External Connectivity Connections */
     connections: Array<$64$luvio_engine_StoreLink>;
+    /** The Connector developer name for a filtered list of connections. */
+    connectorDeveloperName: string | null;
 }
 /**
  * Output representation for External Connectivity Connection List
  *
  * Keys:
- *    (none)
+ *    connectorDeveloperName (string | null): connectorDeveloperName
  */
 export interface ExternalConnectivityConnectionListRepresentation {
     connections: Array<ExternalConnectivityConnectionRepresentation_ExternalConnectivityConnectionRepresentation>;
+    connectorDeveloperName: string | null;
 }
+export declare const notifyUpdateAvailableFactory: (luvio: $64$luvio_engine_Luvio) => (configs: Partial<KeyParams>[]) => Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@salesforce/lds-adapters-platform-external-connectivity",
-    "version": "1.364.0",
+    "version": "1.366.0",
     "description": "A set of API for external connectivity",
     "license": "SEE LICENSE IN LICENSE.txt",
     "main": "dist/es/es2018/platform-external-connectivity.js",
@@ -41,10 +41,10 @@
         "test:unit:debug": "node --inspect-brk ../../node_modules/.bin/jest --runInBand"
     },
     "dependencies": {
-        "@salesforce/lds-bindings": "^1.364.0"
+        "@salesforce/lds-bindings": "^1.366.0"
     },
     "devDependencies": {
-        "@salesforce/lds-compiler-plugins": "^1.364.0"
+        "@salesforce/lds-compiler-plugins": "^1.366.0"
     },
     "nx": {
         "targets": {

package/sfdc/index.js

@@ -17,7 +17,7 @@ import { withDefaultLuvio } from 'force/ldsEngine';
 import { serializeStructuredKey, ingestShape, deepFreeze, StoreKeyMap, createResourceParams as createResourceParams$c, typeCheckConfig as typeCheckConfig$c, buildNetworkSnapshotCachePolicy as buildNetworkSnapshotCachePolicy$7 } from 'force/luvioEngine';
 
 const { hasOwnProperty: ObjectPrototypeHasOwnProperty } = Object.prototype;
-const { keys: ObjectKeys, create: ObjectCreate } = Object;
+const { keys: ObjectKeys$1, create: ObjectCreate$1 } = Object;
 const { isArray: ArrayIsArray$1 } = Array;
 /**
  * Validates an adapter config is well-formed.
@@ -41,7 +41,7 @@ function validateConfig(config, adapter, oneOf) {
         throw new TypeError(`adapter ${displayName} does not yet support ${unsupported.sort().join(', ')}`);
     }
     const supported = required.concat(optional);
-    if (ObjectKeys(config).some(key => !supported.includes(key))) {
+    if (ObjectKeys$1(config).some(key => !supported.includes(key))) {
         throw new TypeError(`adapter ${displayName} configuration supports only ${supported.sort().join(', ')}`);
     }
 }
@@ -81,6 +81,7 @@ function buildAdapterValidationConfig(displayName, paramsMeta) {
 }
 const keyPrefix = 'external-connectivity';
 
+const { keys: ObjectKeys, create: ObjectCreate, assign: ObjectAssign } = Object;
 const { isArray: ArrayIsArray } = Array;
 const { stringify: JSONStringify } = JSON;
 function equalsArray(a, b, equalsItem) {
@@ -144,14 +145,14 @@ function validate$k(obj, path = 'ExternalConnectivityConnectionCreatedRepresenta
     return v_error === undefined ? null : v_error;
 }
 const RepresentationType$d = 'ExternalConnectivityConnectionCreatedRepresentation';
-function keyBuilder$i(luvio, config) {
+function keyBuilder$j(luvio, config) {
     return keyPrefix + '::' + RepresentationType$d + ':' + config.developerName;
 }
-function keyBuilderFromType$4(luvio, object) {
+function keyBuilderFromType$5(luvio, object) {
     const keyParams = {
         developerName: object.developerName
     };
-    return keyBuilder$i(luvio, keyParams);
+    return keyBuilder$j(luvio, keyParams);
 }
 function normalize$d(input, existing, path, luvio, store, timestamp) {
     return input;
@@ -184,14 +185,14 @@ const ingest$d = function ExternalConnectivityConnectionCreatedRepresentationIng
             throw validateError;
         }
     }
-    const key = keyBuilderFromType$4(luvio, input);
+    const key = keyBuilderFromType$5(luvio, input);
     const ttlToUse = TTL$c;
     ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$d, "external-connectivity", VERSION$d, RepresentationType$d, equals$d);
     return createLink(key);
 };
 function getTypeCacheKeys$d(rootKeySet, luvio, input, fullPathFactory) {
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
-    const rootKey = keyBuilderFromType$4(luvio, input);
+    const rootKey = keyBuilderFromType$5(luvio, input);
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
         representationName: RepresentationType$d,
@@ -207,7 +208,7 @@ function getResponseCacheKeys$b(storeKeyMap, luvio, resourceParams, response) {
 }
 function ingestSuccess$b(luvio, resourceParams, response) {
     const { body } = response;
-    const key = keyBuilderFromType$4(luvio, body);
+    const key = keyBuilderFromType$5(luvio, body);
     luvio.storeIngest(key, ingest$d, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
@@ -373,14 +374,14 @@ function validate$j(obj, path = 'ExternalConnectivityConnectionEditDeleteResultR
     return v_error === undefined ? null : v_error;
 }
 const RepresentationType$c = 'ExternalConnectivityConnectionEditDeleteResultRepresentation';
-function keyBuilder$h(luvio, config) {
+function keyBuilder$i(luvio, config) {
     return keyPrefix + '::' + RepresentationType$c + ':' + config.developerName;
 }
-function keyBuilderFromType$3(luvio, object) {
+function keyBuilderFromType$4(luvio, object) {
     const keyParams = {
         developerName: object.developerName
     };
-    return keyBuilder$h(luvio, keyParams);
+    return keyBuilder$i(luvio, keyParams);
 }
 function normalize$c(input, existing, path, luvio, store, timestamp) {
     return input;
@@ -431,14 +432,14 @@ const ingest$c = function ExternalConnectivityConnectionEditDeleteResultRepresen
             throw validateError;
         }
     }
-    const key = keyBuilderFromType$3(luvio, input);
+    const key = keyBuilderFromType$4(luvio, input);
     const ttlToUse = TTL$b;
     ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$c, "external-connectivity", VERSION$c, RepresentationType$c, equals$c);
     return createLink(key);
 };
 function getTypeCacheKeys$c(rootKeySet, luvio, input, fullPathFactory) {
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
-    const rootKey = keyBuilderFromType$3(luvio, input);
+    const rootKey = keyBuilderFromType$4(luvio, input);
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
         representationName: RepresentationType$c,
@@ -454,7 +455,7 @@ function getResponseCacheKeys$a(storeKeyMap, luvio, resourceParams, response) {
 }
 function ingestSuccess$a(luvio, resourceParams, response) {
     const { body } = response;
-    const key = keyBuilderFromType$3(luvio, body);
+    const key = keyBuilderFromType$4(luvio, body);
     luvio.storeIngest(key, ingest$c, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
@@ -985,15 +986,15 @@ function getTypeCacheKeys$a(rootKeySet, luvio, input, fullPathFactory) {
 function select$j(luvio, params) {
     return select$k();
 }
-function keyBuilder$g(luvio, params) {
+function keyBuilder$h(luvio, params) {
     return keyPrefix + '::ExternalConnectivityConnectionDetailsRepresentation:(' + 'connectionDeveloperName:' + params.urlParams.connectionDeveloperName + ')';
 }
 function getResponseCacheKeys$9(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$a(storeKeyMap, luvio, response, () => keyBuilder$g(luvio, resourceParams));
+    getTypeCacheKeys$a(storeKeyMap, luvio, response, () => keyBuilder$h(luvio, resourceParams));
 }
 function ingestSuccess$9(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$g(luvio, resourceParams);
+    const key = keyBuilder$h(luvio, resourceParams);
     luvio.storeIngest(key, ingest$a, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
@@ -1009,7 +1010,7 @@ function ingestSuccess$9(luvio, resourceParams, response, snapshotRefresh) {
     return snapshot;
 }
 function ingestError$6(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$g(luvio, params);
+    const key = keyBuilder$h(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     const storeMetadataParams = {
         ttl: TTL$9,
@@ -1040,9 +1041,9 @@ const getConnectionDetails_ConfigPropertyMetadata = [
 ];
 const getConnectionDetails_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$9, getConnectionDetails_ConfigPropertyMetadata);
 const createResourceParams$9 = /*#__PURE__*/ createResourceParams$c(getConnectionDetails_ConfigPropertyMetadata);
-function keyBuilder$f(luvio, config) {
+function keyBuilder$g(luvio, config) {
     const resourceParams = createResourceParams$9(config);
-    return keyBuilder$g(luvio, resourceParams);
+    return keyBuilder$h(luvio, resourceParams);
 }
 function typeCheckConfig$9(untrustedConfig) {
     const config = {};
@@ -1100,7 +1101,7 @@ function buildNetworkSnapshotCachePolicy$6(context, coercedAdapterRequestContext
 function buildCachedSnapshotCachePolicy$6(context, storeLookup) {
     const { luvio, config } = context;
     const selector = {
-        recordId: keyBuilder$f(luvio, config),
+        recordId: keyBuilder$g(luvio, config),
         node: adapterFragment$6(luvio, config),
         variables: {},
     };
@@ -1410,7 +1411,7 @@ function getTypeCacheKeys$9(rootKeySet, luvio, input, fullPathFactory) {
 }
 
 const TTL$8 = 500;
-const VERSION$8 = "20bb37f8c88f1dd513107a5128a6f4a5";
+const VERSION$8 = "b5d13b1fd1ba9a2eccd69af50a915654";
 function validate$b(obj, path = 'ExternalConnectivityConnectionListRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
@@ -1428,10 +1429,45 @@ function validate$b(obj, path = 'ExternalConnectivityConnectionListRepresentatio
                 return new TypeError('Expected "object" but received "' + typeof obj_connections_item + '" (at "' + path_connections_item + '")');
             }
         }
+        const obj_connectorDeveloperName = obj.connectorDeveloperName;
+        const path_connectorDeveloperName = path + '.connectorDeveloperName';
+        let obj_connectorDeveloperName_union0 = null;
+        const obj_connectorDeveloperName_union0_error = (() => {
+            if (typeof obj_connectorDeveloperName !== 'string') {
+                return new TypeError('Expected "string" but received "' + typeof obj_connectorDeveloperName + '" (at "' + path_connectorDeveloperName + '")');
+            }
+        })();
+        if (obj_connectorDeveloperName_union0_error != null) {
+            obj_connectorDeveloperName_union0 = obj_connectorDeveloperName_union0_error.message;
+        }
+        let obj_connectorDeveloperName_union1 = null;
+        const obj_connectorDeveloperName_union1_error = (() => {
+            if (obj_connectorDeveloperName !== null) {
+                return new TypeError('Expected "null" but received "' + typeof obj_connectorDeveloperName + '" (at "' + path_connectorDeveloperName + '")');
+            }
+        })();
+        if (obj_connectorDeveloperName_union1_error != null) {
+            obj_connectorDeveloperName_union1 = obj_connectorDeveloperName_union1_error.message;
+        }
+        if (obj_connectorDeveloperName_union0 && obj_connectorDeveloperName_union1) {
+            let message = 'Object doesn\'t match union (at "' + path_connectorDeveloperName + '")';
+            message += '\n' + obj_connectorDeveloperName_union0.split('\n').map((line) => '\t' + line).join('\n');
+            message += '\n' + obj_connectorDeveloperName_union1.split('\n').map((line) => '\t' + line).join('\n');
+            return new TypeError(message);
+        }
     })();
     return v_error === undefined ? null : v_error;
 }
 const RepresentationType$8 = 'ExternalConnectivityConnectionListRepresentation';
+function keyBuilder$f(luvio, config) {
+    return keyPrefix + '::' + RepresentationType$8 + ':' + (config.connectorDeveloperName === null ? '' : config.connectorDeveloperName);
+}
+function keyBuilderFromType$3(luvio, object) {
+    const keyParams = {
+        connectorDeveloperName: object.connectorDeveloperName
+    };
+    return keyBuilder$f(luvio, keyParams);
+}
 function normalize$8(input, existing, path, luvio, store, timestamp) {
     const input_connections = input.connections;
     const input_connections_id = path.fullPath + '__connections';
@@ -1462,6 +1498,10 @@ const select$h = function ExternalConnectivityConnectionListRepresentationSelect
                 kind: 'Link',
                 plural: true,
                 fragment: select$i()
+            },
+            {
+                name: 'connectorDeveloperName',
+                kind: 'Scalar'
             }
         ]
     };
@@ -1477,6 +1517,11 @@ function equals$8(existing, incoming) {
     if (equals_connections_items === false) {
         return false;
     }
+    const existing_connectorDeveloperName = existing.connectorDeveloperName;
+    const incoming_connectorDeveloperName = incoming.connectorDeveloperName;
+    if (!(existing_connectorDeveloperName === incoming_connectorDeveloperName)) {
+        return false;
+    }
     return true;
 }
 const ingest$8 = function ExternalConnectivityConnectionListRepresentationIngest(input, path, luvio, store, timestamp) {
@@ -1486,14 +1531,14 @@ const ingest$8 = function ExternalConnectivityConnectionListRepresentationIngest
             throw validateError;
         }
     }
-    const key = path.fullPath;
+    const key = keyBuilderFromType$3(luvio, input);
     const ttlToUse = TTL$8;
     ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize$8, "external-connectivity", VERSION$8, RepresentationType$8, equals$8);
     return createLink(key);
 };
 function getTypeCacheKeys$8(rootKeySet, luvio, input, fullPathFactory) {
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
-    const rootKey = fullPathFactory();
+    const rootKey = keyBuilderFromType$3(luvio, input);
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
         representationName: RepresentationType$8,
@@ -1504,19 +1549,35 @@ function getTypeCacheKeys$8(rootKeySet, luvio, input, fullPathFactory) {
         getTypeCacheKeys$9(rootKeySet, luvio, input.connections[i], () => '');
     }
 }
+const notifyUpdateAvailableFactory = (luvio) => {
+    return function notifyConnectionListUpdateAvailable(configs) {
+        if (process.env.NODE_ENV !== 'production') {
+            const requiredKeyParams = ['connectorDeveloperName'];
+            configs.forEach(config => {
+                if (false === requiredKeyParams.every(req => req in config)) {
+                    throw new Error(`one of the configs did not contain all required parameters: ${JSONStringify(ObjectKeys(config))}`);
+                }
+            });
+        }
+        const keys = configs.map(c => keyBuilder$f(luvio, c));
+        return luvio.notifyStoreUpdateAvailable(keys);
+    };
+};
 
 function select$g(luvio, params) {
     return select$h();
 }
 function keyBuilder$e(luvio, params) {
-    return keyPrefix + '::ExternalConnectivityConnectionListRepresentation:(' + ')';
+    return keyBuilder$f(luvio, {
+        connectorDeveloperName: params.queryParams.connectorDeveloperName || ''
+    });
 }
 function getResponseCacheKeys$8(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys$8(storeKeyMap, luvio, response, () => keyBuilder$e());
+    getTypeCacheKeys$8(storeKeyMap, luvio, response);
 }
 function ingestSuccess$8(luvio, resourceParams, response, snapshotRefresh) {
     const { body } = response;
-    const key = keyBuilder$e();
+    const key = keyBuilder$e(luvio, resourceParams);
     luvio.storeIngest(key, ingest$8, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
@@ -1532,7 +1593,7 @@ function ingestSuccess$8(luvio, resourceParams, response, snapshotRefresh) {
     return snapshot;
 }
 function ingestError$5(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$e();
+    const key = keyBuilder$e(luvio, params);
     const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
     const storeMetadataParams = {
         ttl: TTL$8,
@@ -1551,22 +1612,25 @@ function createResourceRequest$8(config) {
         method: 'get',
         body: null,
         urlParams: {},
-        queryParams: {},
+        queryParams: config.queryParams,
         headers,
         priority: 'normal',
     };
 }
 
 const adapterName$8 = 'getConnections';
-const getConnections_ConfigPropertyMetadata = [];
+const getConnections_ConfigPropertyMetadata = [
+    generateParamConfigMetadata('connectorDeveloperName', false, 1 /* QueryParameter */, 0 /* String */),
+];
 const getConnections_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName$8, getConnections_ConfigPropertyMetadata);
 const createResourceParams$8 = /*#__PURE__*/ createResourceParams$c(getConnections_ConfigPropertyMetadata);
 function keyBuilder$d(luvio, config) {
-    createResourceParams$8(config);
-    return keyBuilder$e();
+    const resourceParams = createResourceParams$8(config);
+    return keyBuilder$e(luvio, resourceParams);
 }
 function typeCheckConfig$8(untrustedConfig) {
     const config = {};
+    typeCheckConfig$c(untrustedConfig, config, getConnections_ConfigPropertyMetadata);
     return config;
 }
 function validateAdapterConfig$8(untrustedConfig, configPropertyNames) {
@@ -1576,7 +1640,7 @@ function validateAdapterConfig$8(untrustedConfig, configPropertyNames) {
     if (process.env.NODE_ENV !== 'production') {
         validateConfig(untrustedConfig, configPropertyNames);
     }
-    const config = typeCheckConfig$8();
+    const config = typeCheckConfig$8(untrustedConfig);
     if (!areRequiredParametersPresent(config, configPropertyNames)) {
         return null;
     }
@@ -1602,7 +1666,7 @@ function onFetchResponseError$5(luvio, config, resourceParams, response) {
 }
 function buildNetworkSnapshot$8(luvio, config, options) {
     const resourceParams = createResourceParams$8(config);
-    const request = createResourceRequest$8();
+    const request = createResourceRequest$8(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
         .then((response) => {
         return luvio.handleSuccessResponse(() => onFetchResponseSuccess$5(luvio, config, resourceParams, response), () => {
@@ -3675,7 +3739,7 @@ function getResponseCacheKeys(storeKeyMap, luvio, resourceParams, response) {
 }
 function ingestSuccess(luvio, resourceParams, response) {
     const { body } = response;
-    const key = keyBuilderFromType$3(luvio, body);
+    const key = keyBuilderFromType$4(luvio, body);
     luvio.storeIngest(key, ingest$c, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
@@ -3830,6 +3894,7 @@ const getInvocableActionsMetadata = {
     ttl: 500,
 };
 // Notify Update Available
+let notifyConnectionListUpdateAvailable;
 function bindExportsTo(luvio) {
     // LDS Adapters
     const getConnectionDetails_ldsAdapter = createInstrumentedAdapter(createLDSAdapter(luvio, 'getConnectionDetails', getConnectionDetailsAdapterFactory), getConnectionDetailsMetadata);
@@ -3865,6 +3930,7 @@ function bindExportsTo(luvio) {
         getExternalIdentityProviders_imperative: createImperativeAdapter(luvio, getExternalIdentityProviders_ldsAdapter, getExternalIdentityProvidersMetadata),
         getInvocableActions_imperative: createImperativeAdapter(luvio, getInvocableActions_ldsAdapter, getInvocableActionsMetadata),
         // Notify Update Availables
+        notifyConnectionListUpdateAvailable: createLDSAdapter(luvio, 'notifyConnectionListUpdateAvailable', notifyUpdateAvailableFactory),
     };
 }
 withDefaultLuvio((luvio) => {
@@ -3888,8 +3954,9 @@ withDefaultLuvio((luvio) => {
         getExternalConnectivityConnectionReferencedFlows_imperative,
         getExternalIdentityProviders_imperative,
         getInvocableActions_imperative,
+        notifyConnectionListUpdateAvailable,
     } = bindExportsTo(luvio));
 });
 
-export { createConnection, deleteConnection, getConnectionDetails, getConnectionDetails_imperative, getConnections, getConnections_imperative, getConnectorDetails, getConnectorDetails_imperative, getConnectors, getConnectors_imperative, getExternalConnectivityConnectionReferencedFlows, getExternalConnectivityConnectionReferencedFlows_imperative, getExternalIdentityProviders, getExternalIdentityProviders_imperative, getInvocableActions, getInvocableActions_imperative, refreshMetadata, testConnection, updateConnection };
-// version: 1.364.0-a541a03c7e
+export { createConnection, deleteConnection, getConnectionDetails, getConnectionDetails_imperative, getConnections, getConnections_imperative, getConnectorDetails, getConnectorDetails_imperative, getConnectors, getConnectors_imperative, getExternalConnectivityConnectionReferencedFlows, getExternalConnectivityConnectionReferencedFlows_imperative, getExternalIdentityProviders, getExternalIdentityProviders_imperative, getInvocableActions, getInvocableActions_imperative, notifyConnectionListUpdateAvailable, refreshMetadata, testConnection, updateConnection };
+// version: 1.366.0-bf15f04cce

package/src/raml/api.raml

@@ -234,6 +234,9 @@ types:
         type: array
         items:
           type: ExternalConnectivityConnectionRepresentation
+      connectorDeveloperName:
+        description: The Connector developer name for a filtered list of connections.
+        type: string | nil
   ExternalConnectivityConnectionReferencedFlowsDefinitionRepresentation:
     description: Output representation for flow definition referencing External Connectivity Connection
     type: object
@@ -502,6 +505,10 @@ types:
           body:
             application/json:
               type: ExternalConnectivityConnectionListRepresentation
+      queryParameters:
+        connectorDeveloperName:
+          type: string
+          required: false
     post:
       displayName: postExternalConnectivityConnectionList
       description: POST method to create External Connectivity Connection

package/src/raml/luvio.raml

@@ -21,6 +21,12 @@ types:
       developerName: developerName
   ExternalConnectivityConnectionListRepresentation:
     (luvio.ttl): 500
+    (luvio.key):
+      connectorDeveloperName: connectorDeveloperName
+    (luvio.updateAvailable):
+      name: notifyConnectionListUpdateAvailable
+      parameters:
+        connectorDeveloperName: connectorDeveloperName
   ExternalConnectivityConnectionReferencedFlowsDefinitionRepresentation:
     (luvio.ttl): 500
   ExternalConnectivityConnectionReferencedFlowsRepresentation:
@@ -61,6 +67,8 @@ types:
   get:
     (luvio.adapter):
       name: getConnections
+    (luvio.key):
+      connectorDeveloperName: queryParams.connectorDeveloperName || ''
   post:
     (luvio.adapter):
       name: createConnection