konokenj.cdk-api-mcp-server 0.1.0__py3-none-any.whl → 0.2.1__py3-none-any.whl

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-appsync/integ.graphql-grant-imported-api.ts

@@ -0,0 +1,90 @@
+import { join } from 'path';
+import { UserPool } from 'aws-cdk-lib/aws-cognito';
+import { App, RemovalPolicy, Stack, StackProps } from 'aws-cdk-lib';
+import {
+  AuthorizationType,
+  GraphqlApi,
+  UserPoolDefaultAction,
+  SchemaFile,
+  IamResource,
+} from 'aws-cdk-lib/aws-appsync';
+import { IntegTest } from '@aws-cdk/integ-tests-alpha';
+import { ServicePrincipal, Role } from 'aws-cdk-lib/aws-iam';
+
+class OriginalStack extends Stack {
+  public readonly apiId: string;
+
+  constructor(scope: App, id: string) {
+    super(scope, id);
+
+    const userPool = new UserPool(this, 'Pool', {
+      userPoolName: 'myPool',
+      removalPolicy: RemovalPolicy.DESTROY,
+    });
+
+    const api = new GraphqlApi(this, 'Api', {
+      name: 'Integ_Test_IAM',
+      schema: SchemaFile.fromAsset(join(__dirname, 'integ.graphql-iam.graphql')),
+      authorizationConfig: {
+        defaultAuthorization: {
+          authorizationType: AuthorizationType.USER_POOL,
+          userPoolConfig: {
+            userPool,
+            defaultAction: UserPoolDefaultAction.ALLOW,
+          },
+        },
+        additionalAuthorizationModes: [
+          {
+            authorizationType: AuthorizationType.IAM,
+          },
+        ],
+      },
+    });
+
+    this.apiId = api.apiId;
+  }
+}
+
+interface ImportedStackProps extends StackProps {
+  apiId: string;
+}
+
+class ImportedStack extends Stack {
+  constructor(scope: App, id: string, props: ImportedStackProps) {
+    super(scope, id);
+
+    const importedApi = GraphqlApi.fromGraphqlApiAttributes(originalStack, 'ImportedApi', {
+      graphqlApiId: `${props.apiId}`,
+    });
+
+    const lambdaRole = new Role(this, 'lambdaRole', {
+      assumedBy: new ServicePrincipal('lambda.amazonaws.com'),
+    });
+    importedApi.grant(lambdaRole, IamResource.custom('types/Query/fields/getPost'), 'appsync:GraphQL');
+
+    const mutationLambdaRole = new Role(this, 'mutatioLambdaRole', {
+      assumedBy: new ServicePrincipal('lambda.amazonaws.com'),
+    });
+    importedApi.grantMutation(mutationLambdaRole);
+
+    const queryLambdaRole = new Role(this, 'queryLambdaRole', {
+      assumedBy: new ServicePrincipal('lambda.amazonaws.com'),
+    });
+    importedApi.grantQuery(queryLambdaRole);
+
+    const subscriptionLambdaRole = new Role(this, 'subscriptionLambdaRole', {
+      assumedBy: new ServicePrincipal('lambda.amazonaws.com'),
+    });
+    importedApi.grantSubscription(subscriptionLambdaRole);
+  }
+}
+
+const app = new App();
+const originalStack = new OriginalStack(app, 'aws-appsync-integ');
+const importedStack = new ImportedStack(app, 'imported-stack', {
+  apiId: originalStack.apiId,
+});
+
+new IntegTest(app, 'GraphqlGrantImportedApiInteg', {
+  testCases: [importedStack],
+});

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-appsync/integ.graphql-iam.ts

