@mettlecast/domain-cdk-packer 0.2.0

package/dist/__tests__/domain-stack.test.js

@@ -0,0 +1,223 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import * as cdk from 'aws-cdk-lib';
+import { Template } from 'aws-cdk-lib/assertions';
+import fs from 'node:fs';
+import path from 'node:path';
+import { DomainStack } from '../DomainStack.js';
+const DOMAIN_ROOT = '/tmp/test-domain-cdk-packer';
+const minimalRegistry = {
+    schemaVersion: '1',
+    domainRoot: DOMAIN_ROOT,
+    domain: { id: 'test-domain', kind: 'domain', name: 'Test Domain', tenancy: 'none' },
+    apis: [
+        {
+            id: 'get-users',
+            kind: 'api',
+            handlerFile: 'src/handlers/get-users.ts',
+            path: '/users',
+            method: 'GET',
+            authType: 'jwt',
+        },
+    ],
+    webhooks: [],
+    subscribers: [],
+    schedules: [],
+    jobs: [],
+    actions: [],
+    integrations: [],
+    events: [],
+};
+beforeAll(() => {
+    const handlerDir = path.join(DOMAIN_ROOT, 'src', 'handlers');
+    fs.mkdirSync(handlerDir, { recursive: true });
+    fs.writeFileSync(path.join(handlerDir, 'get-users.ts'), 'export const handler = async () => ({ statusCode: 200 });\n');
+});
+afterAll(() => {
+    fs.rmSync(DOMAIN_ROOT, { recursive: true, force: true });
+});
+describe('DomainStack', () => {
+    const eventBusArn = 'arn:aws:events:eu-north-1:123456789012:event-bus/tib-event-bus';
+    it('synthesises without error for minimal registry', () => {
+        const app = new cdk.App();
+        expect(() => new DomainStack(app, 'TestDomainStack', { registry: minimalRegistry, eventBusArn })).not.toThrow();
+    });
+    it('template contains HttpApi', () => {
+        const app = new cdk.App();
+        const stack = new DomainStack(app, 'TestDomainStack2', { registry: minimalRegistry, eventBusArn });
+        const template = Template.fromStack(stack);
+        template.resourceCountIs('AWS::ApiGatewayV2::Api', 1);
+    });
+    it('template contains one Lambda function for the api entry', () => {
+        const app = new cdk.App();
+        const stack = new DomainStack(app, 'TestDomainStack3', { registry: minimalRegistry, eventBusArn });
+        const template = Template.fromStack(stack);
+        template.resourceCountIs('AWS::Lambda::Function', 4);
+    });
+    it('attaches JWT authorizer to jwt-auth API routes when userPoolArn provided', () => {
+        const app = new cdk.App();
+        const userPoolArn = 'arn:aws:cognito-idp:eu-north-1:123456789012:userpool/eu-north-1_abc123xyz';
+        const userPoolClientId = 'test-client-id';
+        const stack = new DomainStack(app, 'TestDomainStackJwt', {
+            registry: minimalRegistry,
+            eventBusArn,
+            userPoolArn,
+            userPoolClientId,
+        });
+        const template = Template.fromStack(stack);
+        template.hasResourceProperties('AWS::ApiGatewayV2::Authorizer', {
+            AuthorizerType: 'JWT',
+        });
+    });
+    it('no authorizer attached when authType is none', () => {
+        const app = new cdk.App();
+        const registryNoAuth = {
+            ...minimalRegistry,
+            apis: [
+                {
+                    ...minimalRegistry.apis[0],
+                    authType: 'none',
+                },
+            ],
+        };
+        const stack = new DomainStack(app, 'TestDomainStackNoAuth', {
+            registry: registryNoAuth,
+            eventBusArn,
+        });
+        const template = Template.fromStack(stack);
+        template.resourceCountIs('AWS::ApiGatewayV2::Authorizer', 0);
+    });
+    it('DB_SECRET_ARN env var set on Lambdas when dbSecretArn provided', () => {
+        const app = new cdk.App();
+        const dbSecretArn = 'arn:aws:secretsmanager:eu-north-1:123456789012:secret:db-secret-abc123';
+        const stack = new DomainStack(app, 'TestDomainStackDbSecret', {
+            registry: minimalRegistry,
+            eventBusArn,
+            dbSecretArn,
+        });
+        const template = Template.fromStack(stack);
+        template.allResources('AWS::Lambda::Function', {
+            Environment: {
+                Variables: {
+                    Match: {
+                        stringLike: {
+                            DB_SECRET_ARN: dbSecretArn,
+                        },
+                    },
+                },
+            },
+        });
+    });
+    it('secretsmanager:GetSecretValue grant added when dbSecretArn provided', () => {
+        const app = new cdk.App();
+        const dbSecretArn = 'arn:aws:secretsmanager:eu-north-1:123456789012:secret:db-secret-abc123';
+        const stack = new DomainStack(app, 'TestDomainStackSecretGrant', {
+            registry: minimalRegistry,
+            eventBusArn,
+            dbSecretArn,
+        });
+        const template = Template.fromStack(stack);
+        template.allResources('AWS::IAM::Policy', {
+            PolicyDocument: {
+                Match: {
+                    objectLike: {
+                        Statement: [
+                            {
+                                Match: {
+                                    objectLike: {
+                                        Action: ['secretsmanager:GetSecretValue'],
+                                        Resource: [dbSecretArn],
+                                    },
+                                },
+                            },
+                        ],
+                    },
+                },
+            },
+        });
+    });
+    describe('domain S3 bucket', () => {
+        const app = new cdk.App();
+        const stack = new DomainStack(app, 'TestDomainStackS3', { registry: minimalRegistry, eventBusArn });
+        const template = Template.fromStack(stack);
+        it('creates exactly one S3 bucket', () => {
+            template.resourceCountIs('AWS::S3::Bucket', 1);
+        });
+        it('enables versioning on the domain bucket', () => {
+            template.hasResourceProperties('AWS::S3::Bucket', {
+                VersioningConfiguration: {
+                    Status: 'Enabled',
+                },
+            });
+        });
+        it('has CfnOutput for bucket name', () => {
+            template.hasOutput('DomainBucketName', {});
+        });
+    });
+    describe('tenant-scoped IAM role (defence in depth)', () => {
+        const app = new cdk.App();
+        const stack = new DomainStack(app, 'TestDomainStackTenant', { registry: minimalRegistry, eventBusArn });
+        const template = Template.fromStack(stack);
+        it('creates a tenant-scoped IAM role', () => {
+            template.hasResourceProperties('AWS::IAM::Role', {
+                RoleName: 'tib-test-domain-tenant-scoped',
+            });
+        });
+        it('sets DOMAIN_TENANT_ROLE_ARN env var on each Lambda', () => {
+            const lambdas = template.findResources('AWS::Lambda::Function');
+            for (const [id, res] of Object.entries(lambdas)) {
+                // Skip health/readiness Lambdas from HealthConstruct
+                if (id.includes('Health') || id.includes('Ready'))
+                    continue;
+                expect(res.Properties.Environment.Variables).toHaveProperty('DOMAIN_TENANT_ROLE_ARN');
+            }
+        });
+        it('grants Lambda execution roles sts:AssumeRole + sts:TagSession on the tenant-scoped role', () => {
+            template.hasResourceProperties('AWS::IAM::Policy', {
+                PolicyDocument: {
+                    Statement: expect.arrayContaining([
+                        expect.objectContaining({
+                            Action: expect.arrayContaining(['sts:AssumeRole', 'sts:TagSession']),
+                            Effect: 'Allow',
+                        }),
+                    ]),
+                },
+            });
+        });
+        it('tenant-scoped role has trust policy with request-tag condition', () => {
+            template.hasResourceProperties('AWS::IAM::Role', {
+                AssumeRolePolicyDocument: {
+                    Statement: expect.arrayContaining([
+                        expect.objectContaining({
+                            Action: expect.arrayContaining(['sts:AssumeRole', 'sts:TagSession']),
+                            Effect: 'Allow',
+                            Condition: expect.objectContaining({
+                                StringLike: expect.objectContaining({
+                                    'aws:RequestTag/tenantId': '*',
+                                }),
+                            }),
+                        }),
+                    ]),
+                },
+            });
+        });
+        it('tenant-scoped role policy uses PrincipalTag conditions', () => {
+            template.hasResourceProperties('AWS::IAM::Policy', {
+                Roles: expect.arrayContaining([expect.objectContaining({ Ref: expect.any(String) })]),
+                PolicyDocument: {
+                    Statement: expect.arrayContaining([
+                        expect.objectContaining({
+                            Condition: expect.objectContaining({
+                                'ForAllValues:StringEquals': expect.objectContaining({
+                                    'dynamodb:LeadingKeys': ['${aws:PrincipalTag/tenantId}'],
+                                }),
+                            }),
+                        }),
+                    ]),
+                },
+            });
+        });
+        it('has CfnOutput for tenant-scoped role ARN', () => {
+            template.hasOutput('DomainTenantScopedRoleArn', {});
+        });
+    });
+});

