@vyriy/stack 0.2.0 → 0.3.0

package/AGENTS.md

@@ -0,0 +1,65 @@
+# Vyriy Package Agent Guide
+
+This package belongs to the Vyriy toolkit. Keep changes calm, explicit, reusable, and easy to reason about.
+
+## Architecture
+
+- Prefer simple modules over clever frameworks or hidden conventions.
+- Keep package boundaries explicit and avoid project-specific coupling.
+- Extract only proven reusable behavior.
+- Keep public APIs small, typed, documented, and stable.
+- Prefer SSR-friendly and SSG-friendly code paths.
+- Keep integrations replaceable and avoid hard coupling to a CMS or runtime host.
+- Prefer AWS serverless-compatible assumptions when infrastructure concerns appear.
+
+## File Shape
+
+- Prefer one exported runtime method, component, or helper per production file when it stays readable.
+- Prefer one matching test file per production file, for example `feature.ts` and `feature.test.ts`.
+- Use focused folders when behavior naturally splits into several related files.
+- Keep `index.ts` as a public re-export surface only. Do not place implementation logic in it.
+- Use `.js` relative import and export specifiers in TypeScript source where package style requires it.
+- Add `types.ts` when public shared types are part of the package contract.
+- Keep constants near the code that owns them unless they are shared or clarify repeated behavior.
+
+## Public Surface
+
+- Every new public export should be re-exported from `index.ts`.
+- Add or update `index.test.ts` when the public export surface changes.
+- Add JSDoc for public exports when behavior, parameters, return values, or usage expectations need explanation.
+- Do not hand-maintain source package `exports` maps unless the package has a real custom publishing need.
+
+## Tests
+
+- Tests use Jest and `@jest/globals`.
+- Cover public behavior and meaningful edge cases.
+- Prefer behavior-focused tests over private implementation lock-in.
+- When mocking modules, install mocks before loading the module under test.
+- Use focused validation when changing package behavior:
+
+```bash
+yarn jest packages/<package> --runInBand --coverage=false
+```
+
+## Documentation
+
+- Keep `README.md` concise and usage-oriented.
+- Start package READMEs with `# @vyriy/<package>`.
+- Document real public exports, supported options, and examples that actually work.
+- Keep `doc.mdx` as the Storybook/docs wrapper for the README when the package participates in docs.
+- For component packages, include Storybook coverage for supported states and common usage.
+
+## Components
+
+- Prefer lightweight React 19+ components with TypeScript.
+- Keep components SSR-friendly and avoid browser globals during render.
+- Prefer composable props and Bootstrap-compatible ergonomics where practical.
+- Put each public component in its own file with a matching test.
+- Add Storybook stories when a component has visual states, variants, or interaction states.
+
+## Change Discipline
+
+- Keep changes scoped to the requested behavior.
+- Avoid unrelated refactors and metadata churn.
+- Sync implementation, tests, README, `doc.mdx`, and public re-exports together.
+- Prefer the option that is simpler to explain, easier to evolve, and calmer to maintain.

package/README.md

