@gemeentenijmegen/webapp 1.0.1 → 1.1.1

package/node_modules/@aws-solutions-constructs/aws-lambda-dynamodb/node_modules/@aws-cdk/integ-tests-alpha/lib/assertions/providers/lambda-handler/index.d.ts

@@ -0,0 +1,14 @@
+export declare function handler(event: AWSLambda.CloudFormationCustomResourceEvent, context: AWSLambda.Context): Promise<void>;
+/**
+ * Invoked by the waiter statemachine when the retry
+ * attempts are exhausted
+ */
+export declare function onTimeout(timeoutEvent: any): Promise<void>;
+/**
+ * Invoked by the waiter statemachine when the user is waiting for a specific
+ * result.
+ *
+ * If the result of the assertion is not successful then it will throw an error
+ * which will cause the state machine to try again
+ */
+export declare function isComplete(event: AWSLambda.CloudFormationCustomResourceEvent, context: AWSLambda.Context): Promise<void>;

package/node_modules/@aws-solutions-constructs/aws-lambda-dynamodb/node_modules/@aws-cdk/integ-tests-alpha/lib/assertions/providers/lambda-handler/index.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isComplete = exports.onTimeout = exports.handler = void 0;
+/* eslint-disable no-console */
+const assertion_1 = require("./assertion");
+const http_1 = require("./http");
+const sdk_1 = require("./sdk");
+const types = require("./types");
+async function handler(event, context) {
+    console.log(`Event: ${JSON.stringify({ ...event, ResponseURL: '...' })}`);
+    const provider = createResourceHandler(event, context);
+    try {
+        // if we are deleting the custom resource, just respond
+        // with 'SUCCESS' since there is nothing to do.
+        if (event.RequestType === 'Delete') {
+            await provider.respond({
+                status: 'SUCCESS',
+                reason: 'OK',
+            });
+            return;
+        }
+        const result = await provider.handle();
+        // if there is a `stateMachineArn` then we have already started a state machine
+        // execution and the rest will be handled there
+        if ('stateMachineArn' in event.ResourceProperties) {
+            console.info('Found "stateMachineArn", waiter statemachine started');
+            return;
+        }
+        else if ('expected' in event.ResourceProperties) {
+            console.info('Found "expected", testing assertions');
+            const actualPath = event.ResourceProperties.actualPath;
+            // if we are providing a path to make the assertion at, that means that we have
+            // flattened the response, otherwise the path to assert against in the entire response
+            const actual = actualPath ? result[`apiCallResponse.${actualPath}`] : result.apiCallResponse;
+            const assertion = new assertion_1.AssertionHandler({
+                ...event,
+                ResourceProperties: {
+                    ServiceToken: event.ServiceToken,
+                    actual,
+                    expected: event.ResourceProperties.expected,
+                },
+            }, context);
+            try {
+                const assertionResult = await assertion.handle();
+                await provider.respond({
+                    status: 'SUCCESS',
+                    reason: 'OK',
+                    // return both the result of the API call _and_ the assertion results
+                    data: {
+                        ...assertionResult,
+                        ...result,
+                    },
+                });
+                return;
+            }
+            catch (e) {
+                await provider.respond({
+                    status: 'FAILED',
+                    reason: e.message ?? 'Internal Error',
+                });
+                return;
+            }
+        }
+        await provider.respond({
+            status: 'SUCCESS',
+            reason: 'OK',
+            data: result,
+        });
+    }
+    catch (e) {
+        await provider.respond({
+            status: 'FAILED',
+            reason: e.message ?? 'Internal Error',
+        });
+        return;
+    }
+    return;
+}
+exports.handler = handler;
+/**
+ * Invoked by the waiter statemachine when the retry
+ * attempts are exhausted
+ */
+async function onTimeout(timeoutEvent) {
+    // the event payload is passed through the `errorMessage` in the state machine
+    // timeout event
+    const isCompleteRequest = JSON.parse(JSON.parse(timeoutEvent.Cause).errorMessage);
+    const provider = createResourceHandler(isCompleteRequest, standardContext);
+    await provider.respond({
+        status: 'FAILED',
+        reason: 'Operation timed out: ' + JSON.stringify(isCompleteRequest),
+    });
+}
+exports.onTimeout = onTimeout;
+/**
+ * Invoked by the waiter statemachine when the user is waiting for a specific
+ * result.
+ *
+ * If the result of the assertion is not successful then it will throw an error
+ * which will cause the state machine to try again
+ */
+async function isComplete(event, context) {
+    console.log(`Event: ${JSON.stringify({ ...event, ResponseURL: '...' })}`);
+    const provider = createResourceHandler(event, context);
+    try {
+        const result = await provider.handleIsComplete();
+        const actualPath = event.ResourceProperties.actualPath;
+        if (result) {
+            const actual = actualPath ? result[`apiCallResponse.${actualPath}`] : result.apiCallResponse;
+            if ('expected' in event.ResourceProperties) {
+                const assertion = new assertion_1.AssertionHandler({
+                    ...event,
+                    ResourceProperties: {
+                        ServiceToken: event.ServiceToken,
+                        actual,
+                        expected: event.ResourceProperties.expected,
+                    },
+                }, context);
+                const assertionResult = await assertion.handleIsComplete();
+                if (!(assertionResult?.failed)) {
+                    await provider.respond({
+                        status: 'SUCCESS',
+                        reason: 'OK',
+                        data: {
+                            ...assertionResult,
+                            ...result,
+                        },
+                    });
+                    return;
+                }
+                else {
+                    console.log(`Assertion Failed: ${JSON.stringify(assertionResult)}`);
+                    throw new Error(JSON.stringify(event));
+                }
+            }
+            await provider.respond({
+                status: 'SUCCESS',
+                reason: 'OK',
+                data: result,
+            });
+        }
+        else {
+            console.log('No result');
+            throw new Error(JSON.stringify(event));
+        }
+        return;
+    }
+    catch (e) {
+        console.log(e);
+        throw new Error(JSON.stringify(event));
+    }
+}
+exports.isComplete = isComplete;
+function createResourceHandler(event, context) {
+    if (event.ResourceType.startsWith(types.SDK_RESOURCE_TYPE_PREFIX)) {
+        return new sdk_1.AwsApiCallHandler(event, context);
+    }
+    else if (event.ResourceType.startsWith(types.ASSERT_RESOURCE_TYPE)) {
+        return new assertion_1.AssertionHandler(event, context);
+    }
+    else if (event.ResourceType.startsWith(types.HTTP_RESOURCE_TYPE)) {
+        return new http_1.HttpHandler(event, context);
+    }
+    else {
+        throw new Error(`Unsupported resource type "${event.ResourceType}`);
+    }
+}
+const standardContext = {
+    getRemainingTimeInMillis: () => 90000,
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable no-console */\nimport { AssertionHandler } from './assertion';\nimport { HttpHandler } from './http';\nimport { AwsApiCallHandler } from './sdk';\nimport * as types from './types';\n\nexport async function handler(event: AWSLambda.CloudFormationCustomResourceEvent, context: AWSLambda.Context) {\n  console.log(`Event: ${JSON.stringify({ ...event, ResponseURL: '...' })}`);\n  const provider = createResourceHandler(event, context);\n  try {\n    // if we are deleting the custom resource, just respond\n    // with 'SUCCESS' since there is nothing to do.\n    if (event.RequestType === 'Delete') {\n      await provider.respond({\n        status: 'SUCCESS',\n        reason: 'OK',\n      });\n      return;\n    }\n    const result = await provider.handle();\n    // if there is a `stateMachineArn` then we have already started a state machine\n    // execution and the rest will be handled there\n    if ('stateMachineArn' in event.ResourceProperties) {\n      console.info('Found \"stateMachineArn\", waiter statemachine started');\n      return;\n    } else if ('expected' in event.ResourceProperties) {\n      console.info('Found \"expected\", testing assertions');\n      const actualPath = event.ResourceProperties.actualPath;\n      // if we are providing a path to make the assertion at, that means that we have\n      // flattened the response, otherwise the path to assert against in the entire response\n      const actual = actualPath ? (result as { [key: string]: string })[`apiCallResponse.${actualPath}`] : (result as types.AwsApiCallResult).apiCallResponse;\n      const assertion = new AssertionHandler({\n        ...event,\n        ResourceProperties: {\n          ServiceToken: event.ServiceToken,\n          actual,\n          expected: event.ResourceProperties.expected,\n        },\n      }, context);\n      try {\n        const assertionResult = await assertion.handle();\n        await provider.respond({\n          status: 'SUCCESS',\n          reason: 'OK',\n          // return both the result of the API call _and_ the assertion results\n          data: {\n            ...assertionResult,\n            ...result,\n          },\n        });\n        return;\n      } catch (e: any) {\n        await provider.respond({\n          status: 'FAILED',\n          reason: e.message ?? 'Internal Error',\n        });\n        return;\n      }\n    }\n    await provider.respond({\n      status: 'SUCCESS',\n      reason: 'OK',\n      data: result,\n    });\n  } catch (e: any) {\n    await provider.respond({\n      status: 'FAILED',\n      reason: e.message ?? 'Internal Error',\n    });\n    return;\n  }\n  return;\n}\n\n/**\n * Invoked by the waiter statemachine when the retry\n * attempts are exhausted\n */\nexport async function onTimeout(timeoutEvent: any) {\n  // the event payload is passed through the `errorMessage` in the state machine\n  // timeout event\n  const isCompleteRequest = JSON.parse(JSON.parse(timeoutEvent.Cause).errorMessage);\n  const provider = createResourceHandler(isCompleteRequest, standardContext);\n  await provider.respond({\n    status: 'FAILED',\n    reason: 'Operation timed out: ' + JSON.stringify(isCompleteRequest),\n  });\n}\n\n/**\n * Invoked by the waiter statemachine when the user is waiting for a specific\n * result.\n *\n * If the result of the assertion is not successful then it will throw an error\n * which will cause the state machine to try again\n */\nexport async function isComplete(event: AWSLambda.CloudFormationCustomResourceEvent, context: AWSLambda.Context) {\n  console.log(`Event: ${JSON.stringify({ ...event, ResponseURL: '...' })}`);\n  const provider = createResourceHandler(event, context);\n  try {\n    const result = await provider.handleIsComplete();\n    const actualPath = event.ResourceProperties.actualPath;\n    if (result) {\n      const actual = actualPath ? (result as { [key: string]: string })[`apiCallResponse.${actualPath}`] : (result as types.AwsApiCallResult).apiCallResponse;\n      if ('expected' in event.ResourceProperties) {\n        const assertion = new AssertionHandler({\n          ...event,\n          ResourceProperties: {\n            ServiceToken: event.ServiceToken,\n            actual,\n            expected: event.ResourceProperties.expected,\n          },\n        }, context);\n        const assertionResult = await assertion.handleIsComplete();\n        if (!(assertionResult?.failed)) {\n          await provider.respond({\n            status: 'SUCCESS',\n            reason: 'OK',\n            data: {\n              ...assertionResult,\n              ...result,\n            },\n          });\n          return;\n        } else {\n          console.log(`Assertion Failed: ${JSON.stringify(assertionResult)}`);\n          throw new Error(JSON.stringify(event));\n        }\n      }\n      await provider.respond({\n        status: 'SUCCESS',\n        reason: 'OK',\n        data: result,\n      });\n    } else {\n      console.log('No result');\n      throw new Error(JSON.stringify(event));\n    }\n    return;\n  } catch (e) {\n    console.log(e);\n    throw new Error(JSON.stringify(event));\n  }\n}\n\nfunction createResourceHandler(event: AWSLambda.CloudFormationCustomResourceEvent, context: AWSLambda.Context) {\n  if (event.ResourceType.startsWith(types.SDK_RESOURCE_TYPE_PREFIX)) {\n    return new AwsApiCallHandler(event, context);\n  } else if (event.ResourceType.startsWith(types.ASSERT_RESOURCE_TYPE)) {\n    return new AssertionHandler(event, context);\n  } else if (event.ResourceType.startsWith(types.HTTP_RESOURCE_TYPE)) {\n    return new HttpHandler(event, context);\n  } else {\n    throw new Error(`Unsupported resource type \"${event.ResourceType}`);\n  }\n}\n\nconst standardContext: any = {\n  getRemainingTimeInMillis: () => 90000,\n};\n"]}

package/node_modules/@aws-solutions-constructs/aws-lambda-dynamodb/node_modules/@aws-cdk/integ-tests-alpha/lib/assertions/providers/lambda-handler/sdk.d.ts

@@ -0,0 +1,9 @@
+import { CustomResourceHandler } from './base';
+import { AwsApiCallRequest, AwsApiCallResult } from './types';
+export declare class AwsApiCallHandler extends CustomResourceHandler<AwsApiCallRequest, AwsApiCallResult | {
+    [key: string]: unknown;
+}> {
+    protected processEvent(request: AwsApiCallRequest): Promise<AwsApiCallResult | {
+        [key: string]: unknown;
+    } | undefined>;
+}

package/node_modules/@aws-solutions-constructs/aws-lambda-dynamodb/node_modules/@aws-cdk/integ-tests-alpha/lib/assertions/providers/lambda-handler/sdk.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AwsApiCallHandler = void 0;
+/* eslint-disable no-console */
+const base_1 = require("./base");
+const aws_custom_resource_sdk_adapter_1 = require("@aws-cdk/aws-custom-resource-sdk-adapter");
+const utils_1 = require("./utils");
+class AwsApiCallHandler extends base_1.CustomResourceHandler {
+    async processEvent(request) {
+        const apiCall = new aws_custom_resource_sdk_adapter_1.ApiCall(request.service, request.api);
+        const parameters = request.parameters ? (0, utils_1.decodeParameters)(request.parameters) : {};
+        console.log(`SDK request to ${apiCall.service}.${apiCall.action} with parameters ${JSON.stringify(parameters)}`);
+        const response = await apiCall.invoke({ parameters });
+        console.log(`SDK response received ${JSON.stringify(response)}`);
+        delete response.$metadata;
+        let resp;
+        if (request.outputPaths || request.flattenResponse === 'true') {
+            // Flatten and explode JSON fields
+            const flattened = (0, aws_custom_resource_sdk_adapter_1.flatten)((0, utils_1.deepParseJson)({ apiCallResponse: response }));
+            resp = request.outputPaths ? filterKeys(flattened, request.outputPaths) : flattened;
+        }
+        else {
+            // Otherwise just return the response as-is, without exploding JSON fields
+            resp = { apiCallResponse: response };
+        }
+        console.log(`Returning result ${JSON.stringify(resp)}`);
+        return resp;
+    }
+}
+exports.AwsApiCallHandler = AwsApiCallHandler;
+function filterKeys(object, searchStrings) {
+    return Object.entries(object).reduce((filteredObject, [key, value]) => {
+        for (const searchString of searchStrings) {
+            if (key.startsWith(`apiCallResponse.${searchString}`)) {
+                filteredObject[key] = value;
+            }
+        }
+        return filteredObject;
+    }, {});
+}
+//# sourceMappingURL=data:application/json;base64,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

package/node_modules/@aws-solutions-constructs/aws-lambda-dynamodb/node_modules/@aws-cdk/integ-tests-alpha/lib/assertions/providers/lambda-handler/types.d.ts

@@ -0,0 +1,235 @@
+export declare const ASSERT_RESOURCE_TYPE = "Custom::DeployAssert@AssertEquals";
+export declare const SDK_RESOURCE_TYPE_PREFIX = "Custom::DeployAssert@SdkCall";
+export declare const HTTP_RESOURCE_TYPE = "Custom::DeployAssert@HttpCall";
+export interface HttpRequestParameters {
+    /**
+     * The url to fetch
+     */
+    readonly url: string;
+    /**
+     * Options for fetch
+     */
+    readonly fetchOptions?: FetchOptions;
+}
+/**
+ * Request to the HttpCall resource
+ */
+export interface HttpRequest {
+    /**
+     * Parameters from the custom resource
+     */
+    readonly parameters: HttpRequestParameters;
+}
+/**
+ * Options to pass to the JavaScript fetch api
+ */
+export interface FetchOptions {
+    /**
+     * Request body
+     *
+     * @default - no body
+     */
+    readonly body?: string;
+    /**
+     * Optional port
+     *
+     * @default default port for protocol
+     */
+    readonly port?: number;
+    /**
+     * HTTP method
+     *
+     * @default GET
+     */
+    readonly method?: string;
+    /**
+     * Optional request headers
+     *
+     * @default no headers
+     */
+    readonly headers?: {
+        [key: string]: string;
+    };
+}
+/**
+ * Response from the HttpCall resource
+ */
+export interface HttpResponseWrapper {
+    /**
+     * The Response from the fetch request
+     */
+    readonly apiCallResponse: HttpResponse;
+}
+/**
+ * Response from fetch
+ */
+export interface HttpResponse {
+    /**
+     * Indicates whether the response was successful
+     *
+     * status range 200-299
+     */
+    readonly ok?: boolean;
+    /**
+     * Status code of the response
+     */
+    readonly status?: number;
+    /**
+     * The status message corresponding to the status code
+     */
+    readonly statusText?: string;
+    /**
+     * The response, either as parsed JSON or a string literal.
+     */
+    readonly body?: any;
+    /**
+     * Headers associated with the response
+     */
+    readonly headers?: {
+        [name: string]: any;
+    };
+}
+/**
+ * A AWS JavaScript SDK V2 request
+ */
+export interface AwsApiCallRequest {
+    /**
+     * The AWS service i.e. S3
+     */
+    readonly service: string;
+    /**
+     * The AWS api call to make i.e. getBucketLifecycle
+     */
+    readonly api: string;
+    /**
+     * Any parameters to pass to the api call
+     *
+     * @default - no parameters
+     */
+    readonly parameters?: any;
+    /**
+     * Whether or not to flatten the response from the api call
+     *
+     * Valid values are 'true' or 'false' as strings
+     *
+     * Typically when using an SdkRequest you will be passing it as the
+     * `actual` value to an assertion provider so this would be set
+     * to 'false' (you want the actual response).
+     *
+     * If you are using the SdkRequest to perform more of a query to return
+     * a single value to use, then this should be set to 'true'. For example,
+     * you could make a StepFunctions.startExecution api call and retreive the
+     * `executionArn` from the response.
+     *
+     * @default 'false'
+     */
+    readonly flattenResponse?: string;
+    /**
+     * Restrict the data returned by the API call to specific paths in
+     * the API response. Use this to limit the data returned by the custom
+     * resource if working with API calls that could potentially result in custom
+     * response objects exceeding the hard limit of 4096 bytes.
+     *
+     * @default - return all data
+     */
+    readonly outputPaths?: string[];
+}
+/**
+ * The result from a SdkQuery
+ */
+export interface AwsApiCallResult {
+    /**
+     * The full api response
+     */
+    readonly apiCallResponse: any;
+}
+/**
+ * The type of assertion to perform
+ */
+export declare enum AssertionType {
+    /**
+     * Assert that two values are equal
+     */
+    EQUALS = "equals",
+    /**
+     * The keys and their values must be present in the target but the target
+     * can be a superset.
+     */
+    OBJECT_LIKE = "objectLike",
+    /**
+     * Matches the specified pattern with the array
+     * The set of elements must be in the same order as would be found
+     */
+    ARRAY_WITH = "arrayWith"
+}
+/**
+ * A request to make an assertion that the
+ * actual value matches the expected
+ */
+export interface AssertionRequest {
+    /**
+     * The expected value to assert
+     */
+    readonly expected: any;
+    /**
+     * The actual value received
+     */
+    readonly actual: any;
+    /**
+     * Set this to true if a failed assertion should
+     * result in a CloudFormation deployment failure
+     *
+     * This is only necessary if assertions are being
+     * executed outside of `integ-runner`.
+     *
+     * @default false
+     */
+    readonly failDeployment?: boolean;
+}
+/**
+ * The result of an Assertion
+ * wrapping the actual result data in another struct.
+ * Needed to access the whole message via getAtt() on the custom resource.
+ */
+export interface AssertionResult {
+    /**
+     * The result of an assertion
+     */
+    readonly assertion: string;
+    /**
+     * Whether or not the assertion failed
+     *
+     * @default false
+     */
+    readonly failed?: boolean;
+}
+/**
+ * The status of the assertion
+ */
+export declare enum Status {
+    /**
+     * The assertion passed
+     */
+    PASS = "pass",
+    /**
+     * The assertion failed
+     */
+    FAIL = "fail"
+}
+/**
+ * The result of an assertion
+ */
+export interface AssertionResultData {
+    /**
+     * The status of the assertion, i.e.
+     * pass or fail
+     */
+    readonly status: Status;
+    /**
+     * Any message returned with the assertion result
+     * typically this will be the diff if there is any
+     *
+     * @default - none
+     */
+    readonly message?: string;
+}

package/node_modules/@aws-solutions-constructs/aws-lambda-dynamodb/node_modules/@aws-cdk/integ-tests-alpha/lib/assertions/providers/lambda-handler/types.js

@@ -0,0 +1,43 @@
+"use strict";
+// This file contains the input and output types for the providers.
+// Kept in a separate file for sharing between the handler and the provider constructs.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Status = exports.AssertionType = exports.HTTP_RESOURCE_TYPE = exports.SDK_RESOURCE_TYPE_PREFIX = exports.ASSERT_RESOURCE_TYPE = void 0;
+exports.ASSERT_RESOURCE_TYPE = 'Custom::DeployAssert@AssertEquals';
+exports.SDK_RESOURCE_TYPE_PREFIX = 'Custom::DeployAssert@SdkCall';
+exports.HTTP_RESOURCE_TYPE = 'Custom::DeployAssert@HttpCall';
+/**
+ * The type of assertion to perform
+ */
+var AssertionType;
+(function (AssertionType) {
+    /**
+     * Assert that two values are equal
+     */
+    AssertionType["EQUALS"] = "equals";
+    /**
+     * The keys and their values must be present in the target but the target
+     * can be a superset.
+     */
+    AssertionType["OBJECT_LIKE"] = "objectLike";
+    /**
+     * Matches the specified pattern with the array
+     * The set of elements must be in the same order as would be found
+     */
+    AssertionType["ARRAY_WITH"] = "arrayWith";
+})(AssertionType || (exports.AssertionType = AssertionType = {}));
+/**
+ * The status of the assertion
+ */
+var Status;
+(function (Status) {
+    /**
+     * The assertion passed
+     */
+    Status["PASS"] = "pass";
+    /**
+     * The assertion failed
+     */
+    Status["FAIL"] = "fail";
+})(Status || (exports.Status = Status = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["types.ts"],"names":[],"mappings":";AAAA,mEAAmE;AACnE,uFAAuF;;;AAE1E,QAAA,oBAAoB,GAAG,mCAAmC,CAAC;AAC3D,QAAA,wBAAwB,GAAG,8BAA8B,CAAC;AAC1D,QAAA,kBAAkB,GAAG,+BAA+B,CAAC;AA+JlE;;GAEG;AACH,IAAY,aAiBX;AAjBD,WAAY,aAAa;IACvB;;OAEG;IACH,kCAAiB,CAAA;IAEjB;;;OAGG;IACH,2CAA0B,CAAA;IAE1B;;;OAGG;IACH,yCAAwB,CAAA;AAC1B,CAAC,EAjBW,aAAa,6BAAb,aAAa,QAiBxB;AA+CD;;GAEG;AACH,IAAY,MAUX;AAVD,WAAY,MAAM;IAChB;;OAEG;IACH,uBAAa,CAAA;IAEb;;OAEG;IACH,uBAAa,CAAA;AACf,CAAC,EAVW,MAAM,sBAAN,MAAM,QAUjB","sourcesContent":["// This file contains the input and output types for the providers.\n// Kept in a separate file for sharing between the handler and the provider constructs.\n\nexport const ASSERT_RESOURCE_TYPE = 'Custom::DeployAssert@AssertEquals';\nexport const SDK_RESOURCE_TYPE_PREFIX = 'Custom::DeployAssert@SdkCall';\nexport const HTTP_RESOURCE_TYPE = 'Custom::DeployAssert@HttpCall';\n\nexport interface HttpRequestParameters {\n  /**\n   * The url to fetch\n   */\n  readonly url: string;\n\n  /**\n   * Options for fetch\n   */\n  readonly fetchOptions?: FetchOptions;\n}\n\n/**\n * Request to the HttpCall resource\n */\nexport interface HttpRequest {\n  /**\n   * Parameters from the custom resource\n   */\n  readonly parameters: HttpRequestParameters;\n}\n\n/**\n * Options to pass to the JavaScript fetch api\n */\nexport interface FetchOptions {\n  /**\n   * Request body\n   *\n   * @default - no body\n   */\n  readonly body?: string;\n\n  /**\n   * Optional port\n   *\n   * @default default port for protocol\n   */\n  readonly port?: number;\n\n  /**\n   * HTTP method\n   *\n   * @default GET\n   */\n  readonly method?: string;\n\n  /**\n   * Optional request headers\n   *\n   * @default no headers\n   */\n  readonly headers?: { [key: string]: string };\n}\n\n/**\n * Response from the HttpCall resource\n */\nexport interface HttpResponseWrapper {\n  /**\n   * The Response from the fetch request\n   */\n  readonly apiCallResponse: HttpResponse;\n}\n\n/**\n * Response from fetch\n */\nexport interface HttpResponse {\n  /**\n   * Indicates whether the response was successful\n   *\n   * status range 200-299\n   */\n  readonly ok?: boolean;\n\n  /**\n   * Status code of the response\n   */\n  readonly status?: number;\n\n  /**\n   * The status message corresponding to the status code\n   */\n  readonly statusText?: string;\n\n  /**\n   * The response, either as parsed JSON or a string literal.\n   */\n  readonly body?: any;\n\n  /**\n   * Headers associated with the response\n   */\n  readonly headers?: { [name: string]: any };\n}\n\n/**\n * A AWS JavaScript SDK V2 request\n */\nexport interface AwsApiCallRequest {\n  /**\n   * The AWS service i.e. S3\n   */\n  readonly service: string;\n\n  /**\n   * The AWS api call to make i.e. getBucketLifecycle\n   */\n  readonly api: string;\n\n  /**\n   * Any parameters to pass to the api call\n   *\n   * @default - no parameters\n   */\n  readonly parameters?: any;\n\n  /**\n   * Whether or not to flatten the response from the api call\n   *\n   * Valid values are 'true' or 'false' as strings\n   *\n   * Typically when using an SdkRequest you will be passing it as the\n   * `actual` value to an assertion provider so this would be set\n   * to 'false' (you want the actual response).\n   *\n   * If you are using the SdkRequest to perform more of a query to return\n   * a single value to use, then this should be set to 'true'. For example,\n   * you could make a StepFunctions.startExecution api call and retreive the\n   * `executionArn` from the response.\n   *\n   * @default 'false'\n   */\n  readonly flattenResponse?: string;\n\n  /**\n   * Restrict the data returned by the API call to specific paths in\n   * the API response. Use this to limit the data returned by the custom\n   * resource if working with API calls that could potentially result in custom\n   * response objects exceeding the hard limit of 4096 bytes.\n   *\n   * @default - return all data\n   */\n  readonly outputPaths?: string[];\n}\n\n/**\n * The result from a SdkQuery\n */\nexport interface AwsApiCallResult {\n  /**\n   * The full api response\n   */\n  readonly apiCallResponse: any;\n}\n\n/**\n * The type of assertion to perform\n */\nexport enum AssertionType {\n  /**\n   * Assert that two values are equal\n   */\n  EQUALS = 'equals',\n\n  /**\n   * The keys and their values must be present in the target but the target\n   * can be a superset.\n   */\n  OBJECT_LIKE = 'objectLike',\n\n  /**\n   * Matches the specified pattern with the array\n   * The set of elements must be in the same order as would be found\n   */\n  ARRAY_WITH = 'arrayWith',\n}\n\n/**\n * A request to make an assertion that the\n * actual value matches the expected\n */\nexport interface AssertionRequest {\n  /**\n   * The expected value to assert\n   */\n  readonly expected: any;\n\n  /**\n   * The actual value received\n   */\n  readonly actual: any;\n\n  /**\n   * Set this to true if a failed assertion should\n   * result in a CloudFormation deployment failure\n   *\n   * This is only necessary if assertions are being\n   * executed outside of `integ-runner`.\n   *\n   * @default false\n   */\n  readonly failDeployment?: boolean;\n}\n/**\n * The result of an Assertion\n * wrapping the actual result data in another struct.\n * Needed to access the whole message via getAtt() on the custom resource.\n */\nexport interface AssertionResult {\n/**\n * The result of an assertion\n */\n  readonly assertion: string;\n\n  /**\n   * Whether or not the assertion failed\n   *\n   * @default false\n   */\n  readonly failed?: boolean;\n}\n\n/**\n * The status of the assertion\n */\nexport enum Status {\n  /**\n   * The assertion passed\n   */\n  PASS = 'pass',\n\n  /**\n   * The assertion failed\n   */\n  FAIL = 'fail',\n}\n\n/**\n * The result of an assertion\n */\nexport interface AssertionResultData {\n  /**\n   * The status of the assertion, i.e.\n   * pass or fail\n   */\n  readonly status: Status;\n\n  /**\n   * Any message returned with the assertion result\n   * typically this will be the diff if there is any\n   *\n   * @default - none\n   */\n  readonly message?: string;\n}\n"]}

package/node_modules/@aws-solutions-constructs/aws-lambda-dynamodb/node_modules/@aws-cdk/integ-tests-alpha/lib/assertions/providers/lambda-handler/utils.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Recurse into the given object, trying to parse any string as JSON
+ */
+export declare function deepParseJson<A extends string>(x: A): unknown;
+export declare function deepParseJson<A extends object>(x: A): A;
+export declare function decodeParameters(obj: Record<string, any>): any;

package/node_modules/@aws-solutions-constructs/aws-lambda-dynamodb/node_modules/@aws-cdk/integ-tests-alpha/lib/assertions/providers/lambda-handler/utils.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeParameters = exports.deepParseJson = void 0;
+function deepParseJson(x) {
+    if (typeof x === 'string') {
+        return tryJsonParse(x);
+    }
+    if (Array.isArray(x)) {
+        return x.map(deepParseJson);
+    }
+    if (x && typeof x === 'object') {
+        for (const [key, value] of Object.entries(x)) {
+            x[key] = deepParseJson(value);
+        }
+        return x;
+    }
+    return x;
+}
+exports.deepParseJson = deepParseJson;
+function tryJsonParse(v) {
+    if (typeof (v) !== 'string') {
+        return v;
+    }
+    try {
+        return JSON.parse(v);
+    }
+    catch {
+        return v;
+    }
+}
+function decodeParameters(obj) {
+    return Object.fromEntries(Object.entries(obj).map(([key, value]) => {
+        try {
+            return [key, decodeValue(value)];
+        }
+        catch {
+            // if the value cannot be parsed, leave it unchanged
+            // this will end up as a string
+            return [key, value];
+        }
+    }));
+}
+exports.decodeParameters = decodeParameters;
+function decodeValue(value) {
+    if (value != null && !Array.isArray(value) && typeof value === 'object') {
+        if (value.$type === 'ArrayBufferView') {
+            return new TextEncoder().encode(value.string);
+        }
+    }
+    return JSON.parse(value);
+}
+//# sourceMappingURL=data:application/json;base64,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