package/dist/__tests__/lambda-factory.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/lambda-factory.test.js

@@ -0,0 +1,76 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import * as cdk from 'aws-cdk-lib';
+import { Template } from 'aws-cdk-lib/assertions';
+import * as lambdaNode from 'aws-cdk-lib/aws-lambda-nodejs';
+import fs from 'node:fs';
+import path from 'node:path';
+import { LambdaFactory } from '../lambda-factory.js';
+const DOMAIN_ROOT = '/tmp/test-domain-cdk-packer';
+const minimalRegistry = {
+    schemaVersion: '1',
+    domainRoot: DOMAIN_ROOT,
+    domain: { id: 'test-domain', kind: 'domain', name: 'Test Domain', tenancy: 'none' },
+    apis: [], webhooks: [], subscribers: [], schedules: [], jobs: [], actions: [], integrations: [], events: [],
+};
+beforeAll(() => {
+    const handlerDir = path.join(DOMAIN_ROOT, 'src');
+    fs.mkdirSync(handlerDir, { recursive: true });
+    fs.writeFileSync(path.join(handlerDir, 'api.ts'), 'export const handler = async () => ({ statusCode: 200 });\n');
+});
+afterAll(() => {
+    fs.rmSync(DOMAIN_ROOT, { recursive: true, force: true });
+});
+describe('LambdaFactory', () => {
+    it('creates a NodejsFunction construct without throwing', () => {
+        const app = new cdk.App();
+        const stack = new cdk.Stack(app, 'TestStack');
+        const factory = new LambdaFactory({ scope: stack, registry: minimalRegistry, domainRoot: minimalRegistry.domainRoot });
+        expect(() => {
+            factory.createFunction({ id: 'test-api', kind: 'api', handlerFile: 'src/api.ts' });
+        }).not.toThrow();
+    });
+    describe('bundling configuration', () => {
+        it('template has Lambda with ARM_64 architecture', () => {
+            const app = new cdk.App();
+            const stack = new cdk.Stack(app, 'TestStackArch');
+            const factory = new LambdaFactory({ scope: stack, registry: minimalRegistry, domainRoot: minimalRegistry.domainRoot });
+            factory.createFunction({ id: 'test-api', kind: 'api', handlerFile: 'src/api.ts' });
+            const template = Template.fromStack(stack);
+            template.hasResourceProperties('AWS::Lambda::Function', {
+                Architectures: ['arm64'],
+            });
+        });
+        it('template has Lambda with NODEJS_22_X runtime', () => {
+            const app = new cdk.App();
+            const stack = new cdk.Stack(app, 'TestStackRuntime');
+            const factory = new LambdaFactory({ scope: stack, registry: minimalRegistry, domainRoot: minimalRegistry.domainRoot });
+            factory.createFunction({ id: 'test-api', kind: 'api', handlerFile: 'src/api.ts' });
+            const template = Template.fromStack(stack);
+            template.hasResourceProperties('AWS::Lambda::Function', {
+                Runtime: 'nodejs22.x',
+            });
+        });
+        it('template has Lambda with NODE_OPTIONS for source maps', () => {
+            const app = new cdk.App();
+            const stack = new cdk.Stack(app, 'TestStackSourceMaps');
+            const factory = new LambdaFactory({ scope: stack, registry: minimalRegistry, domainRoot: minimalRegistry.domainRoot });
+            factory.createFunction({ id: 'test-api', kind: 'api', handlerFile: 'src/api.ts' });
+            const template = Template.fromStack(stack);
+            template.hasResourceProperties('AWS::Lambda::Function', {
+                Environment: {
+                    Variables: {
+                        NODE_OPTIONS: '--enable-source-maps',
+                    },
+                },
+            });
+        });
+        it('creates NodejsFunction with required bundling defaults (minify, INLINE sourceMap, treeShaking, external @aws-sdk/*)', () => {
+            const app = new cdk.App();
+            const stack = new cdk.Stack(app, 'TestStackDefaults');
+            const factory = new LambdaFactory({ scope: stack, registry: minimalRegistry, domainRoot: minimalRegistry.domainRoot });
+            const fn = factory.createFunction({ id: 'test-api', kind: 'api', handlerFile: 'src/api.ts' });
+            expect(fn).toBeInstanceOf(lambdaNode.NodejsFunction);
+            expect(fn.runtime?.name).toContain('nodejs22');
+        });
+    });
+});

