@gemeentenijmegen/webapp 1.0.1 → 1.1.0

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

@@ -0,0 +1,43 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Match = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+/**
+ * Partial and special matching during assertions.
+ */
+class Match {
+    /**
+     * Matches the specified pattern with the array found in the same relative path of the target.
+     * The set of elements (or matchers) must be in the same order as would be found.
+     * @param pattern the pattern to match
+     */
+    static arrayWith(pattern) {
+        return { $ArrayWith: pattern };
+    }
+    /**
+     * Matches the specified pattern to an object found in the same relative path of the target.
+     * The keys and their values (or matchers) must be present in the target but the target can be a superset.
+     * @param pattern the pattern to match
+     */
+    static objectLike(pattern) {
+        return { $ObjectLike: pattern };
+    }
+    /**
+     * Matches targets according to a regular expression
+     */
+    static stringLikeRegexp(pattern) {
+        return { $StringLike: pattern };
+    }
+    /**
+     * Matches any string-encoded JSON and applies the specified pattern after parsing it.
+     * @param pattern the pattern to match after parsing the encoded JSON.
+     */
+    static serializedJson(pattern) {
+        return { $SerializedJson: pattern };
+    }
+}
+exports.Match = Match;
+_a = JSII_RTTI_SYMBOL_1;
+Match[_a] = { fqn: "@aws-cdk/integ-tests-alpha.Match", version: "2.160.0-alpha.0" };
+//# 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/private/deploy-assert.d.ts

@@ -0,0 +1,43 @@
+import { Stack } from 'aws-cdk-lib/core';
+import { Construct, IConstruct } from 'constructs';
+import { IApiCall } from '../api-call-base';
+import { ActualResult, ExpectedResult } from '../common';
+import { FetchOptions } from '../providers';
+import { LambdaInvokeFunctionProps } from '../sdk';
+import { IDeployAssert } from '../types';
+/**
+ * Options for DeployAssert
+ */
+export interface DeployAssertProps {
+    /**
+     * A stack to use for assertions
+     *
+     * @default - a stack is created for you
+     */
+    readonly stack?: Stack;
+}
+/**
+ * Construct that allows for registering a list of assertions
+ * that should be performed on a construct
+ */
+export declare class DeployAssert extends Construct implements IDeployAssert {
+    /**
+     * Returns whether the construct is a DeployAssert construct
+     */
+    static isDeployAssert(x: any): x is DeployAssert;
+    /**
+     * Finds a DeployAssert construct in the given scope
+     */
+    static of(construct: IConstruct): DeployAssert;
+    scope: Stack;
+    private assertionIdCounts;
+    constructor(scope: Construct, props?: DeployAssertProps);
+    awsApiCall(service: string, api: string, parameters?: any, outputPaths?: string[]): IApiCall;
+    httpApiCall(url: string, options?: FetchOptions): IApiCall;
+    invokeFunction(props: LambdaInvokeFunctionProps): IApiCall;
+    expect(id: string, expected: ExpectedResult, actual: ActualResult): void;
+    /**
+     * Gets a unique logical id based on a proposed assertion id.
+     */
+    private uniqueAssertionId;
+}

