@aws-blocks/core 0.4.0 → 0.5.0

package/dist/scripts/generate-spec.test.js

@@ -15,6 +15,7 @@ import { join, dirname } from 'path';
 import { tmpdir } from 'os';
 import { fileURLToPath, pathToFileURL } from 'url';
 import { generateSpec } from './generate-spec.js';
+import { ApiNamespace } from '../api.js';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 // `import.meta.url` lives in dist/scripts/, so `..` is dist/ and the built
 // `api.js` is next to it. Re-using the real ApiNamespace ensures the marker
@@ -86,3 +87,95 @@ describe('generateSpec — @blocksSkipCodegen', () => {
         }
     });
 });
+describe('generateSpec — namespaces sharing a method name (regression: #445)', () => {
+    it('emits each namespace its OWN schema for a same-named method', async () => {
+        const dir = join(tmpdir(), `blocks-spec-test-${Date.now()}-collision`);
+        mkdirSync(dir, { recursive: true });
+        writeTsconfig(dir);
+        // Typed foundation for the TS type extractor. `create` has DIFFERENT params
+        // in each namespace; binding names (widgets/subscriptions) match the runtime
+        // module's export names below.
+        writeFileSync(join(dir, 'index.ts'), `
+			interface ApiNamespaceConstructor { new <T>(scope: any, name: string, handler: (ctx: any) => T): T; }
+			const ApiNamespace: ApiNamespaceConstructor = class {} as any;
+
+			export const widgets = new ApiNamespace(null, 'widgets', () => ({
+				async create(label: string): Promise<{ widgetId: string }> { return { widgetId: 'w' }; },
+			}));
+			export const subscriptions = new ApiNamespace(null, 'subscriptions', () => ({
+				async create(topicCount: number): Promise<{ subId: number }> { return { subId: 1 }; },
+			}));
+		`);
+        // Runtime module for namespace discovery (types come from the .ts above via
+        // the extractor). Use the real ApiNamespace so the marker symbol matches.
+        const widgets = new ApiNamespace(null, 'widgets', () => ({ async create(_label) { return { widgetId: 'w' }; } }));
+        const subscriptions = new ApiNamespace(null, 'subscriptions', () => ({ async create(_topicCount) { return { subId: 1 }; } }));
+        const loader = async () => ({ widgets, subscriptions });
+        try {
+            const doc = await generateSpec(join(dir, 'index.ts'), loader);
+            const byName = new Map(doc.methods.map((m) => [m.name, m]));
+            const w = byName.get('widgets.create');
+            const s = byName.get('subscriptions.create');
+            assert.ok(w && s, 'both namespace-qualified methods should be present');
+            // Each keeps its OWN param — no cross-assignment.
+            assert.strictEqual(w.params[0]?.name, 'label');
+            assert.strictEqual(w.params[0]?.schema?.type, 'string');
+            assert.strictEqual(s.params[0]?.name, 'topicCount');
+            assert.strictEqual(s.params[0]?.schema?.type, 'number');
+        }
+        finally {
+            rmSync(dir, { recursive: true, force: true });
+        }
+    });
+});
+describe('generateSpec — namespace returned by a factory, then destructured (regression: #444)', () => {
+    it('emits real schemas (not unknown) for a factory/destructured namespace', async () => {
+        const dir = join(tmpdir(), `blocks-spec-test-${Date.now()}-factory`);
+        mkdirSync(dir, { recursive: true });
+        writeTsconfig(dir);
+        // Typed foundation: one directly-exported namespace and one built inside a
+        // factory, returned as a property, destructured, and re-exported. Both use
+        // `create` with DIFFERENT params so a regression would cross-assign or emit
+        // unknown.
+        writeFileSync(join(dir, 'index.ts'), `
+			interface ApiNamespaceConstructor { new <T>(scope: any, name: string, handler: (ctx: any) => T): T; }
+			const ApiNamespace: ApiNamespaceConstructor = class {} as any;
+			class Scope { constructor(id: string) {} }
+
+			class Factory {
+				constructor(private readonly scope: Scope) {}
+				build() {
+					return {
+						subscriptions: new ApiNamespace(this.scope, 'subscriptions', () => ({
+							async create(topicCount: number): Promise<{ subId: number }> { return { subId: 1 }; },
+						})),
+					};
+				}
+			}
+
+			const scope = new Scope('app');
+			export const widgets = new ApiNamespace(scope, 'widgets', () => ({
+				async create(label: string): Promise<{ widgetId: string }> { return { widgetId: 'w' }; },
+			}));
+			const { subscriptions } = new Factory(scope).build();
+			export { subscriptions };
+		`);
+        const widgets = new ApiNamespace(null, 'widgets', () => ({ async create(_label) { return { widgetId: 'w' }; } }));
+        const subscriptions = new ApiNamespace(null, 'subscriptions', () => ({ async create(_topicCount) { return { subId: 1 }; } }));
+        const loader = async () => ({ widgets, subscriptions });
+        try {
+            const doc = await generateSpec(join(dir, 'index.ts'), loader);
+            const byName = new Map(doc.methods.map((m) => [m.name, m]));
+            const w = byName.get('widgets.create');
+            const s = byName.get('subscriptions.create');
+            assert.ok(w && s, 'both qualified methods present');
+            // The factory-returned namespace keeps its own param, not `unknown` and
+            // not the direct namespace's `string`.
+            assert.strictEqual(s.params[0]?.schema?.type, 'number');
+            assert.strictEqual(w.params[0]?.schema?.type, 'string');
+        }
+        finally {
+            rmSync(dir, { recursive: true, force: true });
+        }
+    });
+});