package/dist/__tests__/pack-flows.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/pack-flows.test.js

@@ -0,0 +1,283 @@
+import { describe, it, expect } from 'vitest';
+import { FlowsStack, packFlows } from '../pack-flows.js';
+import * as cdk from 'aws-cdk-lib';
+describe('packFlows', () => {
+    it('creates a FlowsStack from a registry', () => {
+        const app = new cdk.App();
+        const registry = {
+            schemaVersion: '1',
+            flows: [
+                {
+                    id: 'test-flow',
+                    name: 'Test Flow',
+                    steps: [
+                        {
+                            type: 'flow-control',
+                            control: 'succeed',
+                            name: 'End',
+                        },
+                    ],
+                },
+            ],
+        };
+        const stack = packFlows(registry, app, 'test-flows', {
+            domainLambdaArns: {},
+            eventBusArn: 'arn:aws:events:us-east-1:123456789012:event-bus/test',
+        });
+        expect(stack).toBeInstanceOf(FlowsStack);
+        expect(stack.flowArnMap).toBeDefined();
+    });
+    it('throws when domain-action step references missing Lambda ARN', () => {
+        const app = new cdk.App();
+        const registry = {
+            schemaVersion: '1',
+            flows: [
+                {
+                    id: 'action-flow',
+                    name: 'Action Flow',
+                    steps: [
+                        {
+                            type: 'domain-action',
+                            name: 'RunAction',
+                            domainId: 'example',
+                            actionId: 'process',
+                        },
+                    ],
+                },
+            ],
+        };
+        expect(() => {
+            packFlows(registry, app, 'test-flows', {
+                domainLambdaArns: {},
+                eventBusArn: 'arn:aws:events:us-east-1:123456789012:event-bus/test',
+            });
+        }).toThrow(/no Lambda ARN for example-action/);
+    });
+    it('translates domain-action step with Lambda ARN', () => {
+        const app = new cdk.App();
+        const registry = {
+            schemaVersion: '1',
+            flows: [
+                {
+                    id: 'action-flow',
+                    name: 'Action Flow',
+                    steps: [
+                        {
+                            type: 'domain-action',
+                            name: 'RunAction',
+                            domainId: 'example',
+                            actionId: 'process',
+                        },
+                    ],
+                },
+            ],
+        };
+        const stack = packFlows(registry, app, 'test-flows', {
+            domainLambdaArns: {
+                'example-action': 'arn:aws:lambda:us-east-1:123456789012:function:test',
+            },
+            eventBusArn: 'arn:aws:events:us-east-1:123456789012:event-bus/test',
+        });
+        expect(stack.flowArnMap['action-flow']).toBeDefined();
+    });
+    it('translates domain-event step to putEvents', () => {
+        const app = new cdk.App();
+        const registry = {
+            schemaVersion: '1',
+            flows: [
+                {
+                    id: 'event-flow',
+                    name: 'Event Flow',
+                    steps: [
+                        {
+                            type: 'domain-event',
+                            name: 'EmitEvent',
+                            eventId: 'example.completed',
+                            payload: { status: 'ok' },
+                            version: 1,
+                        },
+                    ],
+                },
+            ],
+        };
+        const stack = packFlows(registry, app, 'test-flows', {
+            domainLambdaArns: {},
+            eventBusArn: 'arn:aws:events:us-east-1:123456789012:event-bus/test',
+        });
+        expect(stack.flowArnMap['event-flow']).toBeDefined();
+    });
+    it('handles empty flow registry gracefully', () => {
+        const app = new cdk.App();
+        const registry = {
+            schemaVersion: '1',
+            flows: [],
+        };
+        const stack = packFlows(registry, app, 'test-flows', {
+            domainLambdaArns: {},
+            eventBusArn: 'arn:aws:events:us-east-1:123456789012:event-bus/test',
+        });
+        expect(Object.keys(stack.flowArnMap)).toHaveLength(0);
+    });
+    it('creates EXPRESS state machine when flow type is express', () => {
+        const app = new cdk.App();
+        const registry = {
+            schemaVersion: '1',
+            flows: [
+                {
+                    id: 'express-flow',
+                    type: 'express',
+                    name: 'Express Flow',
+                    steps: [{ type: 'flow-control', control: 'succeed', name: 'End' }],
+                },
+            ],
+        };
+        const stack = packFlows(registry, app, 'test-flows-express', {
+            domainLambdaArns: {},
+            eventBusArn: 'arn:aws:events:us-east-1:123456789012:event-bus/test',
+        });
+        expect(stack.flowArnMap['express-flow']).toBeDefined();
+    });
+    it('creates STANDARD state machine when flow type is standard', () => {
+        const app = new cdk.App();
+        const registry = {
+            schemaVersion: '1',
+            flows: [
+                {
+                    id: 'standard-flow',
+                    type: 'standard',
+                    name: 'Standard Flow',
+                    steps: [{ type: 'flow-control', control: 'succeed', name: 'End' }],
+                },
+            ],
+        };
+        const stack = packFlows(registry, app, 'test-flows-standard', {
+            domainLambdaArns: {},
+            eventBusArn: 'arn:aws:events:us-east-1:123456789012:event-bus/test',
+        });
+        expect(stack.flowArnMap['standard-flow']).toBeDefined();
+    });
+    it('defaults to EXPRESS state machine when type is not specified', () => {
+        const app = new cdk.App();
+        const registry = {
+            schemaVersion: '1',
+            flows: [
+                {
+                    id: 'default-flow',
+                    name: 'Default Flow',
+                    steps: [{ type: 'flow-control', control: 'succeed', name: 'End' }],
+                },
+            ],
+        };
+        const stack = packFlows(registry, app, 'test-flows-default', {
+            domainLambdaArns: {},
+            eventBusArn: 'arn:aws:events:us-east-1:123456789012:event-bus/test',
+        });
+        expect(stack.flowArnMap['default-flow']).toBeDefined();
+    });
+    it('adds IAM lambda:InvokeFunction grant when flow has domain-action steps', () => {
+        const app = new cdk.App();
+        const actionArn = 'arn:aws:lambda:eu-north-1:123456789012:function:example-process';
+        const registry = {
+            schemaVersion: '1',
+            flows: [
+                {
+                    id: 'cross-domain-flow',
+                    name: 'Cross Domain Flow',
+                    steps: [
+                        {
+                            type: 'domain-action',
+                            name: 'CallExternalDomain',
+                            domainId: 'example',
+                            actionId: 'process',
+                        },
+                    ],
+                },
+            ],
+        };
+        // Should not throw — ARN is provided and IAM grant added
+        const stack = packFlows(registry, app, 'test-cross-domain', {
+            domainLambdaArns: { 'example-action': actionArn },
+            eventBusArn: 'arn:aws:events:eu-north-1:123456789012:event-bus/test',
+        });
+        expect(stack.flowArnMap['cross-domain-flow']).toBeDefined();
+    });
+    it('skips IAM grant when domain-action step has no matching Lambda ARN', () => {
+        const app = new cdk.App();
+        const registry = {
+            schemaVersion: '1',
+            flows: [
+                {
+                    id: 'no-arn-flow',
+                    name: 'No ARN Flow',
+                    steps: [
+                        { type: 'flow-control', control: 'succeed', name: 'End' },
+                    ],
+                },
+            ],
+        };
+        // No domain-action steps — no IAM grant needed
+        const stack = packFlows(registry, app, 'test-no-arn', {
+            domainLambdaArns: {},
+            eventBusArn: 'arn:aws:events:eu-north-1:123456789012:event-bus/test',
+        });
+        expect(stack.flowArnMap['no-arn-flow']).toBeDefined();
+    });
+    it('emits waitForTaskToken resource for domain-action step with waitForTaskToken=true', () => {
+        const app = new cdk.App();
+        const registry = {
+            schemaVersion: '1',
+            flows: [
+                {
+                    id: 'wftt-flow',
+                    type: 'standard',
+                    name: 'Wait Flow',
+                    steps: [
+                        {
+                            type: 'domain-action',
+                            name: 'PauseStep',
+                            domainId: 'example',
+                            actionId: 'pause',
+                            waitForTaskToken: true,
+                            next: 'End',
+                        },
+                        { type: 'flow-control', control: 'succeed', name: 'End' },
+                    ],
+                },
+            ],
+        };
+        const stack = packFlows(registry, app, 'test-wftt', {
+            domainLambdaArns: { 'example-action': 'arn:aws:lambda:eu-north-1:123:function:example-pause' },
+            eventBusArn: 'arn:aws:events:eu-north-1:123:event-bus/test',
+        });
+        expect(stack.flowArnMap['wftt-flow']).toBeDefined();
+        expect(stack.taskTokensTableName).toBeDefined();
+    });
+    it('creates the DDB task tokens table in the stack', () => {
+        const app = new cdk.App();
+        const registry = { schemaVersion: '1', flows: [] };
+        const stack = packFlows(registry, app, 'test-ddb', {
+            domainLambdaArns: {},
+            eventBusArn: 'arn:aws:events:eu-north-1:123:event-bus/test',
+        });
+        expect(stack.taskTokensTableName).toBeDefined();
+        expect(stack.taskTokensTableArn).toBeDefined();
+    });
+});
+describe('IamPolicyBuilder.forFlow', () => {
+    it('returns empty array when no action ARNs', async () => {
+        const { IamPolicyBuilder } = await import('../iam/iam-policy-builder.js');
+        const builder = new IamPolicyBuilder();
+        expect(builder.forFlow([])).toHaveLength(0);
+    });
+    it('returns lambda:InvokeFunction statement for provided ARNs', async () => {
+        const { IamPolicyBuilder } = await import('../iam/iam-policy-builder.js');
+        const builder = new IamPolicyBuilder();
+        const arns = [
+            'arn:aws:lambda:eu-north-1:123:function:auth-verify-token',
+            'arn:aws:lambda:eu-north-1:123:function:payments-charge-card',
+        ];
+        const statements = builder.forFlow(arns);
+        expect(statements).toHaveLength(1);
+        expect(JSON.stringify(statements[0]?.toStatementJson())).toContain('lambda:InvokeFunction');
+    });
+});