@@ -0,0 +1,115 @@
+import { join } from 'path';
+import { UserPool } from 'aws-cdk-lib/aws-cognito';
+import { AttributeType, BillingMode, Table } from 'aws-cdk-lib/aws-dynamodb';
+import { Role, ServicePrincipal } from 'aws-cdk-lib/aws-iam';
+import { Code, Function } from 'aws-cdk-lib/aws-lambda';
+import { App, RemovalPolicy, Stack } from 'aws-cdk-lib';
+import {
+  AuthorizationType,
+  GraphqlApi,
+  MappingTemplate,
+  PrimaryKey,
+  UserPoolDefaultAction,
+  Values,
+  IamResource,
+  SchemaFile,
+} from 'aws-cdk-lib/aws-appsync';
+import { STANDARD_NODEJS_RUNTIME } from '../../config';
+
+/*
+ * Creates an Appsync GraphQL API and Lambda with IAM Roles.
+ * Testing for IAM Auth and grantFullAccess.
+ *
+ * Stack verification steps:
+ * Install dependencies and deploy integration test. Invoke Lambda
+ * function with different permissions to test policies.
+ *
+ * -- bash verify.integ.graphql-iam.sh --start             -- get dependencies/deploy    --
+ * -- aws lambda list-functions                            -- obtain testFail/testQuery  --
+ * -- aws lambda invoke /dev/stdout --function-name [FAIL] -- fails beacuse no IAM Role` --
+ * -- aws lambda invoke /dev/stdout --function-name [Query]-- succeeds with empty get  ` --
+ * -- bash verify.integ.graphql-iam.sh --clean             -- clean dependencies/deploy  --
+ */
+
+const app = new App({
+  postCliContext: {
+    '@aws-cdk/aws-lambda:useCdkManagedLogGroup': false,
+  },
+});
+const stack = new Stack(app, 'aws-appsync-integ');
+const userPool = new UserPool(stack, 'Pool', {
+  userPoolName: 'myPool',
+});
+
+const api = new GraphqlApi(stack, 'Api', {
+  name: 'Integ_Test_IAM',
+  schema: SchemaFile.fromAsset(join(__dirname, 'integ.graphql-iam.graphql')),
+  authorizationConfig: {
+    defaultAuthorization: {
+      authorizationType: AuthorizationType.USER_POOL,
+      userPoolConfig: {
+        userPool,
+        defaultAction: UserPoolDefaultAction.ALLOW,
+      },
+    },
+    additionalAuthorizationModes: [
+      {
+        authorizationType: AuthorizationType.IAM,
+      },
+    ],
+  },
+});
+
+const testTable = new Table(stack, 'TestTable', {
+  billingMode: BillingMode.PAY_PER_REQUEST,
+  partitionKey: {
+    name: 'id',
+    type: AttributeType.STRING,
+  },
+  removalPolicy: RemovalPolicy.DESTROY,
+});
+
+const testDS = api.addDynamoDbDataSource('ds', testTable, { name: 'testDataSource' });
+
+testDS.createResolver('QueryGetTest', {
+  typeName: 'Query',
+  fieldName: 'getTest',
+  requestMappingTemplate: MappingTemplate.dynamoDbGetItem('id', 'id'),
+  responseMappingTemplate: MappingTemplate.dynamoDbResultItem(),
+});
+
+testDS.createResolver('QueryGetTests', {
+  typeName: 'Query',
+  fieldName: 'getTests',
+  requestMappingTemplate: MappingTemplate.dynamoDbScanTable(),
+  responseMappingTemplate: MappingTemplate.dynamoDbResultList(),
+});
+
+testDS.createResolver('MutationAddTest', {
+  typeName: 'Mutation',
+  fieldName: 'addTest',
+  requestMappingTemplate: MappingTemplate.dynamoDbPutItem(PrimaryKey.partition('id').auto(), Values.projecting('test')),
+  responseMappingTemplate: MappingTemplate.dynamoDbResultItem(),
+});
+
+const lambdaIAM = new Role(stack, 'LambdaIAM', { assumedBy: new ServicePrincipal('lambda.amazonaws.com') });
+
+api.grant(lambdaIAM, IamResource.custom('types/Query/fields/getTests'), 'appsync:graphql');
+api.grant(lambdaIAM, IamResource.ofType('test'), 'appsync:GraphQL');
+api.grantMutation(lambdaIAM, 'addTest');
+
+new Function(stack, 'testQuery', {
+  code: Code.fromAsset(join(__dirname, 'verify/iam-query')),
+  handler: 'iam-query.handler',
+  runtime: STANDARD_NODEJS_RUNTIME,
+  environment: { APPSYNC_ENDPOINT: api.graphqlUrl },
+  role: lambdaIAM,
+});
+new Function(stack, 'testFail', {
+  code: Code.fromAsset(join(__dirname, 'verify/iam-query')),
+  handler: 'iam-query.handler',
+  runtime: STANDARD_NODEJS_RUNTIME,
+  environment: { APPSYNC_ENDPOINT: api.graphqlUrl },
+});
+
+app.synth();

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-appsync/integ.graphql-lambda-permission.ts