package/node_modules/@aws-solutions-constructs/aws-lambda-dynamodb/node_modules/@aws-cdk/integ-tests-alpha/lib/assertions/private/deploy-assert.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeployAssert = void 0;
+const core_1 = require("aws-cdk-lib/core");
+const constructs_1 = require("constructs");
+const assertions_1 = require("../assertions");
+const http_call_1 = require("../http-call");
+const hash_1 = require("../private/hash");
+const sdk_1 = require("../sdk");
+const DEPLOY_ASSERT_SYMBOL = Symbol.for('@aws-cdk/integ-tests.DeployAssert');
+/**
+ * Construct that allows for registering a list of assertions
+ * that should be performed on a construct
+ */
+class DeployAssert extends constructs_1.Construct {
+    /**
+     * Returns whether the construct is a DeployAssert construct
+     */
+    static isDeployAssert(x) {
+        return x !== null && typeof (x) === 'object' && DEPLOY_ASSERT_SYMBOL in x;
+    }
+    /**
+     * Finds a DeployAssert construct in the given scope
+     */
+    static of(construct) {
+        const scopes = constructs_1.Node.of(constructs_1.Node.of(construct).root).findAll();
+        const deployAssert = scopes.find(s => DeployAssert.isDeployAssert(s));
+        if (!deployAssert) {
+            throw new Error('No DeployAssert construct found in scopes');
+        }
+        return deployAssert;
+    }
+    constructor(scope, props) {
+        super(scope, 'Default');
+        this.assertionIdCounts = new Map();
+        this.scope = props?.stack ?? new core_1.Stack(scope, 'DeployAssert');
+        Object.defineProperty(this, DEPLOY_ASSERT_SYMBOL, { value: true });
+    }
+    awsApiCall(service, api, parameters, outputPaths) {
+        let hash = '';
+        try {
+            hash = (0, hash_1.md5hash)(this.scope.resolve(parameters));
+        }
+        catch { }
+        return new sdk_1.AwsApiCall(this.scope, this.uniqueAssertionId(`AwsApiCall${service}${api}${hash}`), {
+            api,
+            service,
+            parameters,
+            outputPaths,
+        });
+    }
+    httpApiCall(url, options) {
+        let hash = '';
+        try {
+            hash = (0, hash_1.md5hash)(this.scope.resolve({
+                url,
+                options,
+            }));
+        }
+        catch { }
+        let append = '';
+        if (!core_1.Token.isUnresolved(url)) {
+            const parsedUrl = new URL(url);
+            append = `${parsedUrl.hostname}${parsedUrl.pathname}`;
+        }
+        return new http_call_1.HttpApiCall(this.scope, this.uniqueAssertionId(`HttpApiCall${append}${hash}`), {
+            url,
+            fetchOptions: options,
+        });
+    }
+    invokeFunction(props) {
+        const hash = (0, hash_1.md5hash)(this.scope.resolve(props));
+        return new sdk_1.LambdaInvokeFunction(this.scope, this.uniqueAssertionId(`LambdaInvoke${hash}`), props);
+    }
+    expect(id, expected, actual) {
+        new assertions_1.EqualsAssertion(this.scope, `EqualsAssertion${id}`, {
+            expected,
+            actual,
+        });
+    }
+    /**
+     * Gets a unique logical id based on a proposed assertion id.
+     */
+    uniqueAssertionId(id) {
+        const count = this.assertionIdCounts.get(id);
+        if (count === undefined) {
+            // If we've never seen this id before, we'll return the id unchanged
+            // to maintain backward compatibility.
+            this.assertionIdCounts.set(id, 1);
+            return id;
+        }
+        // Otherwise, we'll increment the counter and return a unique id.
+        this.assertionIdCounts.set(id, count + 1);
+        return `${id}${count}`;
+    }
+}
+exports.DeployAssert = DeployAssert;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"deploy-assert.js","sourceRoot":"","sources":["deploy-assert.ts"],"names":[],"mappings":"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","sourcesContent":["import { Stack, Token } from 'aws-cdk-lib/core';\nimport { Construct, IConstruct, Node } from 'constructs';\nimport { IApiCall } from '../api-call-base';\nimport { EqualsAssertion } from '../assertions';\nimport { ActualResult, ExpectedResult } from '../common';\nimport { HttpApiCall as HttpApiCall } from '../http-call';\nimport { md5hash } from '../private/hash';\nimport { FetchOptions } from '../providers';\nimport { AwsApiCall, LambdaInvokeFunction, LambdaInvokeFunctionProps } from '../sdk';\nimport { IDeployAssert } from '../types';\n\nconst DEPLOY_ASSERT_SYMBOL = Symbol.for('@aws-cdk/integ-tests.DeployAssert');\n\n/**\n * Options for DeployAssert\n */\nexport interface DeployAssertProps {\n\n  /**\n   * A stack to use for assertions\n   *\n   * @default - a stack is created for you\n   */\n  readonly stack?: Stack;\n}\n\n/**\n * Construct that allows for registering a list of assertions\n * that should be performed on a construct\n */\nexport class DeployAssert extends Construct implements IDeployAssert {\n\n  /**\n   * Returns whether the construct is a DeployAssert construct\n   */\n  public static isDeployAssert(x: any): x is DeployAssert {\n    return x !== null && typeof (x) === 'object' && DEPLOY_ASSERT_SYMBOL in x;\n  }\n\n  /**\n   * Finds a DeployAssert construct in the given scope\n   */\n  public static of(construct: IConstruct): DeployAssert {\n    const scopes = Node.of(Node.of(construct).root).findAll();\n    const deployAssert = scopes.find(s => DeployAssert.isDeployAssert(s));\n    if (!deployAssert) {\n      throw new Error('No DeployAssert construct found in scopes');\n    }\n    return deployAssert as DeployAssert;\n  }\n\n  public scope: Stack;\n  private assertionIdCounts = new Map<string, number>();\n\n  constructor(scope: Construct, props?: DeployAssertProps) {\n    super(scope, 'Default');\n\n    this.scope = props?.stack ?? new Stack(scope, 'DeployAssert');\n\n    Object.defineProperty(this, DEPLOY_ASSERT_SYMBOL, { value: true });\n  }\n\n  public awsApiCall(service: string, api: string, parameters?: any, outputPaths?: string[]): IApiCall {\n    let hash = '';\n    try {\n      hash = md5hash(this.scope.resolve(parameters));\n    } catch {}\n\n    return new AwsApiCall(this.scope, this.uniqueAssertionId(`AwsApiCall${service}${api}${hash}`), {\n      api,\n      service,\n      parameters,\n      outputPaths,\n    });\n  }\n\n  public httpApiCall(url: string, options?: FetchOptions): IApiCall {\n    let hash = '';\n    try {\n      hash = md5hash(this.scope.resolve({\n        url,\n        options,\n      }));\n    } catch {}\n\n    let append = '';\n    if (!Token.isUnresolved(url)) {\n      const parsedUrl = new URL(url);\n      append = `${parsedUrl.hostname}${parsedUrl.pathname}`;\n    }\n    return new HttpApiCall(this.scope, this.uniqueAssertionId(`HttpApiCall${append}${hash}`), {\n      url,\n      fetchOptions: options,\n    });\n  }\n\n  public invokeFunction(props: LambdaInvokeFunctionProps): IApiCall {\n    const hash = md5hash(this.scope.resolve(props));\n    return new LambdaInvokeFunction(this.scope, this.uniqueAssertionId(`LambdaInvoke${hash}`), props);\n  }\n\n  public expect(id: string, expected: ExpectedResult, actual: ActualResult): void {\n    new EqualsAssertion(this.scope, `EqualsAssertion${id}`, {\n      expected,\n      actual,\n    });\n  }\n\n  /**\n   * Gets a unique logical id based on a proposed assertion id.\n   */\n  private uniqueAssertionId(id: string): string {\n    const count = this.assertionIdCounts.get(id);\n\n    if (count === undefined) {\n      // If we've never seen this id before, we'll return the id unchanged\n      // to maintain backward compatibility.\n      this.assertionIdCounts.set(id, 1);\n      return id;\n    }\n\n    // Otherwise, we'll increment the counter and return a unique id.\n    this.assertionIdCounts.set(id, count + 1);\n    return `${id}${count}`;\n  }\n}\n"]}