@@ -149,3 +149,322 @@ stack(
   },
 );
 ```
+
+## API Gateway Lambda Example
+
+This example wires a Lambda-backed REST API to an API Gateway custom domain:
+
+- find an existing hosted zone
+- create a DNS-validated ACM certificate
+- create a Lambda from built API assets
+- create an edge REST API with proxy Lambda integration
+- map the API to a custom domain
+- create a Route 53 alias record for the API Gateway domain
+
+Edge API Gateway custom domains use edge-optimized CloudFront distributions, so keep the certificate in `us-east-1`.
+
+```ts
+import { CfnOutput, Stack, type StackProps } from 'aws-cdk-lib';
+import { ApiGatewayDomain } from 'aws-cdk-lib/aws-route53-targets';
+import type { Construct } from 'constructs';
+
+import { stack } from '@vyriy/cdk';
+import { acm, apigateway, lambda, route53 } from '@vyriy/stack';
+import { getPackage } from '@vyriy/package';
+import { path } from '@vyriy/path';
+
+stack(
+  class ApiStack extends Stack {
+    constructor(scope: Construct, id: string, props: StackProps & { env: { account: string; region: string } }) {
+      super(scope, id, props);
+
+      const domain = 'api.site.com';
+      const hostedZoneName = 'site.com';
+      const { description } = getPackage();
+
+      const zone = route53.getHostedZone(this, 'HostedZone', {
+        zoneName: hostedZoneName,
+      });
+
+      const certificate = acm.createCertificate(this, 'Certificate', {
+        domainName: domain,
+        validation: acm.CertificateValidation.fromDns(zone),
+      });
+
+      const apiLambda = lambda.createLambda(this, 'ApiLambda', {
+        code: lambda.Code.fromAsset(path('dist', 'api')),
+        description,
+        functionName: 'api',
+        handler: 'index.handler',
+      });
+
+      const apiGateway = apigateway.createApiGateway(this, 'ApiGateway', {
+        defaultIntegration: apigateway.createIntegration(apiLambda, { proxy: true }),
+        description,
+        restApiName: `${id}-api-gateway`,
+      });
+
+      const apiDomainName = apigateway.createDomainName(this, 'ApiGatewayDomain', {
+        certificate,
+        domainName: domain,
+      });
+
+      apigateway.createBasePathMapping(this, 'ApiBasePathMapping', {
+        domainName: apiDomainName,
+        restApi: apiGateway,
+      });
+
+      route53.createARecord(this, 'ARecord', {
+        recordName: domain,
+        target: route53.RecordTarget.fromAlias(new ApiGatewayDomain(apiDomainName)),
+        zone,
+      });
+
+      new CfnOutput(this, 'Account', { value: props.env.account });
+      new CfnOutput(this, 'Region', { value: props.env.region });
+
+      new CfnOutput(this, 'LambdaName', { value: apiLambda.functionName });
+
+      new CfnOutput(this, 'ApiGatewayId', { value: apiGateway.restApiId });
+      new CfnOutput(this, 'ApiGatewayUrl', { value: apiGateway.url });
+
+      new CfnOutput(this, 'ApiUrl', { value: `https://${domain}/` });
+    }
+  },
+);
+```
+
+## Fargate Worker Example
+
+This example wires a Fargate task foundation to an existing VPC:
+
+- read the VPC id from the environment
+- load package metadata for reusable descriptions
+- create a security group for the workload
+- create an ECR repository for the task image
+- create an ECS cluster in the VPC
+- create a Fargate task definition with AWS Logs configured
+
+```ts
+import { CfnOutput, Stack, type StackProps } from 'aws-cdk-lib';
+import type { Construct } from 'constructs';
+
+import { stack } from '@vyriy/cdk';
+import { getVpc } from '@vyriy/env';
+import { getPackage } from '@vyriy/package';
+import { ec2, ecr, ecs } from '@vyriy/stack';
+
+stack(
+  class FargateWorkerStack extends Stack {
+    constructor(scope: Construct, id: string, props: StackProps & { env: { account: string; region: string } }) {
+      super(scope, id, props);
+
+      const { description } = getPackage();
+      const vpc = ec2.findVpc(this, 'Vpc', { vpcId: getVpc() });
+      const subnets = vpc.privateSubnets;
+
+      const securityGroup = ec2.createSecurityGroup(this, 'SecurityGroup', {
+        allowAllOutbound: true,
+        description,
+        securityGroupName: `${id}-${vpc.vpcId}-securityGroup`,
+        vpc,
+      });
+
+      const repository = ecr.createRepository(this, 'SyncRepository', {
+        repositoryName: `${id}-repository`,
+      });
+
+      const cluster = ecs.createCluster(this, 'FargateCluster', {
+        clusterName: `${id}-cluster`,
+        vpc,
+      });
+
+      const taskDefinition = ecs.createTaskDefinition(this, 'SyncFargateTaskDefinition', {
+        cpu: 256,
+        family: `${id}-task-definition`,
+        memoryLimitMiB: 512,
+      });
+
+      taskDefinition.addContainer('SyncTaskDefinition', {
+        cpu: 256,
+        image: ecs.ContainerImage.fromEcrRepository(repository),
+        logging: ecs.setLogs({ streamPrefix: `${id}-cluster-logs` }),
+        memoryLimitMiB: 512,
+      });
+
+      new CfnOutput(this, 'Account', { value: props.env.account });
+      new CfnOutput(this, 'Region', { value: props.env.region });
+
+      new CfnOutput(this, 'VpcId', { value: vpc.vpcId });
+      new CfnOutput(this, 'PrivateSubnetIds', { value: subnets.map((subnet) => subnet.subnetId).join(',') });
+      new CfnOutput(this, 'SecurityGroupId', { value: securityGroup.securityGroupId });
+
+      new CfnOutput(this, 'RepositoryName', { value: repository.repositoryName });
+      new CfnOutput(this, 'ClusterName', { value: cluster.clusterName });
+
+      new CfnOutput(this, 'TaskDefinitionArn', { value: taskDefinition.taskDefinitionArn });
+    }
+  },
+);
+```
+
+## DynamoDB Access Examples
+
+These examples show small DynamoDB table definitions and common IAM access patterns for Lambda and Fargate workloads.
+
+Create two country tables:
+
+```ts
+import { dynamodb } from '@vyriy/stack';
+
+const countriesIndexTable = dynamodb.createTable(this, 'CountriesIndexTable', {
+  partitionKey: {
+    name: 'key',
+    type: dynamodb.AttributeType.STRING,
+  },
+  tableName: `${id}-countries-index`,
+});
+
+const countriesTable = dynamodb.createTable(this, 'CountriesTable', {
+  partitionKey: {
+    name: 'key',
+    type: dynamodb.AttributeType.STRING,
+  },
+  sortKey: {
+    name: 'code',
+    type: dynamodb.AttributeType.STRING,
+  },
+  tableName: `${id}-countries`,
+});
+```
+
+Grant Lambda access to the tables:
+
+```ts
+countriesIndexTable.grantReadData(apiLambda);
+countriesTable.grantReadWriteData(apiLambda);
+
+// Use full access only for maintenance or sync jobs that really need table-level control.
+countriesIndexTable.grantFullAccess(apiLambda);
+```
+
+Grant Fargate task access through the task role:
+
+```ts
+countriesIndexTable.grantReadData(taskDefinition.taskRole);
+countriesTable.grantReadWriteData(taskDefinition.taskRole);
+
+// Full access is useful for controlled backfill or indexing tasks.
+countriesIndexTable.grantFullAccess(taskDefinition.taskRole);
+```
+
+Allow a Lambda to run the Fargate task definition:
+
+```ts
+taskDefinition.grantRun(apiLambda);
+```
+
+## Messaging And Parameter Examples
+
+These examples show simple SNS, SQS, and SSM helper usage for application stacks.
+
+Create an SNS topic and grant publishers/subscribers:
+
+```ts
+import { sns } from '@vyriy/stack';
+
+const eventsTopic = sns.createTopic(this, 'EventsTopic', {
+  topicName: `${id}-events`,
+});
+
+eventsTopic.grantPublish(apiLambda);
+eventsTopic.grantSubscribe(taskDefinition.taskRole);
+```
+
+Import an existing SNS topic:
+
+```ts
+const importedEventsTopic = sns.fromTopicArn(
+  this,
+  'ImportedEventsTopic',
+  `arn:aws:sns:${this.region}:${this.account}:${id}-events`,
+);
+
+importedEventsTopic.grantPublish(taskDefinition.taskRole);
+```
+
+Create an SQS queue and allow Lambda/Fargate workers to use it:
+
+```ts
+import { Duration } from 'aws-cdk-lib';
+
+import { sqs } from '@vyriy/stack';
+
+const jobsQueue = sqs.createQueue(this, 'JobsQueue', {
+  queueName: `${id}-jobs`,
+  visibilityTimeout: Duration.seconds(60),
+});
+
+jobsQueue.grantSendMessages(apiLambda);
+jobsQueue.grantConsumeMessages(taskDefinition.taskRole);
+```
+
+Import an existing SQS queue:
+
+```ts
+const importedJobsQueue = sqs.fromQueueAttributes(this, 'ImportedJobsQueue', {
+  queueArn: `arn:aws:sqs:${this.region}:${this.account}:${id}-jobs`,
+  queueUrl: `https://sqs.${this.region}.amazonaws.com/${this.account}/${id}-jobs`,
+});
+
+importedJobsQueue.grantConsumeMessages(apiLambda);
+```
+
+Read SSM parameter values and import parameters:
+
+```ts
+import { ssm } from '@vyriy/stack';
+
+const apiBaseUrl = ssm.valueForStringParameter(this, `/${id}/api/base-url`);
+
+const importedApiKey = ssm.fromSecureStringParameterAttributes(this, 'ImportedApiKey', {
+  parameterName: `/${id}/api/key`,
+  version: 1,
+});
+
+importedApiKey.grantRead(apiLambda);
+importedApiKey.grantRead(taskDefinition.taskRole);
+```
+
+Pass SSM parameter values into Lambda and Fargate environment variables:
+
+```ts
+const apiBaseUrlParameterName = `/${id}/api/base-url`;
+const apiKeyParameterName = `/${id}/api/key`;
+
+const apiBaseUrl = ssm.valueForStringParameter(this, apiBaseUrlParameterName);
+const apiKey = ssm.valueForStringParameter(this, apiKeyParameterName);
+
+const apiLambda = lambda.createLambda(this, 'ApiLambda', {
+  code: lambda.Code.fromAsset(path('dist', 'api')),
+  environment: {
+    API_BASE_URL: apiBaseUrl,
+    API_KEY_PARAMETER_NAME: apiKeyParameterName,
+  },
+  handler: 'index.handler',
+});
+
+taskDefinition.addContainer('WorkerContainer', {
+  environment: {
+    API_BASE_URL: apiBaseUrl,
+    API_KEY: apiKey,
+  },
+  image: ecs.ContainerImage.fromEcrRepository(repository),
+  logging: ecs.setLogs({ streamPrefix: `${id}-worker-logs` }),
+});
+
+const importedApiKeyForEnv = ssm.fromStringParameterName(this, 'ImportedApiKeyForEnv', apiKeyParameterName);
+
+importedApiKeyForEnv.grantRead(apiLambda);
+importedApiKeyForEnv.grantRead(taskDefinition.taskRole);
+```

package/apigateway/index.d.ts

@@ -0,0 +1,10 @@
+import { Construct } from 'constructs';
+import { AwsIntegration, AwsIntegrationProps, BasePathMapping, BasePathMappingProps, DomainName, DomainNameProps, EndpointType, LambdaIntegration, LambdaIntegrationOptions, Model, RestApi, RestApiProps } from 'aws-cdk-lib/aws-apigateway';
+import { IFunction } from 'aws-cdk-lib/aws-lambda';
+export { RestApi, EndpointType, Model };
+export type { RestApiProps };
+export declare const createApiGateway: (scope: Construct, id: string, props: RestApiProps) => RestApi;
+export declare const createIntegration: (lambda: IFunction, options: LambdaIntegrationOptions) => LambdaIntegration;
+export declare const createDomainName: (scope: Construct, id: string, props: DomainNameProps) => DomainName;
+export declare const createBasePathMapping: (scope: Construct, id: string, props: BasePathMappingProps) => BasePathMapping;
+export declare const createAwsIntegration: (props: AwsIntegrationProps) => AwsIntegration;

package/apigateway/index.js

@@ -0,0 +1,29 @@
+import { AwsIntegration, BasePathMapping, DomainName, EndpointType, LambdaIntegration, Model, RestApi, } from 'aws-cdk-lib/aws-apigateway';
+export { RestApi, EndpointType, Model };
+export const createApiGateway = (scope, id, props) => {
+    const { defaultIntegration, ...rest } = props;
+    const apiProps = {
+        deployOptions: {
+            stageName: 'api',
+            methodOptions: {
+                '/*/*': {
+                    throttlingRateLimit: 100,
+                    throttlingBurstLimit: 200,
+                },
+            },
+        },
+        defaultIntegration,
+        endpointTypes: [EndpointType.EDGE],
+        ...rest,
+    };
+    const apiGateway = new RestApi(scope, id, apiProps);
+    apiGateway.root.addProxy({ anyMethod: true, defaultIntegration });
+    return apiGateway;
+};
+export const createIntegration = (lambda, options) => new LambdaIntegration(lambda, options);
+export const createDomainName = (scope, id, props) => new DomainName(scope, id, {
+    endpointType: EndpointType.EDGE,
+    ...props,
+});
+export const createBasePathMapping = (scope, id, props) => new BasePathMapping(scope, id, props);
+export const createAwsIntegration = (props) => new AwsIntegration(props);

package/dynamodb/index.d.ts

@@ -0,0 +1,4 @@
+import { Construct } from 'constructs';
+import { AttributeType, Table, TableProps } from 'aws-cdk-lib/aws-dynamodb';
+export { AttributeType };
+export declare const createTable: (scope: Construct, id: string, props: TableProps) => Table;

package/dynamodb/index.js

@@ -0,0 +1,8 @@
+import { RemovalPolicy } from 'aws-cdk-lib';
+import { AttributeType, BillingMode, Table } from 'aws-cdk-lib/aws-dynamodb';
+export { AttributeType };
+export const createTable = (scope, id, props) => new Table(scope, id, {
+    billingMode: BillingMode.PAY_PER_REQUEST,
+    removalPolicy: RemovalPolicy.DESTROY,
+    ...props,
+});

package/ec2/index.d.ts

@@ -0,0 +1,8 @@
+import { Construct } from 'constructs';
+import { IVpc, InterfaceVpcEndpoint, InterfaceVpcEndpointProps, SecurityGroup, SecurityGroupProps, SubnetType, Vpc, VpcLookupOptions } from 'aws-cdk-lib/aws-ec2';
+export { SubnetType };
+export type { IVpc, SecurityGroup };
+export declare const findVpc: (scope: Construct, id: string, props: VpcLookupOptions) => IVpc;
+export declare const createSecurityGroup: (scope: Construct, id: string, props: SecurityGroupProps) => SecurityGroup;
+export declare const createVpcEndpoint: (scope: Construct, id: string, props: InterfaceVpcEndpointProps) => InterfaceVpcEndpoint;
+export declare const createVpc: (scope: Construct, id: string, props?: Omit<Vpc, "subnetConfiguration">) => Vpc;

package/ec2/index.js

@@ -0,0 +1,19 @@
+import { InterfaceVpcEndpoint, SecurityGroup, SubnetType, Vpc, } from 'aws-cdk-lib/aws-ec2';
+export { SubnetType };
+export const findVpc = (scope, id, props) => Vpc.fromLookup(scope, id, props);
+export const createSecurityGroup = (scope, id, props) => new SecurityGroup(scope, id, props);
+export const createVpcEndpoint = (scope, id, props) => new InterfaceVpcEndpoint(scope, id, props);
+export const createVpc = (scope, id, props) => new Vpc(scope, id, {
+    maxAzs: 2,
+    subnetConfiguration: [
+        {
+            name: 'Public',
+            subnetType: SubnetType.PUBLIC,
+        },
+        {
+            name: 'Private',
+            subnetType: SubnetType.PRIVATE_WITH_EGRESS,
+        },
+    ],
+    ...props,
+});

package/ecr/index.d.ts

@@ -0,0 +1,3 @@
+import { Construct } from 'constructs';
+import { Repository, RepositoryProps } from 'aws-cdk-lib/aws-ecr';
+export declare const createRepository: (scope: Construct, id: string, props: RepositoryProps) => Repository;

package/ecr/index.js

@@ -0,0 +1,8 @@
+import { RemovalPolicy } from 'aws-cdk-lib';
+import { Repository } from 'aws-cdk-lib/aws-ecr';
+export const createRepository = (scope, id, props) => new Repository(scope, id, {
+    removalPolicy: RemovalPolicy.DESTROY,
+    lifecycleRules: [{ maxImageCount: 3 }],
+    emptyOnDelete: true,
+    ...props,
+});

package/ecs/index.d.ts

@@ -0,0 +1,6 @@
+import { Construct } from 'constructs';
+import { AwsLogDriverProps, Cluster, ClusterProps, FargateTaskDefinition, FargateTaskDefinitionProps } from 'aws-cdk-lib/aws-ecs';
+export { ContainerImage } from 'aws-cdk-lib/aws-ecs';
+export declare const createCluster: (scope: Construct, id: string, props: ClusterProps) => Cluster;
+export declare const createTaskDefinition: (scope: Construct, id: string, props: FargateTaskDefinitionProps) => FargateTaskDefinition;
+export declare const setLogs: (props: AwsLogDriverProps) => import("aws-cdk-lib/aws-ecs").LogDriver;

package/ecs/index.js

@@ -0,0 +1,9 @@
+import { Cluster, FargateTaskDefinition, LogDrivers, } from 'aws-cdk-lib/aws-ecs';
+import { RetentionDays } from 'aws-cdk-lib/aws-logs';
+export { ContainerImage } from 'aws-cdk-lib/aws-ecs';
+export const createCluster = (scope, id, props) => new Cluster(scope, id, props);
+export const createTaskDefinition = (scope, id, props) => new FargateTaskDefinition(scope, id, props);
+export const setLogs = (props) => LogDrivers.awsLogs({
+    logRetention: RetentionDays.ONE_WEEK,
+    ...props,
+});

package/index.d.ts

@@ -1,5 +1,14 @@
 export * as acm from './certificatemanager/index.js';
+export * as apigateway from './apigateway/index.js';
 export * as cf from './cloudfront/index.js';
 export * as deployment from './deployment/index.js';
+export * as dynamodb from './dynamodb/index.js';
+export * as ec2 from './ec2/index.js';
+export * as ecr from './ecr/index.js';
+export * as ecs from './ecs/index.js';
+export * as lambda from './lambda/index.js';
 export * as route53 from './route53/index.js';
 export * as s3 from './s3/index.js';
+export * as sns from './sns/index.js';
+export * as sqs from './sqs/index.js';
+export * as ssm from './ssm/index.js';

package/index.js

@@ -1,5 +1,14 @@
 export * as acm from './certificatemanager/index.js';
+export * as apigateway from './apigateway/index.js';
 export * as cf from './cloudfront/index.js';
 export * as deployment from './deployment/index.js';
+export * as dynamodb from './dynamodb/index.js';
+export * as ec2 from './ec2/index.js';
+export * as ecr from './ecr/index.js';
+export * as ecs from './ecs/index.js';
+export * as lambda from './lambda/index.js';
 export * as route53 from './route53/index.js';
 export * as s3 from './s3/index.js';
+export * as sns from './sns/index.js';
+export * as sqs from './sqs/index.js';
+export * as ssm from './ssm/index.js';

package/lambda/index.d.ts

@@ -0,0 +1,9 @@
+import { Construct } from 'constructs';
+import { Code, FunctionProps, FunctionUrl, FunctionUrlProps, Function as LambdaFunction, LayerVersion, Runtime } from 'aws-cdk-lib/aws-lambda';
+export { SqsEventSource } from 'aws-cdk-lib/aws-lambda-event-sources';
+export { Code, Runtime, LayerVersion };
+export type { LambdaFunction, FunctionProps };
+export declare const createLambda: (scope: Construct, id: string, props: Omit<FunctionProps, "runtime"> & {
+    runtime?: Runtime;
+}) => LambdaFunction;
+export declare const createFunctionUrl: (scope: Construct, id: string, props: FunctionUrlProps) => FunctionUrl;

package/lambda/index.js

@@ -0,0 +1,27 @@
+import { Duration, RemovalPolicy } from 'aws-cdk-lib';
+import { Code, FunctionUrl, Function as LambdaFunction, LayerVersion, Runtime, } from 'aws-cdk-lib/aws-lambda';
+import { LogGroup, RetentionDays } from 'aws-cdk-lib/aws-logs';
+export { SqsEventSource } from 'aws-cdk-lib/aws-lambda-event-sources';
+export { Code, Runtime, LayerVersion };
+export const createLambda = (scope, id, props) => {
+    const { functionName, code, handler, runtime = Runtime.NODEJS_24_X, timeout = Duration.seconds(29), memorySize = 128, environment = {}, ...rest } = props;
+    const lambdaFunction = new LambdaFunction(scope, id, {
+        functionName,
+        code,
+        handler,
+        runtime,
+        timeout,
+        memorySize,
+        environment: {
+            NODE_ENV: 'production',
+            ...environment,
+        },
+        logGroup: new LogGroup(scope, `${id}LogGroup`, {
+            retention: RetentionDays.ONE_WEEK,
+            removalPolicy: RemovalPolicy.DESTROY,
+        }),
+        ...rest,
+    });
+    return lambdaFunction;
+};
+export const createFunctionUrl = (scope, id, props) => new FunctionUrl(scope, id, props);

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "@vyriy/stack",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "AWS CDK stack helpers for Vyriy infrastructure",
   "type": "module",
   "main": "./index.js",
   "dependencies": {
-    "aws-cdk-lib": "^2.253.1",
+    "aws-cdk-lib": "^2.254.0",
     "constructs": "^10.6.0"
   },
+  "agents": "./AGENTS.md",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -21,6 +22,16 @@
       "import": "./index.js",
       "default": "./index.js"
     },
+    "./apigateway/index": {
+      "types": "./apigateway/index.d.ts",
+      "import": "./apigateway/index.js",
+      "default": "./apigateway/index.js"
+    },
+    "./apigateway/index.js": {
+      "types": "./apigateway/index.d.ts",
+      "import": "./apigateway/index.js",
+      "default": "./apigateway/index.js"
+    },
     "./certificatemanager/index": {
       "types": "./certificatemanager/index.d.ts",
       "import": "./certificatemanager/index.js",
@@ -51,6 +62,46 @@
       "import": "./deployment/index.js",
       "default": "./deployment/index.js"
     },
+    "./dynamodb/index": {
+      "types": "./dynamodb/index.d.ts",
+      "import": "./dynamodb/index.js",
+      "default": "./dynamodb/index.js"
+    },
+    "./dynamodb/index.js": {
+      "types": "./dynamodb/index.d.ts",
+      "import": "./dynamodb/index.js",
+      "default": "./dynamodb/index.js"
+    },
+    "./ec2/index": {
+      "types": "./ec2/index.d.ts",
+      "import": "./ec2/index.js",
+      "default": "./ec2/index.js"
+    },
+    "./ec2/index.js": {
+      "types": "./ec2/index.d.ts",
+      "import": "./ec2/index.js",
+      "default": "./ec2/index.js"
+    },
+    "./ecr/index": {
+      "types": "./ecr/index.d.ts",
+      "import": "./ecr/index.js",
+      "default": "./ecr/index.js"
+    },
+    "./ecr/index.js": {
+      "types": "./ecr/index.d.ts",
+      "import": "./ecr/index.js",
+      "default": "./ecr/index.js"
+    },
+    "./ecs/index": {
+      "types": "./ecs/index.d.ts",
+      "import": "./ecs/index.js",
+      "default": "./ecs/index.js"
+    },
+    "./ecs/index.js": {
+      "types": "./ecs/index.d.ts",
+      "import": "./ecs/index.js",
+      "default": "./ecs/index.js"
+    },
     "./index": {
       "types": "./index.d.ts",
       "import": "./index.js",
@@ -61,6 +112,16 @@
       "import": "./index.js",
       "default": "./index.js"
     },
+    "./lambda/index": {
+      "types": "./lambda/index.d.ts",
+      "import": "./lambda/index.js",
+      "default": "./lambda/index.js"
+    },
+    "./lambda/index.js": {
+      "types": "./lambda/index.d.ts",
+      "import": "./lambda/index.js",
+      "default": "./lambda/index.js"
+    },
     "./route53/index": {
       "types": "./route53/index.d.ts",
       "import": "./route53/index.js",
@@ -80,6 +141,36 @@
       "types": "./s3/index.d.ts",
       "import": "./s3/index.js",
       "default": "./s3/index.js"
+    },
+    "./sns/index": {
+      "types": "./sns/index.d.ts",
+      "import": "./sns/index.js",
+      "default": "./sns/index.js"
+    },
+    "./sns/index.js": {
+      "types": "./sns/index.d.ts",
+      "import": "./sns/index.js",
+      "default": "./sns/index.js"
+    },
+    "./sqs/index": {
+      "types": "./sqs/index.d.ts",
+      "import": "./sqs/index.js",
+      "default": "./sqs/index.js"
+    },
+    "./sqs/index.js": {
+      "types": "./sqs/index.d.ts",
+      "import": "./sqs/index.js",
+      "default": "./sqs/index.js"
+    },
+    "./ssm/index": {
+      "types": "./ssm/index.d.ts",
+      "import": "./ssm/index.js",
+      "default": "./ssm/index.js"
+    },
+    "./ssm/index.js": {
+      "types": "./ssm/index.d.ts",
+      "import": "./ssm/index.js",
+      "default": "./ssm/index.js"
     }
   }
 }

package/sns/index.d.ts

@@ -0,0 +1,5 @@
+import { Construct } from 'constructs';
+import { Topic, TopicProps, TopicAttributes } from 'aws-cdk-lib/aws-sns';
+export declare const createTopic: (scope: Construct, id: string, props?: TopicProps) => Topic;
+export declare const fromTopicArn: (scope: Construct, id: string, topicArn: string) => import("aws-cdk-lib/aws-sns").ITopic;
+export declare const fromTopicAttributes: (scope: Construct, id: string, attrs: TopicAttributes) => import("aws-cdk-lib/aws-sns").ITopic;

package/sns/index.js

@@ -0,0 +1,4 @@
+import { Topic } from 'aws-cdk-lib/aws-sns';
+export const createTopic = (scope, id, props = {}) => new Topic(scope, id, props);
+export const fromTopicArn = (scope, id, topicArn) => Topic.fromTopicArn(scope, id, topicArn);
+export const fromTopicAttributes = (scope, id, attrs) => Topic.fromTopicAttributes(scope, id, attrs);

package/sqs/index.d.ts

@@ -0,0 +1,8 @@
+import { Construct } from 'constructs';
+import { Queue, QueueProps } from 'aws-cdk-lib/aws-sqs';
+export declare const createQueue: (scope: Construct, id: string, props?: QueueProps) => Queue;
+export declare const fromQueueArn: (scope: Construct, id: string, queueArn: string) => import("aws-cdk-lib/aws-sqs").IQueue;
+export declare const fromQueueAttributes: (scope: Construct, id: string, attrs: {
+    queueArn: string;
+    queueUrl: string;
+}) => import("aws-cdk-lib/aws-sqs").IQueue;

package/sqs/index.js

@@ -0,0 +1,4 @@
+import { Queue } from 'aws-cdk-lib/aws-sqs';
+export const createQueue = (scope, id, props = {}) => new Queue(scope, id, props);
+export const fromQueueArn = (scope, id, queueArn) => Queue.fromQueueArn(scope, id, queueArn);
+export const fromQueueAttributes = (scope, id, attrs) => Queue.fromQueueAttributes(scope, id, attrs);

package/ssm/index.d.ts

@@ -0,0 +1,7 @@
+import { Construct } from 'constructs';
+import { ParameterValueType, SecureStringParameterAttributes, StringParameterAttributes } from 'aws-cdk-lib/aws-ssm';
+export type { ParameterValueType };
+export declare const fromStringParameterName: (scope: Construct, id: string, stringParameterName: string) => import("aws-cdk-lib/aws-ssm").IStringParameter;
+export declare const fromStringParameterAttributes: (scope: Construct, id: string, attrs: StringParameterAttributes) => import("aws-cdk-lib/aws-ssm").IStringParameter;
+export declare const fromSecureStringParameterAttributes: (scope: Construct, id: string, attrs: SecureStringParameterAttributes) => import("aws-cdk-lib/aws-ssm").IStringParameter;
+export declare const valueForStringParameter: (scope: Construct, stringParameterName: string) => string;

package/ssm/index.js

@@ -0,0 +1,5 @@
+import { StringParameter, } from 'aws-cdk-lib/aws-ssm';
+export const fromStringParameterName = (scope, id, stringParameterName) => StringParameter.fromStringParameterName(scope, id, stringParameterName);
+export const fromStringParameterAttributes = (scope, id, attrs) => StringParameter.fromStringParameterAttributes(scope, id, attrs);
+export const fromSecureStringParameterAttributes = (scope, id, attrs) => StringParameter.fromSecureStringParameterAttributes(scope, id, attrs);
+export const valueForStringParameter = (scope, stringParameterName) => StringParameter.valueForStringParameter(scope, stringParameterName);