@@ -0,0 +1,61 @@
+import * as cdk from 'aws-cdk-lib';
+import * as path from 'path';
+import * as lambda from 'aws-cdk-lib/aws-lambda';
+import * as integ from '@aws-cdk/integ-tests-alpha';
+import * as cxapi from 'aws-cdk-lib/cx-api';
+import * as appsync from 'aws-cdk-lib/aws-appsync';
+
+const myFeatureFlag = {
+  [cxapi.APPSYNC_GRAPHQLAPI_SCOPE_LAMBDA_FUNCTION_PERMISSION]: true,
+  '@aws-cdk/aws-lambda:useCdkManagedLogGroup': false,
+};
+
+const app = new cdk.App({
+  context: myFeatureFlag,
+});
+const stack = new cdk.Stack(app, 'aws-graphql-lambda-permissions');
+
+const authorizer = new lambda.Function(stack, 'AuthorizerFunction', {
+  runtime: lambda.Runtime.NODEJS_18_X,
+  code: lambda.Code.fromInline(`
+        exports.handler = async (event) => {
+          console.log("Authorization event:", JSON.stringify(event));
+          
+          const isAuthorized = true;
+          if (isAuthorized) {
+            return {
+              isAuthorized: true,
+              resolverContext: {
+                userId: 'user-id-example'
+              }
+            };
+          } else {
+            return {
+              isAuthorized: false
+            };
+          }
+        };
+      `),
+  handler: 'index.handler',
+});
+
+new appsync.GraphqlApi(stack, 'api', {
+  name: 'api',
+  definition: {
+    schema: appsync.SchemaFile.fromAsset(
+      path.join(__dirname, 'integ.graphql-lambda-permission.graphql'),
+    ),
+  },
+  authorizationConfig: {
+    defaultAuthorization: {
+      authorizationType: appsync.AuthorizationType.LAMBDA,
+      lambdaAuthorizerConfig: {
+        handler: authorizer,
+      },
+    },
+  },
+});
+
+new integ.IntegTest(app, 'GraphqlApiLambdaPermissionTest', {
+  testCases: [stack],
+});

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-appsync/integ.graphql-opensearch.ts

@@ -0,0 +1,82 @@
+import * as path from 'path';
+import { User } from 'aws-cdk-lib/aws-iam';
+import * as opensearch from 'aws-cdk-lib/aws-opensearchservice';
+import * as cdk from 'aws-cdk-lib';
+import { IntegTest } from '@aws-cdk/integ-tests-alpha';
+import { Construct } from 'constructs';
+import * as appsync from 'aws-cdk-lib/aws-appsync';
+
+class OpensSearch23Stack extends cdk.Stack {
+  constructor(scope: Construct) {
+    super(scope, 'appsync-opensearch');
+
+    const user = new User(this, 'User');
+
+    const domain = new opensearch.Domain(this, 'Domain', {
+      version: opensearch.EngineVersion.OPENSEARCH_2_3,
+      removalPolicy: cdk.RemovalPolicy.DESTROY,
+      fineGrainedAccessControl: {
+        masterUserArn: user.userArn,
+      },
+      encryptionAtRest: {
+        enabled: true,
+      },
+      nodeToNodeEncryption: true,
+      enforceHttps: true,
+      capacity: {
+        multiAzWithStandbyEnabled: false,
+      },
+    });
+
+    const api = new appsync.GraphqlApi(this, 'api', {
+      name: 'api',
+      schema: appsync.SchemaFile.fromAsset(path.join(__dirname, 'appsync.test.graphql')),
+    });
+
+    const ds = api.addOpenSearchDataSource('ds', domain);
+
+    ds.createResolver('QueryGetTests', {
+      typeName: 'Query',
+      fieldName: 'getTests',
+      requestMappingTemplate: appsync.MappingTemplate.fromString(JSON.stringify({
+        version: '2017-02-28',
+        operation: 'GET',
+        path: '/id/post/_search',
+        params: {
+          headers: {},
+          queryString: {},
+          body: {
+            from: 0,
+            size: 50,
+          },
+        },
+      })),
+      responseMappingTemplate: appsync.MappingTemplate.fromString(JSON.stringify({
+        version: '2017-02-28',
+        operation: 'GET',
+        path: '/id/post/_search',
+        params: {
+          headers: {},
+          queryString: {},
+          body: {
+            from: 0,
+            size: 50,
+            query: {
+              term: {
+                author: '$util.toJson($context.arguments.author)',
+              },
+            },
+          },
+        },
+      })),
+    });
+  }
+}
+
+const app = new cdk.App();
+const testCase = new OpensSearch23Stack(app);
+new IntegTest(app, 'opensearch-2.3-stack', {
+  testCases: [testCase],
+});
+
+app.synth();

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-appsync/integ.graphql-rds-serverlessv2.ts