package/node_modules/@aws-solutions-constructs/aws-lambda-dynamodb/node_modules/@aws-cdk/integ-tests-alpha/lib/assertions/private/hash.d.ts

@@ -0,0 +1 @@
+export declare function md5hash(obj: any): string;

package/node_modules/@aws-solutions-constructs/aws-lambda-dynamodb/node_modules/@aws-cdk/integ-tests-alpha/lib/assertions/private/hash.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.md5hash = void 0;
+const helpers_internal_1 = require("aws-cdk-lib/core/lib/helpers-internal");
+function md5hash(obj) {
+    if (!obj || (typeof (obj) === 'object' && Object.keys(obj).length === 0)) {
+        throw new Error('Cannot compute md5 hash for falsy object');
+    }
+    return (0, helpers_internal_1.md5hash)(JSON.stringify(obj));
+}
+exports.md5hash = md5hash;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGFzaC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbImhhc2gudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsNEVBQTJFO0FBRTNFLFNBQWdCLE9BQU8sQ0FBQyxHQUFRO0lBQzlCLElBQUksQ0FBQyxHQUFHLElBQUksQ0FBQyxPQUFNLENBQUMsR0FBRyxDQUFDLEtBQUssUUFBUSxJQUFJLE1BQU0sQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLENBQUMsTUFBTSxLQUFLLENBQUMsQ0FBQyxFQUFFLENBQUM7UUFDeEUsTUFBTSxJQUFJLEtBQUssQ0FBQywwQ0FBMEMsQ0FBQyxDQUFDO0lBQzlELENBQUM7SUFDRCxPQUFPLElBQUEsMEJBQU8sRUFBQyxJQUFJLENBQUMsU0FBUyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUM7QUFDdEMsQ0FBQztBQUxELDBCQUtDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgbWQ1aGFzaCBhcyBjb3JlTWQ1IH0gZnJvbSAnYXdzLWNkay1saWIvY29yZS9saWIvaGVscGVycy1pbnRlcm5hbCc7XG5cbmV4cG9ydCBmdW5jdGlvbiBtZDVoYXNoKG9iajogYW55KTogc3RyaW5nIHtcbiAgaWYgKCFvYmogfHwgKHR5cGVvZihvYmopID09PSAnb2JqZWN0JyAmJiBPYmplY3Qua2V5cyhvYmopLmxlbmd0aCA9PT0gMCkpIHtcbiAgICB0aHJvdyBuZXcgRXJyb3IoJ0Nhbm5vdCBjb21wdXRlIG1kNSBoYXNoIGZvciBmYWxzeSBvYmplY3QnKTtcbiAgfVxuICByZXR1cm4gY29yZU1kNShKU09OLnN0cmluZ2lmeShvYmopKTtcbn1cbiJdfQ==

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