package/dist/version.d.ts

@@ -1,2 +1,2 @@
-export declare const CORE_VERSION = "0.4.0";
+export declare const CORE_VERSION = "0.5.0";
 //# sourceMappingURL=version.d.ts.map

package/dist/version.js

@@ -1,2 +1,2 @@
 // Auto-generated by scripts/generate-version.mjs — do not edit manually
-export const CORE_VERSION = '0.4.0';
+export const CORE_VERSION = '0.5.0';

package/package.json

@@ -1,6 +1,13 @@
 {
   "name": "@aws-blocks/core",
-  "version": "0.4.0",
+  "version": "0.5.0",
+  "keywords": [
+    "aws-blocks",
+    "framework",
+    "typescript",
+    "backend",
+    "primitives"
+  ],
   "repository": {
     "type": "git",
     "url": "git+https://github.com/aws-devtools-labs/aws-blocks.git",

package/src/cdk/blocks-backend.test.ts

@@ -8,6 +8,7 @@ import { fileURLToPath } from 'node:url';
 import * as cdk from 'aws-cdk-lib';
 import { Match, Template } from 'aws-cdk-lib/assertions';
 import * as apigateway from 'aws-cdk-lib/aws-apigateway';
+import type { IWidget } from 'aws-cdk-lib/aws-cloudwatch';
 import { PolicyStatement } from 'aws-cdk-lib/aws-iam';
 import * as lambda from 'aws-cdk-lib/aws-lambda-nodejs';
 import type { Construct } from 'constructs';
@@ -18,6 +19,7 @@ import { BlocksPresets } from './blocks-defaults.js';
 import { Compute } from './compute/compute.js';
 import type { DefaultComputeFactory } from './compute/default-compute-factory.js';
 import { Scope } from './index.js';
+import { getVpcContext } from './vpc.js';
 
 // A real app gets its default compute from @aws-blocks/bb-lambda-compute (via
 // @aws-blocks/blocks), which core's own tests can't depend on. Use an
@@ -37,6 +39,11 @@ class StubLambdaCompute extends Compute {
 		this.logGroup = new cdk.aws_logs.LogGroup(this, 'HandlerLogGroup', {
 			removalPolicy: cdk.RemovalPolicy.DESTROY,
 		});
+		// Discover the shared VPC context from the owning stack/backend, mirroring
+		// LambdaCompute — so the core-side VPC placement plumbing (initializeVpc →
+		// getVpcContext) is exercised by these tests without depending on
+		// @aws-blocks/bb-lambda-compute.
+		const vpcContext = getVpcContext(this);
 		this.fn = new lambda.NodejsFunction(this, 'Handler', {
 			entry: this.backendHandlerPath,
 			runtime: cdk.aws_lambda.Runtime.NODEJS_22_X,
@@ -45,6 +52,13 @@ class StubLambdaCompute extends Compute {
 			logGroup: this.logGroup,
 			environment: { BLOCKS_STACK_NAME: this.backendStackName },
 			bundling: { minify: true, esbuildArgs: { '--conditions': 'aws-runtime' } },
+			...(vpcContext
+				? {
+						vpc: vpcContext.vpc,
+						vpcSubnets: vpcContext.computeSubnets,
+						securityGroups: [vpcContext.computeSecurityGroup],
+					}
+				: {}),
 		});
 		this.apiGateway = new apigateway.RestApi(this, 'API', { restApiName: 'Blocks API' });
 		this.apiGateway.root.addProxy({
@@ -57,6 +71,17 @@ class StubLambdaCompute extends Compute {
 	setEnv(key: string, value: string): void {
 		this.fn.addEnvironment(key, value);
 	}
+
+	protected applyTracing(): void {}
+	protected healthWidgets(_region: string): IWidget[][] {
+		return [];
+	}
+	protected loggingWidgets(_region: string): IWidget[][] {
+		return [];
+	}
+	protected tracingWidgets(_region: string): IWidget[][] {
+		return [];
+	}
 }
 
 const stubComputeFactory: DefaultComputeFactory = (root) => new StubLambdaCompute(root as never, 'DefaultCompute');
@@ -77,7 +102,12 @@ const importMetaHandlerPath = join(__dirname, '__fixtures__', 'import-meta-handl
 // Wraps BlocksBackend.create, injecting the stub default-compute factory the way
 // @aws-blocks/blocks injects LambdaCompute — so tests don't repeat it 15 times.
 const makeBackend = (scope: Construct, id: string, backendCDKPath: string) =>
-	BlocksBackend.create(scope, id, { backendHandlerPath: handlerPath, backendCDKPath, defaults: BlocksPresets.production, defaultComputeFactory: stubComputeFactory });
+	BlocksBackend.create(scope, id, {
+		backendHandlerPath: handlerPath,
+		backendCDKPath,
+		defaults: BlocksPresets.production,
+		defaultComputeFactory: stubComputeFactory,
+	});
 
 describe('ESM cache-busting (multi-stage)', () => {
 	test('BlocksBackend.create() with same backendCDKPath but different IDs produces constructs in each', async () => {
@@ -230,25 +260,25 @@ describe('shared execution role', () => {
 });
 
 describe('CJS bundle: import.meta.url in the handler is shimmed (no Lambda-load crash)', () => {
-  test('a handler that uses import.meta.url bundles successfully instead of throwing at load', async () => {
-    // The handler is bundled to CJS, where `import.meta` is empty. Left unshimmed,
-    // `fileURLToPath(import.meta.url)` compiles to `fileURLToPath(undefined)` and
-    // throws at Lambda load (esbuild only warns, so the broken bundle would deploy).
-    // blocksNodejsBundling shims import.meta.* to CommonJS equivalents, so bundling
-    // (which runs synchronously during construction) succeeds. The runtime behaviour
-    // of the emitted shim is verified directly in bundling.test.ts.
-    const app = new cdk.App();
-    const stack = new cdk.Stack(app, 'ImportMetaStack');
-
-    await assert.doesNotReject(() =>
-      BlocksBackend.create(stack, 'blocks', {
-        backendHandlerPath: importMetaHandlerPath,
-        backendCDKPath: sideEffectBackendPath,
-        defaults: BlocksPresets.production,
-        defaultComputeFactory: stubComputeFactory,
-      }),
-    );
-  });
+	test('a handler that uses import.meta.url bundles successfully instead of throwing at load', async () => {
+		// The handler is bundled to CJS, where `import.meta` is empty. Left unshimmed,
+		// `fileURLToPath(import.meta.url)` compiles to `fileURLToPath(undefined)` and
+		// throws at Lambda load (esbuild only warns, so the broken bundle would deploy).
+		// blocksNodejsBundling shims import.meta.* to CommonJS equivalents, so bundling
+		// (which runs synchronously during construction) succeeds. The runtime behaviour
+		// of the emitted shim is verified directly in bundling.test.ts.
+		const app = new cdk.App();
+		const stack = new cdk.Stack(app, 'ImportMetaStack');
+
+		await assert.doesNotReject(() =>
+			BlocksBackend.create(stack, 'blocks', {
+				backendHandlerPath: importMetaHandlerPath,
+				backendCDKPath: sideEffectBackendPath,
+				defaults: BlocksPresets.production,
+				defaultComputeFactory: stubComputeFactory,
+			}),
+		);
+	});
 });
 
 describe('factory function support', () => {
@@ -348,44 +378,98 @@ describe('fullId is token-free (construct IDs / env-var keys)', () => {
 });
 
 describe('infrastructure defaults (backend-anchored)', () => {
-  test('each backend exposes its own defaults', async () => {
-    const app = new cdk.App();
-    const stack = new cdk.Stack(app, 'TwoBackendsStack');
-
-    const a = await BlocksBackend.create(stack, 'A', {
-      backendHandlerPath: handlerPath,
-      backendCDKPath: sideEffectBackendPath,
-      defaults: BlocksPresets.production,
-      defaultComputeFactory: stubComputeFactory,
-    });
-    const b = await BlocksBackend.create(stack, 'B', {
-      backendHandlerPath: handlerPath,
-      backendCDKPath: sideEffectBackendPath,
-      defaults: BlocksPresets.sandbox,
-      defaultComputeFactory: stubComputeFactory,
-    });
-
-    // Two backends in one stack must NOT clobber each other — defaults are
-    // anchored on the backend, not the shared stack.
-    assert.strictEqual(a.defaults, BlocksPresets.production);
-    assert.strictEqual(b.defaults, BlocksPresets.sandbox);
-  });
-
-  test('a nested block resolves its owning backend defaults via the tree-walk', async () => {
-    const app = new cdk.App();
-    const stack = new cdk.Stack(app, 'ResolveDefaultsStack');
-
-    const backend = await BlocksBackend.create(stack, 'Blocks', {
-      backendHandlerPath: handlerPath,
-      backendCDKPath: sideEffectBackendPath,
-      defaults: BlocksPresets.sandbox,
-      defaultComputeFactory: stubComputeFactory,
-    });
-
-    // A Scope under the backend resolves scope.defaults by walking up to it.
-    const outer = new Scope('outer');
-    const inner = new Scope('inner', { parent: outer });
-    assert.strictEqual(inner.defaults, backend.defaults);
-    assert.strictEqual(inner.defaults, BlocksPresets.sandbox);
-  });
+	test('each backend exposes its own defaults', async () => {
+		const app = new cdk.App();
+		const stack = new cdk.Stack(app, 'TwoBackendsStack');
+
+		const a = await BlocksBackend.create(stack, 'A', {
+			backendHandlerPath: handlerPath,
+			backendCDKPath: sideEffectBackendPath,
+			defaults: BlocksPresets.production,
+			defaultComputeFactory: stubComputeFactory,
+		});
+		const b = await BlocksBackend.create(stack, 'B', {
+			backendHandlerPath: handlerPath,
+			backendCDKPath: sideEffectBackendPath,
+			defaults: BlocksPresets.sandbox,
+			defaultComputeFactory: stubComputeFactory,
+		});
+
+		// Two backends in one stack must NOT clobber each other — defaults are
+		// anchored on the backend, not the shared stack.
+		assert.strictEqual(a.defaults, BlocksPresets.production);
+		assert.strictEqual(b.defaults, BlocksPresets.sandbox);
+	});
+
+	test('a nested block resolves its owning backend defaults via the tree-walk', async () => {
+		const app = new cdk.App();
+		const stack = new cdk.Stack(app, 'ResolveDefaultsStack');
+
+		const backend = await BlocksBackend.create(stack, 'Blocks', {
+			backendHandlerPath: handlerPath,
+			backendCDKPath: sideEffectBackendPath,
+			defaults: BlocksPresets.sandbox,
+			defaultComputeFactory: stubComputeFactory,
+		});
+
+		// A Scope under the backend resolves scope.defaults by walking up to it.
+		const outer = new Scope('outer');
+		const inner = new Scope('inner', { parent: outer });
+		assert.strictEqual(inner.defaults, backend.defaults);
+		assert.strictEqual(inner.defaults, BlocksPresets.sandbox);
+	});
+});
+
+describe('VPC placement', () => {
+	test('places the handler Lambda in the VPC with a security group when vpc is provided', async () => {
+		const app = new cdk.App();
+		const parent = new cdk.Stack(app, 'VpcParent', {
+			env: { account: '123456789012', region: 'us-east-1' },
+		});
+		const vpc = new cdk.aws_ec2.Vpc(parent, 'AppVpc', { maxAzs: 2, natGateways: 1 });
+
+		await BlocksBackend.create(parent, 'Blocks', {
+			backendHandlerPath: handlerPath,
+			backendCDKPath: sideEffectBackendPath,
+			defaults: { ...BlocksPresets.production, vpc: { network: vpc } },
+			defaultComputeFactory: stubComputeFactory,
+		});
+
+		const template = Template.fromStack(parent);
+		// The handler Lambda is VPC-attached: it has a VpcConfig with subnets + SGs.
+		template.hasResourceProperties('AWS::Lambda::Function', {
+			VpcConfig: Match.objectLike({
+				SubnetIds: Match.anyValue(),
+				SecurityGroupIds: Match.anyValue(),
+			}),
+		});
+		// The VPC-access managed policy is attached to the execution role.
+		const policies = template.findResources('AWS::IAM::Role');
+		const hasVpcManagedPolicy = Object.values(policies).some((role: any) =>
+			JSON.stringify(role.Properties?.ManagedPolicyArns ?? []).includes('AWSLambdaVPCAccessExecutionRole'),
+		);
+		assert.ok(hasVpcManagedPolicy, 'execution role should have the VPC access managed policy');
+	});
+
+	test('no VpcConfig on the handler when vpc is omitted', async () => {
+		const app = new cdk.App();
+		const parent = new cdk.Stack(app, 'NoVpcParent');
+
+		await BlocksBackend.create(parent, 'Blocks', {
+			backendHandlerPath: handlerPath,
+			backendCDKPath: sideEffectBackendPath,
+			defaults: BlocksPresets.production,
+			defaultComputeFactory: stubComputeFactory,
+		});
+
+		const template = Template.fromStack(parent);
+		const fns = template.findResources('AWS::Lambda::Function');
+		for (const fn of Object.values(fns)) {
+			assert.strictEqual(
+				(fn as any).Properties?.VpcConfig,
+				undefined,
+				'handler must not have VpcConfig when no VPC is configured',
+			);
+		}
+	});
 });