@@ -0,0 +1,133 @@
+/// !cdk-integ *
+
+import * as path from 'path';
+import * as rds from 'aws-cdk-lib/aws-rds';
+import * as cdk from 'aws-cdk-lib';
+import * as appsync from 'aws-cdk-lib/aws-appsync';
+import * as secretmanager from 'aws-cdk-lib/aws-secretsmanager';
+import { Vpc } from 'aws-cdk-lib/aws-ec2';
+import { Construct } from 'constructs';
+import { IntegTest } from '@aws-cdk/integ-tests-alpha';
+
+/*
+ * Creates an Appsync GraphQL API and schema with Aurora Serverless V2 as datasource
+ *
+ * - build RDS Aurora Serverless V2 construct
+ * - Build AppSync API
+ * - Add RDS as Datasource
+ * - Create query and mutation for RDS table
+ */
+
+class TestStack extends cdk.Stack {
+  constructor(scope: Construct) {
+    super(scope, 'appsync-rds-serverlessV2');
+
+    const vpc = new Vpc(this, 'Integ-VPC');
+
+    const credentialsBaseOptions: rds.CredentialsBaseOptions = {
+      secretName: 'integ-secretName',
+    };
+
+    const cluster = new rds.DatabaseCluster(this, 'Integ-Cluster', {
+      engine: rds.DatabaseClusterEngine.auroraPostgres({ version: rds.AuroraPostgresEngineVersion.VER_15_5 }),
+      writer: rds.ClusterInstance.serverlessV2('writer'),
+      removalPolicy: cdk.RemovalPolicy.DESTROY,
+      vpc,
+      credentials: rds.Credentials.fromGeneratedSecret('clusteradmin', credentialsBaseOptions),
+      defaultDatabaseName: 'integdb',
+    });
+
+    const secret = secretmanager.Secret.fromSecretNameV2(this, 'Secret', 'integ-secretName');
+
+    const api = new appsync.GraphqlApi(this, 'RdsServerlessV2API', {
+      name: 'RdsServerlessV2API',
+      schema: appsync.SchemaFile.fromAsset(path.join(__dirname, 'appsync.rds-serverlessv2.graphql')),
+    });
+
+    const serverlessV2DS = api.addRdsDataSourceV2('ds', cluster, secret, 'integdb');
+
+    const queryAllPostReqTemplate: string = `{
+      "version": "2018-05-29",
+      "statements": [
+        "SELECT * FROM integdb"
+      ]
+    }`;
+
+    const queryAllPostsResolver: appsync.BaseResolverProps = {
+      typeName: 'Query',
+      fieldName: 'allPosts',
+      requestMappingTemplate:
+        appsync.MappingTemplate.fromString(queryAllPostReqTemplate),
+      responseMappingTemplate: appsync.MappingTemplate.fromString(`
+        #if($ctx.error)
+            $utils.error($ctx.error.message, $ctx.error.type)
+        #end
+        $utils.toJson($utils.rds.toJsonObject($ctx.result)[0])`,
+      ),
+    };
+
+    serverlessV2DS.createResolver('QueryGetallPostsResolver', queryAllPostsResolver);
+
+    const queryPostReqTemplate: string = `{
+      "version": "2018-05-29",
+      "statements": [
+        "SELECT * FROM integdb WHERE id = :id"
+      ]
+    }`;
+
+    const queryPostResolver: appsync.BaseResolverProps = {
+      typeName: 'Query',
+      fieldName: 'getPost',
+      requestMappingTemplate:
+        appsync.MappingTemplate.fromString(queryPostReqTemplate),
+      responseMappingTemplate: appsync.MappingTemplate.fromString(`
+        #if($ctx.error)
+            $utils.error($ctx.error.message, $ctx.error.type)
+        #end
+        $utils.toJson($utils.rds.toJsonObject($ctx.result)[0])`,
+      ),
+    };
+
+    serverlessV2DS.createResolver('QueryGetPostResolver', queryPostResolver);
+
+    const mutationAddPostReqTemplate: string = `
+    {
+      "version": "2018-05-29",
+      "statements": [
+        "INSERT INTO integdb VALUES (:id, :author, :title, :content, :url )",
+        "SELECT * WHERE id = :id"
+      ],
+      "variableMap": {
+        ":id": $util.toJson($util.autoId()),
+        ":author": $util.toJson($ctx.args.author)
+        ":title": $util.toJson($ctx.args.title)
+        ":content": $util.toJson($ctx.args.content)
+        ":url": $util.toJson($ctx.args.url)
+      }
+    }`;
+
+    const mutationAddPostResolver: appsync.BaseResolverProps = {
+      typeName: 'Mutation',
+      fieldName: 'addPost',
+      requestMappingTemplate:
+        appsync.MappingTemplate.fromString(mutationAddPostReqTemplate),
+      responseMappingTemplate: appsync.MappingTemplate.fromString(`
+        #if($ctx.error)
+            $utils.error($ctx.error.message, $ctx.error.type)
+        #end
+        $utils.toJson($utils.rds.toJsonObject($ctx.result)[0])`,
+      ),
+    };
+
+    serverlessV2DS.createResolver('MutationAddPostResolver', mutationAddPostResolver);
+  }
+}
+
+const app = new cdk.App();
+const testCase = new TestStack(app);
+
+new IntegTest(app, 'rds-serverlessV2-stack', {
+  testCases: [testCase],
+});
+
+app.synth();