@aws-blocks/core 0.4.0 → 0.5.0

package/src/scripts/generate-spec.test.ts

@@ -16,6 +16,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
@@ -97,3 +98,103 @@ 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 as any, 'widgets', () => ({ async create(_label: string) { return { widgetId: 'w' }; } }));
+		const subscriptions = new ApiNamespace(null as any, 'subscriptions', () => ({ async create(_topicCount: number) { return { subId: 1 }; } }));
+		const loader = async () => ({ widgets, subscriptions }) as Record<string, unknown>;
+
+		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] as any)?.schema?.type, 'string');
+			assert.strictEqual(s!.params[0]?.name, 'topicCount');
+			assert.strictEqual((s!.params[0] as any)?.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 as any, 'widgets', () => ({ async create(_label: string) { return { widgetId: 'w' }; } }));
+		const subscriptions = new ApiNamespace(null as any, 'subscriptions', () => ({ async create(_topicCount: number) { return { subId: 1 }; } }));
+		const loader = async () => ({ widgets, subscriptions }) as Record<string, unknown>;
+
+		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] as any)?.schema?.type, 'number');
+			assert.strictEqual((w!.params[0] as any)?.schema?.type, 'string');
+		} finally {
+			rmSync(dir, { recursive: true, force: true });
+		}
+	});
+});

package/src/scripts/generate-spec.ts

@@ -324,6 +324,16 @@ export async function generateSpec(
 		for (const [methodName, methodFn] of Object.entries(methodMap)) {
 			if (typeof methodFn !== 'function') continue;
 
+			const qualifiedName = `${routingName}.${methodName}`;
+			// Prefer the namespace-qualified TS types; fall back to the bare method
+			// name for entries the extractor couldn't attribute to a namespace.
+			// Qualified keys stop two namespaces that share a method name (e.g.
+			// widgets.create / subscriptions.create) from cross-assigning schemas.
+			// Residual edge: namespaces the extractor can't attribute (default export,
+			// factory-wrapped, or an `export { x as y }` rename) still land on bare
+			// keys and could overwrite each other here — same class as #445, but rare.
+			const tsInfo = tsTypes.get(qualifiedName) ?? tsTypes.get(methodName);
+
 			// `@blocksSkipCodegen` is a JSDoc tag the customer puts on a method
 			// they want callable from the generated TS client (Proxy-based,
 			// doesn't enumerate) but absent from the OpenRPC spec — so native
@@ -334,9 +344,11 @@ export async function generateSpec(
 			// type-resolution errors and silently empty its Map — we always
 			// want the JSDoc tag to be honored, so the AST-only scan acts as
 			// a safety net.
-			if (tsTypes.get(methodName)?.skipCodegen || skipCodegenNames.has(methodName)) continue;
+			// The skip set is namespace-qualified too (with a bare fallback), so a
+			// `@blocksSkipCodegen` tag on one namespace's method doesn't drop another
+			// namespace's same-named method.
+			if (tsInfo?.skipCodegen || skipCodegenNames.has(qualifiedName) || skipCodegenNames.has(methodName)) continue;
 
-			const qualifiedName = `${routingName}.${methodName}`;
 			const resultName = capitalize(methodName) + 'Result';
 			const paramNames = extractParamNames(methodFn);
 			const fnSource = methodFn.toString();
@@ -380,7 +392,6 @@ export async function generateSpec(
 				}));
 			} else {
 				// No Zod schema — fall back to TypeScript AST types
-				const tsInfo = tsTypes.get(methodName);
 				if (tsInfo) {
 					params = tsInfo.params.map((p) => ({
 						name: p.name,
@@ -397,8 +408,7 @@ export async function generateSpec(
 				}
 			}
 
-			// Return type: Zod doesn't cover this yet, so use TS types
-			const tsInfo = tsTypes.get(methodName);
+			// Return type: Zod doesn't cover this yet, so use TS types (tsInfo resolved above)
 			const rawResultSchema = tsInfo?.returnType && tsInfo.returnType.type !== 'unknown'
 				? tsInfo.returnType
 				: { type: 'unknown' };

package/src/version.ts

@@ -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';