@aws-blocks/core 0.1.12 → 0.1.13

package/dist/redact.d.ts

@@ -44,8 +44,9 @@ export declare const REDACTED: "[REDACTED]";
 export declare function redactForLogging(value: unknown, seen?: WeakSet<object>): unknown;
 /**
  * Convenience for log call sites: redact `value` and serialize it to a JSON
- * string. Returns a safe placeholder instead of throwing if serialization
- * fails (e.g. a BigInt slips through), so logging can never crash a request.
+ * string. Returns `'undefined'` when JSON serialization produces no output,
+ * or a safe placeholder if serialization throws (e.g. a BigInt slips through),
+ * so logging can never crash a request.
  */
 export declare function redactToJson(value: unknown): string;
 //# sourceMappingURL=redact.d.ts.map

package/dist/redact.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"redact.d.ts","sourceRoot":"","sources":["../src/redact.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,sDAAsD;AACtD,eAAO,MAAM,QAAQ,EAAG,YAAqB,CAAC;AAwC9C;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,GAAE,OAAO,CAAC,MAAM,CAAiB,GAAG,OAAO,CA2C/F;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAMnD"}
+{"version":3,"file":"redact.d.ts","sourceRoot":"","sources":["../src/redact.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,sDAAsD;AACtD,eAAO,MAAM,QAAQ,EAAG,YAAqB,CAAC;AAwC9C;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,GAAE,OAAO,CAAC,MAAM,CAAiB,GAAG,OAAO,CA2C/F;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAMnD"}

package/dist/redact.js

@@ -121,12 +121,13 @@ export function redactForLogging(value, seen = new WeakSet()) {
 }
 /**
  * Convenience for log call sites: redact `value` and serialize it to a JSON
- * string. Returns a safe placeholder instead of throwing if serialization
- * fails (e.g. a BigInt slips through), so logging can never crash a request.
+ * string. Returns `'undefined'` when JSON serialization produces no output,
+ * or a safe placeholder if serialization throws (e.g. a BigInt slips through),
+ * so logging can never crash a request.
  */
 export function redactToJson(value) {
     try {
-        return JSON.stringify(redactForLogging(value));
+        return JSON.stringify(redactForLogging(value)) ?? 'undefined';
     }
     catch {
         return '[unserializable]';

package/dist/redact.test.js

@@ -179,6 +179,15 @@ describe('redactToJson', () => {
         // BigInt is not JSON-serializable and survives redaction (not a sensitive key).
         assert.equal(redactToJson({ big: 10n }), '[unserializable]');
     });
+    it('returns a string for undefined', () => {
+        assert.equal(redactToJson(undefined), 'undefined');
+    });
+    it('returns a string for function values', () => {
+        assert.equal(redactToJson(() => { }), 'undefined');
+    });
+    it('returns a string for symbol values', () => {
+        assert.equal(redactToJson(Symbol('x')), 'undefined');
+    });
     it('does not leak secrets even when truncation would apply downstream', () => {
         const json = redactToJson([{ action: 'signIn', username: 'u', password: 'p'.repeat(50) }]);
         assert.ok(!json.includes('pppp'));

package/dist/scripts/dev-server-rpc.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=dev-server-rpc.test.d.ts.map

package/dist/scripts/dev-server-rpc.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dev-server-rpc.test.d.ts","sourceRoot":"","sources":["../../src/scripts/dev-server-rpc.test.ts"],"names":[],"mappings":""}

package/dist/scripts/dev-server-rpc.test.js

@@ -0,0 +1,107 @@
+import { afterEach, describe, it } from 'node:test';
+import assert from 'node:assert';
+import { spawn } from 'node:child_process';
+import { createServer } from 'node:http';
+import { mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+async function getAvailablePort() {
+    const server = createServer();
+    await new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(0, '127.0.0.1', resolve);
+    });
+    const address = server.address();
+    assert.ok(address && typeof address === 'object');
+    const { port } = address;
+    // TOCTOU: brief window between closing this probe and the dev server binding
+    // the port; port: 0 would require the dev server to expose its assigned port.
+    await new Promise((resolve, reject) => server.close(error => error ? reject(error) : resolve()));
+    return port;
+}
+describe('dev-server RPC integration', () => {
+    let devProcess = null;
+    let tempDir = null;
+    afterEach(async () => {
+        if (devProcess && devProcess.exitCode === null) {
+            devProcess.kill('SIGTERM');
+            await new Promise((resolve) => {
+                const timeout = setTimeout(() => {
+                    devProcess?.kill('SIGKILL');
+                    resolve();
+                }, 2_000);
+                devProcess?.once('exit', () => {
+                    clearTimeout(timeout);
+                    resolve();
+                });
+            });
+        }
+        if (tempDir)
+            rmSync(tempDir, { recursive: true, force: true });
+    });
+    it('returns success for a void handler in verbose mode', async () => {
+        const port = await getAvailablePort();
+        tempDir = join(tmpdir(), `dev-rpc-test-${process.pid}-${Date.now()}`);
+        mkdirSync(tempDir, { recursive: true });
+        writeFileSync(join(tempDir, 'backend.ts'), `
+export const testApi = {
+  pingVoid: async () => undefined,
+};
+`);
+        // Polyfill process.loadEnvFile for Node <20.6; ENOENT means no .env file.
+        writeFileSync(join(tempDir, 'preload.mjs'), `
+if (!process.loadEnvFile) {
+  process.loadEnvFile = () => { throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' }); };
+}
+`);
+        writeFileSync(join(tempDir, 'run-dev.ts'), `
+import { startDevServer } from '${join(__dirname, 'dev-server.js').replace(/\\/g, '/')}';
+startDevServer({ backendPath: '${join(tempDir, 'backend.ts').replace(/\\/g, '/')}', port: ${port} });
+`);
+        const tsxBin = join(__dirname, '..', '..', '..', '..', 'node_modules', '.bin', 'tsx');
+        devProcess = spawn(tsxBin, ['--import', join(tempDir, 'preload.mjs'), join(tempDir, 'run-dev.ts')], {
+            cwd: tempDir,
+            env: {
+                ...process.env,
+                AWS_BLOCKS_DISABLE_TELEMETRY: '1',
+                // Empty is falsy, keeping verbose logging on even if the parent sets quiet mode.
+                BLOCKS_DEV_QUIET: '',
+            },
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        let stdout = '';
+        let stderr = '';
+        devProcess.stdout?.on('data', chunk => { stdout += chunk.toString(); });
+        devProcess.stderr?.on('data', chunk => { stderr += chunk.toString(); });
+        const deadline = Date.now() + 15_000;
+        let response;
+        let lastError;
+        while (!response && Date.now() < deadline) {
+            try {
+                response = await fetch(`http://127.0.0.1:${port}/aws-blocks/api`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ jsonrpc: '2.0', method: 'testApi.pingVoid', params: [], id: 1 }),
+                });
+            }
+            catch (error) {
+                lastError = error;
+                await new Promise(resolve => setTimeout(resolve, 100));
+            }
+        }
+        assert.ok(response, `Dev server did not respond: ${String(lastError)}\nstdout: ${stdout}\nstderr: ${stderr}`);
+        assert.strictEqual(response.status, 200);
+        const payload = await response.json();
+        assert.strictEqual(payload.jsonrpc, '2.0');
+        assert.strictEqual(payload.id, 1);
+        assert.ok(!('error' in payload), `Unexpected RPC error: ${JSON.stringify(payload.error)}`);
+        const logDeadline = Date.now() + 1_000;
+        while (!stdout.includes('[rpc-ok] testApi.pingVoid') && Date.now() < logDeadline) {
+            await new Promise(resolve => setTimeout(resolve, 25));
+        }
+        assert.ok(stdout.includes('[rpc-ok] testApi.pingVoid'), `Missing verbose success log. stdout: ${stdout}`);
+        assert.ok(!stdout.includes('[rpc-err]'), `Unexpected RPC error log. stdout: ${stdout}`);
+    });
+});

package/dist/version.d.ts

@@ -1,2 +1,2 @@
-export declare const CORE_VERSION = "0.1.12";
+export declare const CORE_VERSION = "0.1.13";
 //# 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.1.12';
+export const CORE_VERSION = '0.1.13';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aws-blocks/core",
-  "version": "0.1.12",
+  "version": "0.1.13",
   "author": "Amazon Web Services",
   "license": "Apache-2.0",
   "type": "module",

package/src/redact.test.ts

@@ -201,6 +201,18 @@ describe('redactToJson', () => {
     assert.equal(redactToJson({ big: 10n }), '[unserializable]');
   });
 
+  it('returns a string for undefined', () => {
+    assert.equal(redactToJson(undefined), 'undefined');
+  });
+
+  it('returns a string for function values', () => {
+    assert.equal(redactToJson(() => {}), 'undefined');
+  });
+
+  it('returns a string for symbol values', () => {
+    assert.equal(redactToJson(Symbol('x')), 'undefined');
+  });
+
   it('does not leak secrets even when truncation would apply downstream', () => {
     const json = redactToJson([{ action: 'signIn', username: 'u', password: 'p'.repeat(50) }]);
     assert.ok(!json.includes('pppp'));

package/src/redact.ts

@@ -131,12 +131,13 @@ export function redactForLogging(value: unknown, seen: WeakSet<object> = new Wea
 
 /**
  * Convenience for log call sites: redact `value` and serialize it to a JSON
- * string. Returns a safe placeholder instead of throwing if serialization
- * fails (e.g. a BigInt slips through), so logging can never crash a request.
+ * string. Returns `'undefined'` when JSON serialization produces no output,
+ * or a safe placeholder if serialization throws (e.g. a BigInt slips through),
+ * so logging can never crash a request.
  */
 export function redactToJson(value: unknown): string {
   try {
-    return JSON.stringify(redactForLogging(value));
+    return JSON.stringify(redactForLogging(value)) ?? 'undefined';
   } catch {
     return '[unserializable]';
   }

package/src/scripts/dev-server-rpc.test.ts

@@ -0,0 +1,115 @@
+import { afterEach, describe, it } from 'node:test';
+import assert from 'node:assert';
+import { spawn, type ChildProcess } from 'node:child_process';
+import { createServer } from 'node:http';
+import { mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+async function getAvailablePort(): Promise<number> {
+  const server = createServer();
+  await new Promise<void>((resolve, reject) => {
+    server.once('error', reject);
+    server.listen(0, '127.0.0.1', resolve);
+  });
+  const address = server.address();
+  assert.ok(address && typeof address === 'object');
+  const { port } = address;
+  // TOCTOU: brief window between closing this probe and the dev server binding
+  // the port; port: 0 would require the dev server to expose its assigned port.
+  await new Promise<void>((resolve, reject) => server.close(error => error ? reject(error) : resolve()));
+  return port;
+}
+
+describe('dev-server RPC integration', () => {
+  let devProcess: ChildProcess | null = null;
+  let tempDir: string | null = null;
+
+  afterEach(async () => {
+    if (devProcess && devProcess.exitCode === null) {
+      devProcess.kill('SIGTERM');
+      await new Promise<void>((resolve) => {
+        const timeout = setTimeout(() => {
+          devProcess?.kill('SIGKILL');
+          resolve();
+        }, 2_000);
+        devProcess?.once('exit', () => {
+          clearTimeout(timeout);
+          resolve();
+        });
+      });
+    }
+    if (tempDir) rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it('returns success for a void handler in verbose mode', async () => {
+    const port = await getAvailablePort();
+    tempDir = join(tmpdir(), `dev-rpc-test-${process.pid}-${Date.now()}`);
+    mkdirSync(tempDir, { recursive: true });
+    writeFileSync(join(tempDir, 'backend.ts'), `
+export const testApi = {
+  pingVoid: async () => undefined,
+};
+`);
+    // Polyfill process.loadEnvFile for Node <20.6; ENOENT means no .env file.
+    writeFileSync(join(tempDir, 'preload.mjs'), `
+if (!process.loadEnvFile) {
+  process.loadEnvFile = () => { throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' }); };
+}
+`);
+    writeFileSync(join(tempDir, 'run-dev.ts'), `
+import { startDevServer } from '${join(__dirname, 'dev-server.js').replace(/\\/g, '/')}';
+startDevServer({ backendPath: '${join(tempDir, 'backend.ts').replace(/\\/g, '/')}', port: ${port} });
+`);
+
+    const tsxBin = join(__dirname, '..', '..', '..', '..', 'node_modules', '.bin', 'tsx');
+    devProcess = spawn(tsxBin, ['--import', join(tempDir, 'preload.mjs'), join(tempDir, 'run-dev.ts')], {
+      cwd: tempDir,
+      env: {
+        ...process.env,
+        AWS_BLOCKS_DISABLE_TELEMETRY: '1',
+        // Empty is falsy, keeping verbose logging on even if the parent sets quiet mode.
+        BLOCKS_DEV_QUIET: '',
+      },
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+
+    let stdout = '';
+    let stderr = '';
+    devProcess.stdout?.on('data', chunk => { stdout += chunk.toString(); });
+    devProcess.stderr?.on('data', chunk => { stderr += chunk.toString(); });
+
+    const deadline = Date.now() + 15_000;
+    let response: Response | undefined;
+    let lastError: unknown;
+    while (!response && Date.now() < deadline) {
+      try {
+        response = await fetch(`http://127.0.0.1:${port}/aws-blocks/api`, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ jsonrpc: '2.0', method: 'testApi.pingVoid', params: [], id: 1 }),
+        });
+      } catch (error) {
+        lastError = error;
+        await new Promise(resolve => setTimeout(resolve, 100));
+      }
+    }
+
+    assert.ok(response, `Dev server did not respond: ${String(lastError)}\nstdout: ${stdout}\nstderr: ${stderr}`);
+    assert.strictEqual(response.status, 200);
+    const payload = await response.json() as Record<string, unknown>;
+    assert.strictEqual(payload.jsonrpc, '2.0');
+    assert.strictEqual(payload.id, 1);
+    assert.ok(!('error' in payload), `Unexpected RPC error: ${JSON.stringify(payload.error)}`);
+
+    const logDeadline = Date.now() + 1_000;
+    while (!stdout.includes('[rpc-ok] testApi.pingVoid') && Date.now() < logDeadline) {
+      await new Promise(resolve => setTimeout(resolve, 25));
+    }
+    assert.ok(stdout.includes('[rpc-ok] testApi.pingVoid'), `Missing verbose success log. stdout: ${stdout}`);
+    assert.ok(!stdout.includes('[rpc-err]'), `Unexpected RPC error log. stdout: ${stdout}`);
+  });
+});

package/src/version.ts

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