@horietakehiro/aws-cdk-utul 0.35.6 → 0.40.0

package/lib/assertions.d.ts

@@ -1,4 +1,4 @@
-import { Template, Match, Matcher } from "aws-cdk-lib/assertions";
+import { Template, Matcher } from "aws-cdk-lib/assertions";
 import { Condition, InputResource, Mapping, OutputResource, InputParamter, OutputParameter, ReturnValue, InputOutput, OutputOutput, InputResourceWithoutType, IAMPolicyDocument, AlsoMatcher, TypedMatcher } from "./typed-resource";
 /**
  * almost same class as `Template` class at "aws-cdk-lib/assertions", but you can use this with proper type definitions
@@ -141,7 +141,7 @@ export interface JoinProps {
 /**
  * provides some syntax sugars for `Match` class at `aws-cdk-lib/assertions`
  */
-export declare class ExtraMatch extends Match {
+export declare class ExtraMatch {
     /**
      * same function as `Match.objectEquals({ Ref: logicalId })`
      * @param logicalId
@@ -161,16 +161,6 @@ export declare class ExtraMatch extends Match {
      * @returns
      */
     static getAttArn(logicalId: string): Matcher;
-    static arrayWith<T extends any[]>(pattern: AlsoMatcher<T>): TypedMatcher<T>;
-    static arrayEquals<T extends any[]>(pattern: AlsoMatcher<T>): TypedMatcher<T>;
-    static objectLike<T extends {
-        [key: string]: any;
-    }>(pattern: AlsoMatcher<T>): TypedMatcher<T>;
-    static objectEquals<T extends {
-        [key: string]: any;
-    }>(pattern: AlsoMatcher<T>): TypedMatcher<T>;
-    static not<T>(pattern: AlsoMatcher<T>): TypedMatcher<T>;
-    static exact<T>(pattern: AlsoMatcher<T>): TypedMatcher<T>;
     /**
      * same function as below:
      *
@@ -183,5 +173,222 @@ export declare class ExtraMatch extends Match {
      * @returns
      */
     static joinLike(props: JoinProps): Matcher;
+    /**
+     You can define Matcher for IAM Policy Document with type hints.
+     ```js
+      template.hasResource(
+        AWS_IAM_ROLE({
+          Properties: {
+            AssumeRolePolicyDocument: ExtraMatch.iamPolicyLike({
+              Statement: [
+                {
+                  Principal: { Service: "ec2.amazonaws.com" },
+                },
+              ],
+            }),
+          },
+        })
+      );
+     ```
+     * @param doc
+     * @returns
+     */
     static iamPolicyLike(doc: AlsoMatcher<IAMPolicyDocument>): Matcher;
+    /**
+     Same method as `Match.arrayWith` but provides type hints and validate type match
+     ```js
+      // this is a right code
+      template.hasResource(
+        AWS_EC2_EIP({
+          Properties: {
+            Tags: ExtraMatch.arrayWith<Tag[]>([
+              {
+                Key: "key2",
+                Value: "val2",
+              },
+            ]),
+          },
+        })
+      );
+      // this is a wrong code(type mismatch will be detected and ts-error will be raised)
+      template.hasResource(
+        AWS_EC2_EIP({
+          Properties: {
+            Tags: ExtraMatch.arrayWith<string[]>([
+              "hoge", "fuga"
+            ]),
+          },
+        })
+      );
+     ```
+     * @param pattern
+     * @returns
+     */
+    static arrayWith<T extends any[]>(pattern: AlsoMatcher<T>): TypedMatcher<T>;
+    /**
+     * Same method as `Match.arrayEquals` but provides type hints and validate type match
+     ```js
+      // this is a right code
+      template.hasResource(
+        AWS_EC2_EIP({
+          Properties: {
+            Tags: ExtraMatch.arrayEquals<Tag[]>([
+              {
+                Key: "key1",
+                Value: "val1",
+              },
+              {
+                Key: "key2",
+                Value: "val2",
+              },
+            ]),
+          },
+        })
+      );
+      // this is a wrong code(type mismatch will be detected and ts-error will be raised)
+      template.hasResource(
+        AWS_EC2_EIP({
+          Properties: {
+            Tags: ExtraMatch.arrayEquals<Tag[]>([
+              {
+                Key: "key1",
+                Value: "val1",
+              },
+              {
+                Key: 100,
+                Value: 200,
+              },
+            ]),
+          },
+        })
+      );
+     ```
+     * @param pattern
+     * @returns
+     */
+    static arrayEquals<T extends any[]>(pattern: AlsoMatcher<T>): TypedMatcher<T>;
+    /**
+     * Same method as `Match.objectLike` but provides type hints and validate type match
+     ```js
+     // this is a right code
+      template.hasResource(
+        AWS_EC2_INSTANCE({
+          Properties: {
+            BlockDeviceMappings: [
+              {
+                DeviceName: "test",
+                Ebs: ExtraMatch.objectLike<Ebs>({
+                  VolumeSize: 10,
+                }),
+              },
+            ],
+          },
+        })
+      );
+      // this is a wrong code(type mismatch will be detected and ts-error will be raised)
+      template.hasResource(
+        AWS_EC2_INSTANCE({
+          Properties: {
+            BlockDeviceMappings: [
+              {
+                DeviceName: "test",
+                Ebs: ExtraMatch.objectLike<Ebs>({
+                  VolumeSize: "10",
+                }),
+              },
+            ],
+          },
+        })
+      );
+     * @param pattern
+     * @returns
+     */
+    static objectLike<T extends {
+        [key: string]: any;
+    }>(pattern: AlsoMatcher<T>): TypedMatcher<T>;
+    /**
+     * Same method as `Match.objectEquals` but provides type hints and validate type match
+     ```js
+     // this is a right code
+      template.hasResource(
+        AWS_EC2_EIP({
+          Properties: {
+            // You can nest TypedMatcher(use TypedMatcher inside TypedMatcher)
+            Tags: ExtraMatch.arrayWith<Tag[]>([
+              ExtraMatch.objectEquals<Tag>({
+                Key: "key1",
+                Value: "val1",
+              }),
+            ]),
+          },
+        })
+      );
+      // this is a wrong code(type mismatch will be detected and ts-error will be raised)
+      template.hasResource(
+        AWS_EC2_EIP({
+          Properties: {
+            Tags: ExtraMatch.arrayWith<Tag[]>([
+              ExtraMatch.objectEquals<Tag>({
+                Key: "key1",
+                Value: 100,
+              }),
+            ]),
+          },
+        })
+      );
+     * @param pattern
+     * @returns
+     */
+    static objectEquals<T extends {
+        [key: string]: any;
+    }>(pattern: AlsoMatcher<T>): TypedMatcher<T>;
+    /**
+     * Same method as `Match.not` but provides type hints and validate type match
+     ```js
+      // this is a right code
+      template.hasResource(
+        AWS_EC2_INSTANCE({
+          Properties: {
+            ImageId: ExtraMatch.not("ami-12345"),
+          },
+        })
+      );
+      // this is a wrong code(type mismatch will be detected and ts-error will be raised)
+      template.hasResource(
+        AWS_EC2_INSTANCE({
+          Properties: {
+            ImageId: ExtraMatch.not(100),
+          },
+        })
+      );
+     ```
+     * Same method as `Match.not` but provides type hints and validate type match
+     * @param pattern
+     * @returns
+     */
+    static not<T>(pattern: AlsoMatcher<T extends never ? never : T>): TypedMatcher<T>;
+    /**
+     * Same method as `Match.exact` but provides type hints and validate type match
+     ```js
+      // this is a right code
+      template.hasResource(
+        AWS_EC2_INSTANCE({
+          Properties: {
+            InstanceType: ExtraMatch.exact("t2.micro"),
+          },
+        })
+      );
+      // this is a wrong code(type mismatch will be detected and ts-error will be raised)
+      template.hasResource(
+        AWS_EC2_INSTANCE({
+          Properties: {
+            InstanceType: ExtraMatch.exact(false),
+          },
+        })
+      );
+     ```
+     * @param pattern
+     * @returns
+     */
+    static exact<T>(pattern: AlsoMatcher<T extends never ? never : T>): TypedMatcher<T>;
 }

package/lib/assertions.js

@@ -199,7 +199,7 @@ exports.TypedTemplate = TypedTemplate;
 /**
  * provides some syntax sugars for `Match` class at `aws-cdk-lib/assertions`
  */
-class ExtraMatch extends assertions_1.Match {
+class ExtraMatch {
     /**
      * same function as `Match.objectEquals({ Ref: logicalId })`
      * @param logicalId
@@ -225,24 +225,6 @@ class ExtraMatch extends assertions_1.Match {
     static getAttArn(logicalId) {
         return this.getAtt(logicalId, "Arn");
     }
-    static arrayWith(pattern) {
-        return assertions_1.Match.arrayWith(pattern);
-    }
-    static arrayEquals(pattern) {
-        return assertions_1.Match.arrayEquals(pattern);
-    }
-    static objectLike(pattern) {
-        return assertions_1.Match.objectLike(pattern);
-    }
-    static objectEquals(pattern) {
-        return assertions_1.Match.objectEquals(pattern);
-    }
-    static not(pattern) {
-        return assertions_1.Match.not(pattern);
-    }
-    static exact(pattern) {
-        return assertions_1.Match.exact(pattern);
-    }
     /**
      * same function as below:
      *
@@ -259,55 +241,235 @@ class ExtraMatch extends assertions_1.Match {
             "Fn::Join": [props.delimiter ?? "", assertions_1.Match.arrayWith(props.arrayWith)],
         });
     }
-    // /**
-    //  * returns Match instance that matches regional resource ARN like : `arn:aws:logs:ap-northeast-1:123456789012:log-group:/log-group-name:log-stream:log-stream-name`
-    //  * @param elems
-    //  * @returns
-    //  */
-    // static regionalArnLike(elems: AlsoMatcher<ArnElements>): Matcher {
-    //   return Match.objectEquals({
-    //     "Fn::Join": Match.arrayWith([
-    //       "",
-    //       Match.arrayWith([
-    //         "arn:",
-    //         elems.partition ?? { Ref: "AWS::Partition" },
-    //         Match.stringLikeRegexp(`:${elems.service ?? "*"}:`),
-    //         elems.region ?? { Ref: "AWS::Region" },
-    //         elems.account ?? { Ref: "AWS::AccountId" },
-    //         ...(elems.rest instanceof Matcher
-    //           ? [elems.rest]
-    //           : (elems.rest ?? [])),
-    //       ]),
-    //     ]),
-    //   });
-    // }
-    // /**
-    //  * returns Match instance that matches global resource ARN like : `arn:aws:iam::123456789012:role/role-name`
-    //  * @param elems
-    //  * @returns
-    //  */
-    // static globalArn(
-    //   elems: Omit<ArnElements, "region">,
-    //   delimiter: string = ""
-    // ): Matcher {
-    //   return Match.objectEquals({
-    //     "Fn::Join": Match.arrayEquals([
-    //       delimiter,
-    //       Match.arrayWith([
-    //         "arn:",
-    //         elems.partition ?? { Ref: "AWS::Partition" },
-    //         Match.stringLikeRegexp(`:${elems.service ?? "*"}::`),
-    //         elems.account ?? { Ref: "AWS::AccountId" },
-    //         ...(elems.rest instanceof Matcher
-    //           ? [elems.rest]
-    //           : (elems.rest ?? [])),
-    //       ]),
-    //     ]),
-    //   });
-    // }
+    /**
+     You can define Matcher for IAM Policy Document with type hints.
+     ```js
+      template.hasResource(
+        AWS_IAM_ROLE({
+          Properties: {
+            AssumeRolePolicyDocument: ExtraMatch.iamPolicyLike({
+              Statement: [
+                {
+                  Principal: { Service: "ec2.amazonaws.com" },
+                },
+              ],
+            }),
+          },
+        })
+      );
+     ```
+     * @param doc
+     * @returns
+     */
     static iamPolicyLike(doc) {
         return assertions_1.Match.objectLike(doc);
     }
+    /**
+     Same method as `Match.arrayWith` but provides type hints and validate type match
+     ```js
+      // this is a right code
+      template.hasResource(
+        AWS_EC2_EIP({
+          Properties: {
+            Tags: ExtraMatch.arrayWith<Tag[]>([
+              {
+                Key: "key2",
+                Value: "val2",
+              },
+            ]),
+          },
+        })
+      );
+      // this is a wrong code(type mismatch will be detected and ts-error will be raised)
+      template.hasResource(
+        AWS_EC2_EIP({
+          Properties: {
+            Tags: ExtraMatch.arrayWith<string[]>([
+              "hoge", "fuga"
+            ]),
+          },
+        })
+      );
+     ```
+     * @param pattern
+     * @returns
+     */
+    static arrayWith(pattern) {
+        return assertions_1.Match.arrayWith(pattern);
+    }
+    /**
+     * Same method as `Match.arrayEquals` but provides type hints and validate type match
+     ```js
+      // this is a right code
+      template.hasResource(
+        AWS_EC2_EIP({
+          Properties: {
+            Tags: ExtraMatch.arrayEquals<Tag[]>([
+              {
+                Key: "key1",
+                Value: "val1",
+              },
+              {
+                Key: "key2",
+                Value: "val2",
+              },
+            ]),
+          },
+        })
+      );
+      // this is a wrong code(type mismatch will be detected and ts-error will be raised)
+      template.hasResource(
+        AWS_EC2_EIP({
+          Properties: {
+            Tags: ExtraMatch.arrayEquals<Tag[]>([
+              {
+                Key: "key1",
+                Value: "val1",
+              },
+              {
+                Key: 100,
+                Value: 200,
+              },
+            ]),
+          },
+        })
+      );
+     ```
+     * @param pattern
+     * @returns
+     */
+    static arrayEquals(pattern) {
+        return assertions_1.Match.arrayEquals(pattern);
+    }
+    /**
+     * Same method as `Match.objectLike` but provides type hints and validate type match
+     ```js
+     // this is a right code
+      template.hasResource(
+        AWS_EC2_INSTANCE({
+          Properties: {
+            BlockDeviceMappings: [
+              {
+                DeviceName: "test",
+                Ebs: ExtraMatch.objectLike<Ebs>({
+                  VolumeSize: 10,
+                }),
+              },
+            ],
+          },
+        })
+      );
+      // this is a wrong code(type mismatch will be detected and ts-error will be raised)
+      template.hasResource(
+        AWS_EC2_INSTANCE({
+          Properties: {
+            BlockDeviceMappings: [
+              {
+                DeviceName: "test",
+                Ebs: ExtraMatch.objectLike<Ebs>({
+                  VolumeSize: "10",
+                }),
+              },
+            ],
+          },
+        })
+      );
+     * @param pattern
+     * @returns
+     */
+    static objectLike(pattern) {
+        return assertions_1.Match.objectLike(pattern);
+    }
+    /**
+     * Same method as `Match.objectEquals` but provides type hints and validate type match
+     ```js
+     // this is a right code
+      template.hasResource(
+        AWS_EC2_EIP({
+          Properties: {
+            // You can nest TypedMatcher(use TypedMatcher inside TypedMatcher)
+            Tags: ExtraMatch.arrayWith<Tag[]>([
+              ExtraMatch.objectEquals<Tag>({
+                Key: "key1",
+                Value: "val1",
+              }),
+            ]),
+          },
+        })
+      );
+      // this is a wrong code(type mismatch will be detected and ts-error will be raised)
+      template.hasResource(
+        AWS_EC2_EIP({
+          Properties: {
+            Tags: ExtraMatch.arrayWith<Tag[]>([
+              ExtraMatch.objectEquals<Tag>({
+                Key: "key1",
+                Value: 100,
+              }),
+            ]),
+          },
+        })
+      );
+     * @param pattern
+     * @returns
+     */
+    static objectEquals(pattern) {
+        return assertions_1.Match.objectEquals(pattern);
+    }
+    /**
+     * Same method as `Match.not` but provides type hints and validate type match
+     ```js
+      // this is a right code
+      template.hasResource(
+        AWS_EC2_INSTANCE({
+          Properties: {
+            ImageId: ExtraMatch.not("ami-12345"),
+          },
+        })
+      );
+      // this is a wrong code(type mismatch will be detected and ts-error will be raised)
+      template.hasResource(
+        AWS_EC2_INSTANCE({
+          Properties: {
+            ImageId: ExtraMatch.not(100),
+          },
+        })
+      );
+     ```
+     * Same method as `Match.not` but provides type hints and validate type match
+     * @param pattern
+     * @returns
+     */
+    // TODO: why this expression `T extends never ? never : T` is required but this is required
+    static not(pattern) {
+        return assertions_1.Match.not(pattern);
+    }
+    /**
+     * Same method as `Match.exact` but provides type hints and validate type match
+     ```js
+      // this is a right code
+      template.hasResource(
+        AWS_EC2_INSTANCE({
+          Properties: {
+            InstanceType: ExtraMatch.exact("t2.micro"),
+          },
+        })
+      );
+      // this is a wrong code(type mismatch will be detected and ts-error will be raised)
+      template.hasResource(
+        AWS_EC2_INSTANCE({
+          Properties: {
+            InstanceType: ExtraMatch.exact(false),
+          },
+        })
+      );
+     ```
+     * @param pattern
+     * @returns
+     */
+    static exact(pattern) {
+        return assertions_1.Match.exact(pattern);
+    }
 }
 exports.ExtraMatch = ExtraMatch;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"assertions.js","sourceRoot":"","sources":["assertions.ts"],"names":[],"mappings":"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","sourcesContent":["import { Template, Match, Matcher } from \"aws-cdk-lib/assertions\";\nimport {\n  Condition,\n  InputResource,\n  Mapping,\n  OutputResource,\n  InputParamter,\n  OutputParameter,\n  ReturnValue,\n  InputOutput,\n  OutputOutput,\n  InputResourceWithoutType,\n  IAMPolicyDocument,\n  AlsoMatcher,\n  TypedMatcher,\n} from \"./typed-resource\";\n\n/**\n * almost same class as `Template` class at \"aws-cdk-lib/assertions\", but you can use this with proper type definitions\n */\nexport class TypedTemplate {\n  template: Template;\n  private constructor(template: Template) {\n    this.template = template;\n  }\n\n  private get<T>(type: string, def: any, array: T[]): T {\n    if (array.length === 0) {\n      throw Error(`${type} not found with definition : ${JSON.stringify(def)}`);\n    }\n    if (array.length > 1) {\n      throw Error(\n        `multiple ${type} found with definition : ${JSON.stringify(def)}`\n      );\n    }\n    return array[0];\n  }\n\n  /**\n   * same function as `Template.fromStack` but returns `TypedTemplate`\n   * @param args\n   * @returns\n   */\n  static fromStack(\n    ...args: Parameters<typeof Template.fromStack>\n  ): TypedTemplate {\n    return new TypedTemplate(Template.fromStack(...args));\n  }\n  /**\n   * same function as `Template.fromJSON` but returns `TypedTemplate`\n   * @param args\n   * @returns\n   */\n  static fromJSON(\n    ...args: Parameters<typeof Template.fromJSON>\n  ): TypedTemplate {\n    return new TypedTemplate(Template.fromJSON(...args));\n  }\n  /**\n   * same function as `Template.fromString` but returns `TypedTemplate`\n   * @param args\n   * @returns\n   */\n  static fromString(\n    ...args: Parameters<typeof Template.fromString>\n  ): TypedTemplate {\n    return new TypedTemplate(Template.fromString(...args));\n  }\n\n  /**\n   * same function as `Template.resourceCountIs`\n   *\n   * use this method like below:\n   *\n   * ```js\n   * template.resourceCountIs(AWS_EC2_SUBNET, 3)\n   * ```\n   * @param type\n   * @param count\n   */\n  resourceCountIs<T>(\n    type: (resource?: InputResourceWithoutType<T>) => InputResource<T>,\n    count: number\n  ): void {\n    this.template.resourceCountIs(type().Type, count);\n  }\n  /**\n   * same function as `Template.resourcePropertiesCountIs`\n   * @param r\n   * @param count\n   */\n  resourcePropertiesCountIs<T>(r: InputResource<T>, count: number): void {\n    this.template.resourcePropertiesCountIs(r.Type, r.Properties, count);\n  }\n  /**\n   * same function as `Template.hasResourceProperties`\n   * @param r\n   */\n  hasResourceProperties<T>(r: InputResource<T>): void {\n    this.template.hasResourceProperties(r.Type, r.Properties);\n  }\n  /**\n   * same function as `Template.hasResource`\n   * @param r\n   */\n  hasResource<T>(r: InputResource<T>): void {\n    this.template.hasResource(r.Type, r);\n  }\n  /**\n   * same function as `Template.findResources`\n   * @param r\n   * @returns\n   */\n  findResources<T>(r: InputResource<T>): ReturnValue<OutputResource<T>>[] {\n    const resources = this.template.findResources(r.Type, r) as {\n      [id in string]: OutputResource<T>;\n    };\n    return Object.entries(resources).map(([id, resource]) => {\n      return { id: id, def: resource };\n    });\n  }\n  /**\n   * same function as `Template.allResources`\n   * @param r\n   */\n  allResources<T>(r: InputResource<T>): void {\n    this.template.allResources(r.Type, r);\n  }\n  /**\n   * same function as `Template.allResourceProperties`\n   * @param r\n   */\n  allResourcesProperties<T>(r: InputResource<T>): void {\n    this.template.allResourcesProperties(r.Type, r.Properties);\n  }\n  /**\n   * same function as `Template.hasParameter`\n   * @param logicalId\n   * @param props\n   */\n  hasParameter(logicalId: string, props: InputParamter): void {\n    this.template.hasParameter(logicalId, props);\n  }\n  /**\n   * same function as `Template.findParameters`\n   * @param logicalId\n   * @param props\n   * @returns\n   */\n  findParameters(\n    logicalId: string,\n    props?: InputParamter\n  ): ReturnValue<OutputParameter>[] {\n    const parameters = this.template.findParameters(logicalId, props);\n    return Object.entries(parameters).map(([id, parameter]) => {\n      return { id: id, def: parameter as OutputParameter };\n    });\n  }\n\n  /**\n   * same function as `Template.hasOutput`\n   * @param logicalId\n   * @param props\n   */\n  hasOutput(logicalId: string, props: InputOutput): void {\n    this.template.hasOutput(logicalId, props);\n  }\n  /**\n   * same function as `Template.findOutputs`\n   * @param logicalId\n   * @param props\n   * @returns\n   */\n  findOutputs(\n    logicalId: string,\n    props?: InputOutput\n  ): ReturnValue<OutputOutput>[] {\n    const outputs = this.template.findOutputs(logicalId, props);\n    return Object.entries(outputs).map(([id, output]) => {\n      return { id: id, def: output as OutputOutput };\n    });\n  }\n  /**\n   * same function as `Template.hasMapping`\n   * @param logicalId\n   * @param props\n   */\n  hasMapping(logicalId: string, props: any): void {\n    this.template.hasMapping(logicalId, props);\n  }\n  /**\n   * same function as `Template.findMappings`\n   * @param logicalId\n   * @param props\n   * @returns\n   */\n  findMappings(logicalId: string, props?: any): ReturnValue<Mapping>[] {\n    const mappings = this.template.findMappings(logicalId, props);\n    return Object.entries(mappings).map(([id, mapping]) => {\n      return { id: id, def: mapping };\n    });\n  }\n  /**\n   * same function as `Template.hasCondition`\n   * @param logicalId\n   * @param props\n   */\n  hasCondition(logicalId: string, props: any): void {\n    this.template.hasCondition(logicalId, props);\n  }\n  /**\n   * same function as `Template.findConditions`\n   * @param logicalId\n   * @param props\n   * @returns\n   */\n  findConditions(logicalId: string, props?: any): ReturnValue<Condition>[] {\n    const conditions = this.template.findConditions(logicalId, props);\n    return Object.entries(conditions).map(([id, condition]) => {\n      return { id: id, def: condition };\n    });\n  }\n\n  /**\n   * return a single resource for specified type and definition.\n   *\n   * - if no resource matched with the specified type and definition, raise Error.\n   * - if multiple resources matched, raise Error\n   * @param args\n   * @returns\n   */\n  getResource<T>(\n    ...args: Parameters<typeof this.findResources<T>>\n  ): ReturnType<typeof this.findResources<T>> extends (infer U)[] ? U : never {\n    return this.get(\"resource\", args[0], this.findResources(args[0]));\n  }\n}\n\nexport interface JoinProps {\n  /**\n   * @default \"\"\n   */\n  delimiter?: string;\n  arrayWith: any[];\n}\n/**\n * provides some syntax sugars for `Match` class at `aws-cdk-lib/assertions`\n */\nexport class ExtraMatch extends Match {\n  /**\n   * same function as `Match.objectEquals({ Ref: logicalId })`\n   * @param logicalId\n   * @returns\n   */\n  static ref(logicalId: string): Matcher {\n    return Match.objectEquals({ Ref: logicalId });\n  }\n  /**\n   * same function as `Match.objectEquals({\"Fn::GetAtt\": [logicalId, attribute]})`\n   * @param logicalId\n   * @param attribute\n   * @returns\n   */\n  static getAtt(logicalId: string, attribute: string): Matcher {\n    return Match.objectEquals({ \"Fn::GetAtt\": [logicalId, attribute] });\n  }\n  /**\n   * same function as `Match.objectEquals({\"Fn::GetAtt\": [logicalId, \"Arn\"]})`\n   * @param logicalId\n   * @returns\n   */\n  static getAttArn(logicalId: string): Matcher {\n    return this.getAtt(logicalId, \"Arn\");\n  }\n\n  static arrayWith<T extends any[]>(pattern: AlsoMatcher<T>): TypedMatcher<T> {\n    return Match.arrayWith(pattern);\n  }\n  static arrayEquals<T extends any[]>(\n    pattern: AlsoMatcher<T>\n  ): TypedMatcher<T> {\n    return Match.arrayEquals(pattern);\n  }\n  static objectLike<T extends { [key: string]: any }>(\n    pattern: AlsoMatcher<T>\n  ): TypedMatcher<T> {\n    return Match.objectLike(pattern) as TypedMatcher<T>;\n  }\n  static objectEquals<T extends { [key: string]: any }>(\n    pattern: AlsoMatcher<T>\n  ): TypedMatcher<T> {\n    return Match.objectEquals(pattern);\n  }\n  static not<T>(pattern: AlsoMatcher<T>): TypedMatcher<T> {\n    return Match.not(pattern);\n  }\n  static exact<T>(pattern: AlsoMatcher<T>): TypedMatcher<T> {\n    return Match.exact(pattern);\n  }\n\n  /**\n   * same function as below:\n   * \n   * ```js\n   * Match.objectLike({\n   *  \"Fn::Join\": [props.delimiter ?? \"\", Match.arrayWith(props.arrayWith)],\n    });\n   * ```\n   * @param props \n   * @returns \n   */\n  static joinLike(props: JoinProps): Matcher {\n    return Match.objectLike({\n      \"Fn::Join\": [props.delimiter ?? \"\", Match.arrayWith(props.arrayWith)],\n    });\n  }\n\n  // /**\n  //  * returns Match instance that matches regional resource ARN like : `arn:aws:logs:ap-northeast-1:123456789012:log-group:/log-group-name:log-stream:log-stream-name`\n  //  * @param elems\n  //  * @returns\n  //  */\n  // static regionalArnLike(elems: AlsoMatcher<ArnElements>): Matcher {\n  //   return Match.objectEquals({\n  //     \"Fn::Join\": Match.arrayWith([\n  //       \"\",\n  //       Match.arrayWith([\n  //         \"arn:\",\n  //         elems.partition ?? { Ref: \"AWS::Partition\" },\n  //         Match.stringLikeRegexp(`:${elems.service ?? \"*\"}:`),\n  //         elems.region ?? { Ref: \"AWS::Region\" },\n  //         elems.account ?? { Ref: \"AWS::AccountId\" },\n  //         ...(elems.rest instanceof Matcher\n  //           ? [elems.rest]\n  //           : (elems.rest ?? [])),\n  //       ]),\n  //     ]),\n  //   });\n  // }\n\n  // /**\n  //  * returns Match instance that matches global resource ARN like : `arn:aws:iam::123456789012:role/role-name`\n  //  * @param elems\n  //  * @returns\n  //  */\n  // static globalArn(\n  //   elems: Omit<ArnElements, \"region\">,\n  //   delimiter: string = \"\"\n  // ): Matcher {\n  //   return Match.objectEquals({\n  //     \"Fn::Join\": Match.arrayEquals([\n  //       delimiter,\n  //       Match.arrayWith([\n  //         \"arn:\",\n  //         elems.partition ?? { Ref: \"AWS::Partition\" },\n  //         Match.stringLikeRegexp(`:${elems.service ?? \"*\"}::`),\n  //         elems.account ?? { Ref: \"AWS::AccountId\" },\n  //         ...(elems.rest instanceof Matcher\n  //           ? [elems.rest]\n  //           : (elems.rest ?? [])),\n  //       ]),\n  //     ]),\n  //   });\n  // }\n\n  static iamPolicyLike(doc: AlsoMatcher<IAMPolicyDocument>): Matcher {\n    return Match.objectLike(doc);\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"assertions.js","sourceRoot":"","sources":["assertions.ts"],"names":[],"mappings":"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","sourcesContent":["import { Template, Match, Matcher } from \"aws-cdk-lib/assertions\";\nimport {\n  Condition,\n  InputResource,\n  Mapping,\n  OutputResource,\n  InputParamter,\n  OutputParameter,\n  ReturnValue,\n  InputOutput,\n  OutputOutput,\n  InputResourceWithoutType,\n  IAMPolicyDocument,\n  AlsoMatcher,\n  TypedMatcher,\n} from \"./typed-resource\";\n\n/**\n * almost same class as `Template` class at \"aws-cdk-lib/assertions\", but you can use this with proper type definitions\n */\nexport class TypedTemplate {\n  template: Template;\n  private constructor(template: Template) {\n    this.template = template;\n  }\n\n  private get<T>(type: string, def: any, array: T[]): T {\n    if (array.length === 0) {\n      throw Error(`${type} not found with definition : ${JSON.stringify(def)}`);\n    }\n    if (array.length > 1) {\n      throw Error(\n        `multiple ${type} found with definition : ${JSON.stringify(def)}`\n      );\n    }\n    return array[0];\n  }\n\n  /**\n   * same function as `Template.fromStack` but returns `TypedTemplate`\n   * @param args\n   * @returns\n   */\n  static fromStack(\n    ...args: Parameters<typeof Template.fromStack>\n  ): TypedTemplate {\n    return new TypedTemplate(Template.fromStack(...args));\n  }\n  /**\n   * same function as `Template.fromJSON` but returns `TypedTemplate`\n   * @param args\n   * @returns\n   */\n  static fromJSON(\n    ...args: Parameters<typeof Template.fromJSON>\n  ): TypedTemplate {\n    return new TypedTemplate(Template.fromJSON(...args));\n  }\n  /**\n   * same function as `Template.fromString` but returns `TypedTemplate`\n   * @param args\n   * @returns\n   */\n  static fromString(\n    ...args: Parameters<typeof Template.fromString>\n  ): TypedTemplate {\n    return new TypedTemplate(Template.fromString(...args));\n  }\n\n  /**\n   * same function as `Template.resourceCountIs`\n   *\n   * use this method like below:\n   *\n   * ```js\n   * template.resourceCountIs(AWS_EC2_SUBNET, 3)\n   * ```\n   * @param type\n   * @param count\n   */\n  resourceCountIs<T>(\n    type: (resource?: InputResourceWithoutType<T>) => InputResource<T>,\n    count: number\n  ): void {\n    this.template.resourceCountIs(type().Type, count);\n  }\n  /**\n   * same function as `Template.resourcePropertiesCountIs`\n   * @param r\n   * @param count\n   */\n  resourcePropertiesCountIs<T>(r: InputResource<T>, count: number): void {\n    this.template.resourcePropertiesCountIs(r.Type, r.Properties, count);\n  }\n  /**\n   * same function as `Template.hasResourceProperties`\n   * @param r\n   */\n  hasResourceProperties<T>(r: InputResource<T>): void {\n    this.template.hasResourceProperties(r.Type, r.Properties);\n  }\n  /**\n   * same function as `Template.hasResource`\n   * @param r\n   */\n  hasResource<T>(r: InputResource<T>): void {\n    this.template.hasResource(r.Type, r);\n  }\n  /**\n   * same function as `Template.findResources`\n   * @param r\n   * @returns\n   */\n  findResources<T>(r: InputResource<T>): ReturnValue<OutputResource<T>>[] {\n    const resources = this.template.findResources(r.Type, r) as {\n      [id in string]: OutputResource<T>;\n    };\n    return Object.entries(resources).map(([id, resource]) => {\n      return { id: id, def: resource };\n    });\n  }\n  /**\n   * same function as `Template.allResources`\n   * @param r\n   */\n  allResources<T>(r: InputResource<T>): void {\n    this.template.allResources(r.Type, r);\n  }\n  /**\n   * same function as `Template.allResourceProperties`\n   * @param r\n   */\n  allResourcesProperties<T>(r: InputResource<T>): void {\n    this.template.allResourcesProperties(r.Type, r.Properties);\n  }\n  /**\n   * same function as `Template.hasParameter`\n   * @param logicalId\n   * @param props\n   */\n  hasParameter(logicalId: string, props: InputParamter): void {\n    this.template.hasParameter(logicalId, props);\n  }\n  /**\n   * same function as `Template.findParameters`\n   * @param logicalId\n   * @param props\n   * @returns\n   */\n  findParameters(\n    logicalId: string,\n    props?: InputParamter\n  ): ReturnValue<OutputParameter>[] {\n    const parameters = this.template.findParameters(logicalId, props);\n    return Object.entries(parameters).map(([id, parameter]) => {\n      return { id: id, def: parameter as OutputParameter };\n    });\n  }\n\n  /**\n   * same function as `Template.hasOutput`\n   * @param logicalId\n   * @param props\n   */\n  hasOutput(logicalId: string, props: InputOutput): void {\n    this.template.hasOutput(logicalId, props);\n  }\n  /**\n   * same function as `Template.findOutputs`\n   * @param logicalId\n   * @param props\n   * @returns\n   */\n  findOutputs(\n    logicalId: string,\n    props?: InputOutput\n  ): ReturnValue<OutputOutput>[] {\n    const outputs = this.template.findOutputs(logicalId, props);\n    return Object.entries(outputs).map(([id, output]) => {\n      return { id: id, def: output as OutputOutput };\n    });\n  }\n  /**\n   * same function as `Template.hasMapping`\n   * @param logicalId\n   * @param props\n   */\n  hasMapping(logicalId: string, props: any): void {\n    this.template.hasMapping(logicalId, props);\n  }\n  /**\n   * same function as `Template.findMappings`\n   * @param logicalId\n   * @param props\n   * @returns\n   */\n  findMappings(logicalId: string, props?: any): ReturnValue<Mapping>[] {\n    const mappings = this.template.findMappings(logicalId, props);\n    return Object.entries(mappings).map(([id, mapping]) => {\n      return { id: id, def: mapping };\n    });\n  }\n  /**\n   * same function as `Template.hasCondition`\n   * @param logicalId\n   * @param props\n   */\n  hasCondition(logicalId: string, props: any): void {\n    this.template.hasCondition(logicalId, props);\n  }\n  /**\n   * same function as `Template.findConditions`\n   * @param logicalId\n   * @param props\n   * @returns\n   */\n  findConditions(logicalId: string, props?: any): ReturnValue<Condition>[] {\n    const conditions = this.template.findConditions(logicalId, props);\n    return Object.entries(conditions).map(([id, condition]) => {\n      return { id: id, def: condition };\n    });\n  }\n\n  /**\n   * return a single resource for specified type and definition.\n   *\n   * - if no resource matched with the specified type and definition, raise Error.\n   * - if multiple resources matched, raise Error\n   * @param args\n   * @returns\n   */\n  getResource<T>(\n    ...args: Parameters<typeof this.findResources<T>>\n  ): ReturnType<typeof this.findResources<T>> extends (infer U)[] ? U : never {\n    return this.get(\"resource\", args[0], this.findResources(args[0]));\n  }\n}\n\nexport interface JoinProps {\n  /**\n   * @default \"\"\n   */\n  delimiter?: string;\n  arrayWith: any[];\n}\n/**\n * provides some syntax sugars for `Match` class at `aws-cdk-lib/assertions`\n */\nexport class ExtraMatch {\n  /**\n   * same function as `Match.objectEquals({ Ref: logicalId })`\n   * @param logicalId\n   * @returns\n   */\n  static ref(logicalId: string): Matcher {\n    return Match.objectEquals({ Ref: logicalId });\n  }\n  /**\n   * same function as `Match.objectEquals({\"Fn::GetAtt\": [logicalId, attribute]})`\n   * @param logicalId\n   * @param attribute\n   * @returns\n   */\n  static getAtt(logicalId: string, attribute: string): Matcher {\n    return Match.objectEquals({ \"Fn::GetAtt\": [logicalId, attribute] });\n  }\n  /**\n   * same function as `Match.objectEquals({\"Fn::GetAtt\": [logicalId, \"Arn\"]})`\n   * @param logicalId\n   * @returns\n   */\n  static getAttArn(logicalId: string): Matcher {\n    return this.getAtt(logicalId, \"Arn\");\n  }\n  /**\n   * same function as below:\n   * \n   * ```js\n   * Match.objectLike({\n   *  \"Fn::Join\": [props.delimiter ?? \"\", Match.arrayWith(props.arrayWith)],\n    });\n   * ```\n   * @param props \n   * @returns \n   */\n  static joinLike(props: JoinProps): Matcher {\n    return Match.objectLike({\n      \"Fn::Join\": [props.delimiter ?? \"\", Match.arrayWith(props.arrayWith)],\n    });\n  }\n\n  /**\n   You can define Matcher for IAM Policy Document with type hints.\n   ```js\n    template.hasResource(\n      AWS_IAM_ROLE({\n        Properties: {\n          AssumeRolePolicyDocument: ExtraMatch.iamPolicyLike({\n            Statement: [\n              {\n                Principal: { Service: \"ec2.amazonaws.com\" },\n              },\n            ],\n          }),\n        },\n      })\n    );\n   ```\n   * @param doc \n   * @returns \n   */\n  static iamPolicyLike(doc: AlsoMatcher<IAMPolicyDocument>): Matcher {\n    return Match.objectLike(doc);\n  }\n  /**\n   Same method as `Match.arrayWith` but provides type hints and validate type match \n   ```js\n    // this is a right code\n    template.hasResource(\n      AWS_EC2_EIP({\n        Properties: {\n          Tags: ExtraMatch.arrayWith<Tag[]>([\n            {\n              Key: \"key2\",\n              Value: \"val2\",\n            },\n          ]),\n        },\n      })\n    );\n    // this is a wrong code(type mismatch will be detected and ts-error will be raised)\n    template.hasResource(\n      AWS_EC2_EIP({\n        Properties: {\n          Tags: ExtraMatch.arrayWith<string[]>([\n            \"hoge\", \"fuga\"\n          ]),\n        },\n      })\n    );\n   ```\n   * @param pattern \n   * @returns \n   */\n  static arrayWith<T extends any[]>(pattern: AlsoMatcher<T>): TypedMatcher<T> {\n    return Match.arrayWith(pattern) as unknown as TypedMatcher<T>;\n  }\n  /**\n   * Same method as `Match.arrayEquals` but provides type hints and validate type match \n   ```js\n    // this is a right code\n    template.hasResource(\n      AWS_EC2_EIP({\n        Properties: {\n          Tags: ExtraMatch.arrayEquals<Tag[]>([\n            {\n              Key: \"key1\",\n              Value: \"val1\",\n            },\n            {\n              Key: \"key2\",\n              Value: \"val2\",\n            },\n          ]),\n        },\n      })\n    );\n    // this is a wrong code(type mismatch will be detected and ts-error will be raised)\n    template.hasResource(\n      AWS_EC2_EIP({\n        Properties: {\n          Tags: ExtraMatch.arrayEquals<Tag[]>([\n            {\n              Key: \"key1\",\n              Value: \"val1\",\n            },\n            {\n              Key: 100,\n              Value: 200,\n            },\n          ]),\n        },\n      })\n    );\n   ```\n   * @param pattern \n   * @returns \n   */\n  static arrayEquals<T extends any[]>(\n    pattern: AlsoMatcher<T>\n  ): TypedMatcher<T> {\n    return Match.arrayEquals(pattern);\n  }\n  /**\n   * Same method as `Match.objectLike` but provides type hints and validate type match \n   ```js\n   // this is a right code\n    template.hasResource(\n      AWS_EC2_INSTANCE({\n        Properties: {\n          BlockDeviceMappings: [\n            {\n              DeviceName: \"test\",\n              Ebs: ExtraMatch.objectLike<Ebs>({\n                VolumeSize: 10,\n              }),\n            },\n          ],\n        },\n      })\n    );\n    // this is a wrong code(type mismatch will be detected and ts-error will be raised)\n    template.hasResource(\n      AWS_EC2_INSTANCE({\n        Properties: {\n          BlockDeviceMappings: [\n            {\n              DeviceName: \"test\",\n              Ebs: ExtraMatch.objectLike<Ebs>({\n                VolumeSize: \"10\",\n              }),\n            },\n          ],\n        },\n      })\n    );\n   * @param pattern \n   * @returns \n   */\n  static objectLike<T extends { [key: string]: any }>(\n    pattern: AlsoMatcher<T>\n  ): TypedMatcher<T> {\n    return Match.objectLike(pattern);\n  }\n  /**\n   * Same method as `Match.objectEquals` but provides type hints and validate type match \n   ```js\n   // this is a right code\n    template.hasResource(\n      AWS_EC2_EIP({\n        Properties: {\n          // You can nest TypedMatcher(use TypedMatcher inside TypedMatcher)\n          Tags: ExtraMatch.arrayWith<Tag[]>([\n            ExtraMatch.objectEquals<Tag>({\n              Key: \"key1\",\n              Value: \"val1\",\n            }),\n          ]),\n        },\n      })\n    );\n    // this is a wrong code(type mismatch will be detected and ts-error will be raised)\n    template.hasResource(\n      AWS_EC2_EIP({\n        Properties: {\n          Tags: ExtraMatch.arrayWith<Tag[]>([\n            ExtraMatch.objectEquals<Tag>({\n              Key: \"key1\",\n              Value: 100,\n            }),\n          ]),\n        },\n      })\n    );\n   * @param pattern \n   * @returns \n   */\n  static objectEquals<T extends { [key: string]: any }>(\n    pattern: AlsoMatcher<T>\n  ): TypedMatcher<T> {\n    return Match.objectEquals(pattern);\n  }\n  /**\n   * Same method as `Match.not` but provides type hints and validate type match \n   ```js\n    // this is a right code\n    template.hasResource(\n      AWS_EC2_INSTANCE({\n        Properties: {\n          ImageId: ExtraMatch.not(\"ami-12345\"),\n        },\n      })\n    );\n    // this is a wrong code(type mismatch will be detected and ts-error will be raised)\n    template.hasResource(\n      AWS_EC2_INSTANCE({\n        Properties: {\n          ImageId: ExtraMatch.not(100),\n        },\n      })\n    );\n   ```\n   * Same method as `Match.not` but provides type hints and validate type match \n   * @param pattern \n   * @returns \n   */\n  // TODO: why this expression `T extends never ? never : T` is required but this is required\n  static not<T>(pattern: AlsoMatcher<T extends never ? never : T>): TypedMatcher<T> {\n    return Match.not(pattern);\n  }\n  /**\n   * Same method as `Match.exact` but provides type hints and validate type match \n   ```js\n    // this is a right code\n    template.hasResource(\n      AWS_EC2_INSTANCE({\n        Properties: {\n          InstanceType: ExtraMatch.exact(\"t2.micro\"),\n        },\n      })\n    );\n    // this is a wrong code(type mismatch will be detected and ts-error will be raised)\n    template.hasResource(\n      AWS_EC2_INSTANCE({\n        Properties: {\n          InstanceType: ExtraMatch.exact(false),\n        },\n      })\n    );\n   ```\n   * @param pattern \n   * @returns \n   */\n  static exact<T>(pattern: AlsoMatcher<T extends never ? never : T>): TypedMatcher<T> {\n    return Match.exact(pattern);\n  }\n}\n"]}

package/lib/typed-resource.d.ts

@@ -1,6 +1,6 @@
 import { Matcher } from "aws-cdk-lib/assertions";
 type Primitives = string | number | boolean | undefined | null | symbol | bigint | string[] | number[] | boolean[] | bigint[];
-export type TypedMatcher<T> = Matcher;
+export type TypedMatcher<T> = Matcher | T;
 /**
  * make properties of `T` asignable Matcher recirsively and other arbitrary json objects for primitive type fields
  */