package/dist/__tests__/registry.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/registry.test.js

@@ -0,0 +1,34 @@
+import { describe, it, expect } from 'vitest';
+describe('DomainRegistry type', () => {
+    it('accepts a valid minimal registry object', () => {
+        const r = {
+            schemaVersion: '1',
+            domainRoot: '/workspace/my-domain',
+            domain: { id: 'my-domain', kind: 'domain', name: 'My Domain', tenancy: 'required' },
+            apis: [],
+            webhooks: [],
+            subscribers: [],
+            schedules: [],
+            jobs: [],
+            actions: [],
+            integrations: [],
+            events: [],
+        };
+        expect(r.schemaVersion).toBe('1');
+        expect(r.domain.kind).toBe('domain');
+    });
+    it('discriminates RegistryEntry union by kind', () => {
+        const entries = [
+            { id: 'test-api', kind: 'api', handlerFile: 'src/api.ts', path: '/test', method: 'GET', authType: 'jwt' },
+            { id: 'test-job', kind: 'job', handlerFile: 'src/job.ts', maxRetries: 3, visibilityTimeoutSeconds: 30 },
+        ];
+        for (const entry of entries) {
+            if (entry.kind === 'api') {
+                expect(entry.path).toBeDefined();
+            }
+            if (entry.kind === 'job') {
+                expect(entry.maxRetries).toBeDefined();
+            }
+        }
+    });
+});

package/dist/__tests__/step-functions-codegen.test.d.ts

@@ -0,0 +1 @@
+export {};