@@ -0,0 +1,2 @@
+export * from './lambda-handler/types';
+export * from './provider';

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

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./lambda-handler/types"), exports);
+__exportStar(require("./provider"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEseURBQXVDO0FBQ3ZDLDZDQUEyQiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vbGFtYmRhLWhhbmRsZXIvdHlwZXMnO1xuZXhwb3J0ICogZnJvbSAnLi9wcm92aWRlcic7XG4iXX0=

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

@@ -0,0 +1,5 @@
+import { CustomResourceHandler } from './base';
+import { AssertionResult, AssertionRequest } from './types';
+export declare class AssertionHandler extends CustomResourceHandler<AssertionRequest, AssertionResult> {
+    protected processEvent(request: AssertionRequest): Promise<AssertionResult | undefined>;
+}

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

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssertionHandler = void 0;
+/* eslint-disable no-console */
+// eslint-disable-next-line import/no-extraneous-dependencies
+const helpers_internal_1 = require("aws-cdk-lib/assertions/lib/helpers-internal");
+const base_1 = require("./base");
+class AssertionHandler extends base_1.CustomResourceHandler {
+    async processEvent(request) {
+        let actual = decodeCall(request.actual);
+        const expected = decodeCall(request.expected);
+        let result;
+        const matcher = new MatchCreator(expected).getMatcher();
+        console.log(`Testing equality between ${JSON.stringify(request.actual)} and ${JSON.stringify(request.expected)}`);
+        const matchResult = matcher.test(actual);
+        matchResult.finished();
+        if (matchResult.hasFailed()) {
+            result = {
+                failed: true,
+                assertion: JSON.stringify({
+                    status: 'fail',
+                    message: matchResult.renderMismatch(),
+                }),
+            };
+            if (request.failDeployment) {
+                throw new Error(result.assertion);
+            }
+        }
+        else {
+            result = {
+                assertion: JSON.stringify({
+                    status: 'success',
+                }),
+            };
+        }
+        return result;
+    }
+}
+exports.AssertionHandler = AssertionHandler;
+class MatchCreator {
+    constructor(obj) {
+        this.parsedObj = {
+            matcher: obj,
+        };
+    }
+    /**
+     * Return a Matcher that can be tested against the actual results.
+     * This will convert the encoded matchers into their corresponding
+     * assertions matcher.
+     *
+     * For example:
+     *
+     * ExpectedResult.objectLike({
+     *   Messages: [{
+     *     Body: Match.objectLike({
+     *       Elements: Match.arrayWith([{ Asdf: 3 }]),
+     *       Payload: Match.serializedJson({ key: 'value' }),
+     *     }),
+     *   }],
+     * });
+     *
+     * Will be encoded as:
+     * {
+     *   $ObjectLike: {
+     *     Messages: [{
+     *       Body: {
+     *         $ObjectLike: {
+     *           Elements: {
+     *             $ArrayWith: [{ Asdf: 3 }],
+     *           },
+     *           Payload: {
+     *             $SerializedJson: { key: 'value' }
+     *           }
+     *         },
+     *       },
+     *     }],
+     *   },
+     * }
+     *
+     * Which can then be parsed by this function. For each key (recursively)
+     * the parser will check if the value has one of the encoded matchers as a key
+     * and if so, it will set the value as the Matcher. So,
+     *
+     * {
+     *   Body: {
+     *     $ObjectLike: {
+     *       Elements: {
+     *         $ArrayWith: [{ Asdf: 3 }],
+     *       },
+     *       Payload: {
+     *         $SerializedJson: { key: 'value' }
+     *       }
+     *     },
+     *   },
+     * }
+     *
+     * Will be converted to
+     * {
+     *   Body: Match.objectLike({
+     *     Elements: Match.arrayWith([{ Asdf: 3 }]),
+     *     Payload: Match.serializedJson({ key: 'value' }),
+     *   }),
+     * }
+     */
+    getMatcher() {
+        try {
+            const final = JSON.parse(JSON.stringify(this.parsedObj), function (_k, v) {
+                const nested = Object.keys(v)[0];
+                switch (nested) {
+                    case '$ArrayWith':
+                        return helpers_internal_1.Match.arrayWith(v[nested]);
+                    case '$ObjectLike':
+                        return helpers_internal_1.Match.objectLike(v[nested]);
+                    case '$StringLike':
+                        return helpers_internal_1.Match.stringLikeRegexp(v[nested]);
+                    case '$SerializedJson':
+                        return helpers_internal_1.Match.serializedJson(v[nested]);
+                    default:
+                        return v;
+                }
+            });
+            if (helpers_internal_1.Matcher.isMatcher(final.matcher)) {
+                return final.matcher;
+            }
+            return helpers_internal_1.Match.exact(final.matcher);
+        }
+        catch {
+            return helpers_internal_1.Match.exact(this.parsedObj.matcher);
+        }
+    }
+}
+function decodeCall(call) {
+    if (!call) {
+        return undefined;
+    }
+    try {
+        const parsed = JSON.parse(call);
+        return parsed;
+    }
+    catch {
+        return call;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"assertion.js","sourceRoot":"","sources":["assertion.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable no-console */\n// eslint-disable-next-line import/no-extraneous-dependencies\nimport { Match, Matcher } from 'aws-cdk-lib/assertions/lib/helpers-internal';\nimport { CustomResourceHandler } from './base';\nimport { AssertionResult, AssertionRequest } from './types';\n\nexport class AssertionHandler extends CustomResourceHandler<AssertionRequest, AssertionResult> {\n  protected async processEvent(request: AssertionRequest): Promise<AssertionResult | undefined> {\n    let actual = decodeCall(request.actual);\n    const expected = decodeCall(request.expected);\n    let result: AssertionResult;\n    const matcher = new MatchCreator(expected).getMatcher();\n    console.log(`Testing equality between ${JSON.stringify(request.actual)} and ${JSON.stringify(request.expected)}`);\n\n    const matchResult = matcher.test(actual);\n    matchResult.finished();\n    if (matchResult.hasFailed()) {\n      result = {\n        failed: true,\n        assertion: JSON.stringify({\n          status: 'fail',\n          message: matchResult.renderMismatch(),\n        }),\n      };\n      if (request.failDeployment) {\n        throw new Error(result.assertion);\n      }\n    } else {\n      result = {\n        assertion: JSON.stringify({\n          status: 'success',\n        }),\n      };\n    }\n\n    return result;\n  }\n}\n\nclass MatchCreator {\n  private readonly parsedObj: { [key: string]: any };\n  constructor(obj: { [key: string]: any }) {\n    this.parsedObj = {\n      matcher: obj,\n    };\n  }\n\n  /**\n   * Return a Matcher that can be tested against the actual results.\n   * This will convert the encoded matchers into their corresponding\n   * assertions matcher.\n   *\n   * For example:\n   *\n   * ExpectedResult.objectLike({\n   *   Messages: [{\n   *     Body: Match.objectLike({\n   *       Elements: Match.arrayWith([{ Asdf: 3 }]),\n   *       Payload: Match.serializedJson({ key: 'value' }),\n   *     }),\n   *   }],\n   * });\n   *\n   * Will be encoded as:\n   * {\n   *   $ObjectLike: {\n   *     Messages: [{\n   *       Body: {\n   *         $ObjectLike: {\n   *           Elements: {\n   *             $ArrayWith: [{ Asdf: 3 }],\n   *           },\n   *           Payload: {\n   *             $SerializedJson: { key: 'value' }\n   *           }\n   *         },\n   *       },\n   *     }],\n   *   },\n   * }\n   *\n   * Which can then be parsed by this function. For each key (recursively)\n   * the parser will check if the value has one of the encoded matchers as a key\n   * and if so, it will set the value as the Matcher. So,\n   *\n   * {\n   *   Body: {\n   *     $ObjectLike: {\n   *       Elements: {\n   *         $ArrayWith: [{ Asdf: 3 }],\n   *       },\n   *       Payload: {\n   *         $SerializedJson: { key: 'value' }\n   *       }\n   *     },\n   *   },\n   * }\n   *\n   * Will be converted to\n   * {\n   *   Body: Match.objectLike({\n   *     Elements: Match.arrayWith([{ Asdf: 3 }]),\n   *     Payload: Match.serializedJson({ key: 'value' }),\n   *   }),\n   * }\n   */\n  public getMatcher(): Matcher {\n    try {\n      const final = JSON.parse(JSON.stringify(this.parsedObj), function(_k, v) {\n        const nested = Object.keys(v)[0];\n        switch (nested) {\n          case '$ArrayWith':\n            return Match.arrayWith(v[nested]);\n          case '$ObjectLike':\n            return Match.objectLike(v[nested]);\n          case '$StringLike':\n            return Match.stringLikeRegexp(v[nested]);\n          case '$SerializedJson':\n            return Match.serializedJson(v[nested]);\n          default:\n            return v;\n        }\n      });\n      if (Matcher.isMatcher(final.matcher)) {\n        return final.matcher;\n      }\n      return Match.exact(final.matcher);\n    } catch {\n      return Match.exact(this.parsedObj.matcher);\n    }\n  }\n}\n\nfunction decodeCall(call?: string) {\n  if (!call) { return undefined; }\n  try {\n    const parsed = JSON.parse(call);\n    return parsed;\n  } catch {\n    return call;\n  }\n}\n"]}

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

@@ -0,0 +1,30 @@
+interface HandlerResponse {
+    readonly status: 'SUCCESS' | 'FAILED';
+    readonly reason: 'OK' | string;
+    readonly data?: any;
+}
+export declare abstract class CustomResourceHandler<Request extends object, Response extends object> {
+    protected readonly event: AWSLambda.CloudFormationCustomResourceEvent;
+    protected readonly context: AWSLambda.Context;
+    readonly physicalResourceId: string;
+    private readonly timeout;
+    private timedOut;
+    constructor(event: AWSLambda.CloudFormationCustomResourceEvent, context: AWSLambda.Context);
+    /**
+     * Handles executing the custom resource event. If `stateMachineArn` is present
+     * in the props then trigger the waiter statemachine
+     */
+    handle(): Promise<Response | undefined>;
+    /**
+     * Handle async requests from the waiter state machine
+     */
+    handleIsComplete(): Promise<Response | undefined>;
+    /**
+     * Start a step function state machine which will wait for the request
+     * to be successful.
+     */
+    private startExecution;
+    protected abstract processEvent(request: Request): Promise<Response | undefined>;
+    respond(response: HandlerResponse): Promise<unknown> | undefined;
+}
+export {};

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

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomResourceHandler = void 0;
+/* eslint-disable no-console */
+const https = require("https");
+const url = require("url");
+const client_sfn_1 = require("@aws-sdk/client-sfn");
+// eslint-disable-next-line @typescript-eslint/ban-types
+class CustomResourceHandler {
+    constructor(event, context) {
+        this.event = event;
+        this.context = context;
+        this.timedOut = false;
+        this.timeout = setTimeout(async () => {
+            await this.respond({
+                status: 'FAILED',
+                reason: 'Lambda Function Timeout',
+                data: this.context.logStreamName,
+            });
+            this.timedOut = true;
+        }, context.getRemainingTimeInMillis() - 1200);
+        this.event = event;
+        this.physicalResourceId = extractPhysicalResourceId(event);
+    }
+    /**
+     * Handles executing the custom resource event. If `stateMachineArn` is present
+     * in the props then trigger the waiter statemachine
+     */
+    async handle() {
+        try {
+            if ('stateMachineArn' in this.event.ResourceProperties) {
+                const req = {
+                    stateMachineArn: this.event.ResourceProperties.stateMachineArn,
+                    name: this.event.RequestId,
+                    input: JSON.stringify(this.event),
+                };
+                await this.startExecution(req);
+                return;
+            }
+            else {
+                const response = await this.processEvent(this.event.ResourceProperties);
+                return response;
+            }
+        }
+        catch (e) {
+            console.log(e);
+            throw e;
+        }
+        finally {
+            clearTimeout(this.timeout);
+        }
+    }
+    /**
+     * Handle async requests from the waiter state machine
+     */
+    async handleIsComplete() {
+        try {
+            const result = await this.processEvent(this.event.ResourceProperties);
+            return result;
+        }
+        catch (e) {
+            console.log(e);
+            return;
+        }
+        finally {
+            clearTimeout(this.timeout);
+        }
+    }
+    /**
+     * Start a step function state machine which will wait for the request
+     * to be successful.
+     */
+    async startExecution(req) {
+        try {
+            const sfn = new client_sfn_1.SFN({});
+            await sfn.startExecution(req);
+        }
+        finally {
+            clearTimeout(this.timeout);
+        }
+    }
+    respond(response) {
+        if (this.timedOut) {
+            return;
+        }
+        const cfResponse = {
+            Status: response.status,
+            Reason: response.reason,
+            PhysicalResourceId: this.physicalResourceId,
+            StackId: this.event.StackId,
+            RequestId: this.event.RequestId,
+            LogicalResourceId: this.event.LogicalResourceId,
+            NoEcho: false,
+            Data: response.data,
+        };
+        const responseBody = JSON.stringify(cfResponse);
+        console.log('Responding to CloudFormation', responseBody);
+        const parsedUrl = url.parse(this.event.ResponseURL);
+        const requestOptions = {
+            hostname: parsedUrl.hostname,
+            path: parsedUrl.path,
+            method: 'PUT',
+            headers: {
+                'content-type': '',
+                'content-length': Buffer.byteLength(responseBody, 'utf8'),
+            },
+        };
+        return new Promise((resolve, reject) => {
+            try {
+                const request = https.request(requestOptions, resolve);
+                request.on('error', reject);
+                request.write(responseBody);
+                request.end();
+            }
+            catch (e) {
+                reject(e);
+            }
+            finally {
+                clearTimeout(this.timeout);
+            }
+        });
+    }
+}
+exports.CustomResourceHandler = CustomResourceHandler;
+function extractPhysicalResourceId(event) {
+    switch (event.RequestType) {
+        case 'Create':
+            return event.LogicalResourceId;
+        case 'Update':
+        case 'Delete':
+            return event.PhysicalResourceId;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base.js","sourceRoot":"","sources":["base.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable no-console */\nimport * as https from 'https';\nimport * as url from 'url';\nimport { SFN, StartExecutionInput } from '@aws-sdk/client-sfn';\n\ninterface HandlerResponse {\n  readonly status: 'SUCCESS' | 'FAILED';\n  readonly reason: 'OK' | string;\n  readonly data?: any;\n}\n\n// eslint-disable-next-line @typescript-eslint/ban-types\nexport abstract class CustomResourceHandler<Request extends object, Response extends object> {\n  public readonly physicalResourceId: string;\n  private readonly timeout: NodeJS.Timeout;\n  private timedOut = false;\n\n  constructor(protected readonly event: AWSLambda.CloudFormationCustomResourceEvent, protected readonly context: AWSLambda.Context) {\n    this.timeout = setTimeout(async () => {\n      await this.respond({\n        status: 'FAILED',\n        reason: 'Lambda Function Timeout',\n        data: this.context.logStreamName,\n      });\n      this.timedOut = true;\n    }, context.getRemainingTimeInMillis() - 1200);\n    this.event = event;\n    this.physicalResourceId = extractPhysicalResourceId(event);\n  }\n\n  /**\n   * Handles executing the custom resource event. If `stateMachineArn` is present\n   * in the props then trigger the waiter statemachine\n   */\n  public async handle(): Promise<Response | undefined> {\n    try {\n      if ('stateMachineArn' in this.event.ResourceProperties) {\n        const req: StartExecutionInput = {\n          stateMachineArn: this.event.ResourceProperties.stateMachineArn,\n          name: this.event.RequestId,\n          input: JSON.stringify(this.event),\n        };\n        await this.startExecution(req);\n        return;\n      } else {\n        const response = await this.processEvent(this.event.ResourceProperties as unknown as Request);\n        return response;\n      }\n    } catch (e) {\n      console.log(e);\n      throw e;\n    } finally {\n      clearTimeout(this.timeout);\n    }\n  }\n\n  /**\n   * Handle async requests from the waiter state machine\n   */\n  public async handleIsComplete(): Promise<Response | undefined> {\n    try {\n      const result = await this.processEvent(this.event.ResourceProperties as unknown as Request);\n      return result;\n    } catch (e) {\n      console.log(e);\n      return;\n    } finally {\n      clearTimeout(this.timeout);\n    }\n  }\n\n  /**\n   * Start a step function state machine which will wait for the request\n   * to be successful.\n   */\n  private async startExecution(req: StartExecutionInput): Promise<void> {\n    try {\n      const sfn = new SFN({});\n      await sfn.startExecution(req);\n    } finally {\n      clearTimeout(this.timeout);\n    }\n  }\n\n  protected abstract processEvent(request: Request): Promise<Response | undefined>;\n\n  public respond(response: HandlerResponse) {\n    if (this.timedOut) {\n      return;\n    }\n    const cfResponse: AWSLambda.CloudFormationCustomResourceResponse = {\n      Status: response.status,\n      Reason: response.reason,\n      PhysicalResourceId: this.physicalResourceId,\n      StackId: this.event.StackId,\n      RequestId: this.event.RequestId,\n      LogicalResourceId: this.event.LogicalResourceId,\n      NoEcho: false,\n      Data: response.data,\n    };\n    const responseBody = JSON.stringify(cfResponse);\n\n    console.log('Responding to CloudFormation', responseBody);\n\n    const parsedUrl = url.parse(this.event.ResponseURL);\n    const requestOptions = {\n      hostname: parsedUrl.hostname,\n      path: parsedUrl.path,\n      method: 'PUT',\n      headers: {\n        'content-type': '',\n        'content-length': Buffer.byteLength(responseBody, 'utf8'),\n      },\n    };\n\n    return new Promise((resolve, reject) => {\n      try {\n        const request = https.request(requestOptions, resolve);\n        request.on('error', reject);\n        request.write(responseBody);\n        request.end();\n      } catch (e) {\n        reject(e);\n      } finally {\n        clearTimeout(this.timeout);\n      }\n    });\n  }\n}\n\nfunction extractPhysicalResourceId(event: AWSLambda.CloudFormationCustomResourceEvent): string {\n  switch (event.RequestType) {\n    case 'Create':\n      return event.LogicalResourceId;\n    case 'Update':\n    case 'Delete':\n      return event.PhysicalResourceId;\n  }\n}\n"]}

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

@@ -0,0 +1,5 @@
+import { CustomResourceHandler } from './base';
+import { HttpRequest, HttpResponseWrapper } from './types';
+export declare class HttpHandler extends CustomResourceHandler<HttpRequest, HttpResponseWrapper> {
+    protected processEvent(request: HttpRequest): Promise<HttpResponseWrapper>;
+}

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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpHandler = void 0;
+/* eslint-disable no-console */
+// eslint-disable-next-line import/no-extraneous-dependencies
+const node_fetch_1 = require("node-fetch");
+// TODO: can use builtin fetch on node18
+const base_1 = require("./base");
+class HttpHandler extends base_1.CustomResourceHandler {
+    async processEvent(request) {
+        console.log('request', request);
+        const response = await (0, node_fetch_1.default)(request.parameters.url, request.parameters.fetchOptions);
+        const result = {
+            ok: response.ok,
+            status: response.status,
+            statusText: response.statusText,
+            headers: response.headers.raw(),
+        };
+        result.body = await response.text();
+        try {
+            result.body = JSON.parse(result.body);
+        }
+        catch (e) {
+            // Okay
+        }
+        return {
+            apiCallResponse: result,
+        };
+    }
+}
+exports.HttpHandler = HttpHandler;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaHR0cC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbImh0dHAudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsK0JBQStCO0FBQy9CLDZEQUE2RDtBQUM3RCwyQ0FBNkM7QUFDN0Msd0NBQXdDO0FBQ3hDLGlDQUErQztBQUcvQyxNQUFhLFdBQVksU0FBUSw0QkFBdUQ7SUFDNUUsS0FBSyxDQUFDLFlBQVksQ0FBQyxPQUFvQjtRQUMvQyxPQUFPLENBQUMsR0FBRyxDQUFDLFNBQVMsRUFBRSxPQUFPLENBQUMsQ0FBQztRQUNoQyxNQUFNLFFBQVEsR0FBYSxNQUFNLElBQUEsb0JBQUssRUFBQyxPQUFPLENBQUMsVUFBVSxDQUFDLEdBQUcsRUFBRSxPQUFPLENBQUMsVUFBVSxDQUFDLFlBQVksQ0FBQyxDQUFDO1FBQ2hHLE1BQU0sTUFBTSxHQUFRO1lBQ2xCLEVBQUUsRUFBRSxRQUFRLENBQUMsRUFBRTtZQUNmLE1BQU0sRUFBRSxRQUFRLENBQUMsTUFBTTtZQUN2QixVQUFVLEVBQUUsUUFBUSxDQUFDLFVBQVU7WUFDL0IsT0FBTyxFQUFFLFFBQVEsQ0FBQyxPQUFPLENBQUMsR0FBRyxFQUFFO1NBQ2hDLENBQUM7UUFFRixNQUFNLENBQUMsSUFBSSxHQUFHLE1BQU0sUUFBUSxDQUFDLElBQUksRUFBRSxDQUFDO1FBQ3BDLElBQUksQ0FBQztZQUNILE1BQU0sQ0FBQyxJQUFJLEdBQUcsSUFBSSxDQUFDLEtBQUssQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLENBQUM7UUFDeEMsQ0FBQztRQUFDLE9BQU8sQ0FBQyxFQUFFLENBQUM7WUFDWCxPQUFPO1FBQ1QsQ0FBQztRQUNELE9BQU87WUFDTCxlQUFlLEVBQUUsTUFBTTtTQUN4QixDQUFDO0tBQ0g7Q0FDRjtBQXJCRCxrQ0FxQkMiLCJzb3VyY2VzQ29udGVudCI6WyIvKiBlc2xpbnQtZGlzYWJsZSBuby1jb25zb2xlICovXG4vLyBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgaW1wb3J0L25vLWV4dHJhbmVvdXMtZGVwZW5kZW5jaWVzXG5pbXBvcnQgZmV0Y2gsIHsgUmVzcG9uc2UgfSBmcm9tICdub2RlLWZldGNoJztcbi8vIFRPRE86IGNhbiB1c2UgYnVpbHRpbiBmZXRjaCBvbiBub2RlMThcbmltcG9ydCB7IEN1c3RvbVJlc291cmNlSGFuZGxlciB9IGZyb20gJy4vYmFzZSc7XG5pbXBvcnQgeyBIdHRwUmVxdWVzdCwgSHR0cFJlc3BvbnNlV3JhcHBlciB9IGZyb20gJy4vdHlwZXMnO1xuXG5leHBvcnQgY2xhc3MgSHR0cEhhbmRsZXIgZXh0ZW5kcyBDdXN0b21SZXNvdXJjZUhhbmRsZXI8SHR0cFJlcXVlc3QsIEh0dHBSZXNwb25zZVdyYXBwZXI+IHtcbiAgcHJvdGVjdGVkIGFzeW5jIHByb2Nlc3NFdmVudChyZXF1ZXN0OiBIdHRwUmVxdWVzdCk6IFByb21pc2U8SHR0cFJlc3BvbnNlV3JhcHBlcj4ge1xuICAgIGNvbnNvbGUubG9nKCdyZXF1ZXN0JywgcmVxdWVzdCk7XG4gICAgY29uc3QgcmVzcG9uc2U6IFJlc3BvbnNlID0gYXdhaXQgZmV0Y2gocmVxdWVzdC5wYXJhbWV0ZXJzLnVybCwgcmVxdWVzdC5wYXJhbWV0ZXJzLmZldGNoT3B0aW9ucyk7XG4gICAgY29uc3QgcmVzdWx0OiBhbnkgPSB7XG4gICAgICBvazogcmVzcG9uc2Uub2ssXG4gICAgICBzdGF0dXM6IHJlc3BvbnNlLnN0YXR1cyxcbiAgICAgIHN0YXR1c1RleHQ6IHJlc3BvbnNlLnN0YXR1c1RleHQsXG4gICAgICBoZWFkZXJzOiByZXNwb25zZS5oZWFkZXJzLnJhdygpLFxuICAgIH07XG5cbiAgICByZXN1bHQuYm9keSA9IGF3YWl0IHJlc3BvbnNlLnRleHQoKTtcbiAgICB0cnkge1xuICAgICAgcmVzdWx0LmJvZHkgPSBKU09OLnBhcnNlKHJlc3VsdC5ib2R5KTtcbiAgICB9IGNhdGNoIChlKSB7XG4gICAgICAvLyBPa2F5XG4gICAgfVxuICAgIHJldHVybiB7XG4gICAgICBhcGlDYWxsUmVzcG9uc2U6IHJlc3VsdCxcbiAgICB9O1xuICB9XG59XG4iXX0=