@aws-blocks/core 0.1.18 → 0.3.0

package/dist/cdk/blocks-defaults.d.ts

@@ -0,0 +1,70 @@
+import { RemovalPolicy } from 'aws-cdk-lib';
+/**
+ * Default values for every Amazon-authored Building Block created within a
+ * `BlocksStack` or `BlocksBackend`. A per-block option always overrides the
+ * corresponding default (`option ?? scope.defaults.field`).
+ *
+ * Start from {@link BlocksPresets} and override individual fields as needed.
+ */
+export interface BlocksDefaults {
+    /**
+     * What happens to a stateful resource (table, bucket, user pool) when the
+     * stack is deleted, via CDK/CloudFormation: `RETAIN` keeps the resource (and
+     * its data) behind; `DESTROY` tears it down. Applies only to CDK/CloudFormation
+     * deletions.
+     */
+    removalPolicy: RemovalPolicy;
+    /**
+     * Whether to block deletion of a stateful resource. Unlike `removalPolicy`,
+     * this guards against deletion through **any** path — CDK/CloudFormation as
+     * well as the CLI, API, and AWS console — until it is turned off.
+     */
+    deletionProtection: boolean;
+    /**
+     * CORS origins the compute's API accepts, as regular-expression patterns
+     * matched against the request `Origin` header. Empty means no cross-origin
+     * requests are allowed. The `sandbox` preset allows localhost so a local dev
+     * frontend can reach a deployed API; `production` allows none by default.
+     */
+    allowedOrigins: string[];
+    /**
+     * Whether stateful resources that support continuous backups keep them on by
+     * default — e.g. DynamoDB Point-in-Time Recovery, letting you restore to any
+     * second in the retention window. On in `production`, off in `sandbox` (where
+     * throwaway data isn't worth the backup-storage cost). Blocks whose service
+     * has no equivalent simply ignore it.
+     *
+     * `true` enables backups with the service's default window; `false` disables
+     * them; `{ retentionDays: n }` enables them and pins the window (a block
+     * clamps/validates `n` to its service's supported range — DynamoDB PITR is
+     * 1–35 days). Backups only have a window when on, so the two are one field.
+     */
+    pointInTimeRecovery: boolean | {
+        retentionDays: number;
+    };
+}
+/**
+ * Prepared starting points for {@link BlocksDefaults}. Pick one and override
+ * individual fields with a spread:
+ *
+ * ```ts
+ * defaults: { ...BlocksPresets.production, deletionProtection: false }
+ * ```
+ */
+export declare const BlocksPresets: {
+    /** Disposable development stacks: tear down cleanly, no delete guard, no backups. */
+    sandbox: {
+        removalPolicy: RemovalPolicy.DESTROY;
+        deletionProtection: false;
+        allowedOrigins: string[];
+        pointInTimeRecovery: false;
+    };
+    /** Durable, protected posture for permanent deployments. */
+    production: {
+        removalPolicy: RemovalPolicy.RETAIN;
+        deletionProtection: true;
+        allowedOrigins: never[];
+        pointInTimeRecovery: true;
+    };
+};
+//# sourceMappingURL=blocks-defaults.d.ts.map

package/dist/cdk/blocks-defaults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blocks-defaults.d.ts","sourceRoot":"","sources":["../../src/cdk/blocks-defaults.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAE5C;;;;;;GAMG;AACH,MAAM,WAAW,cAAc;IAC9B;;;;;OAKG;IACH,aAAa,EAAE,aAAa,CAAC;IAE7B;;;;OAIG;IACH,kBAAkB,EAAE,OAAO,CAAC;IAE5B;;;;;OAKG;IACH,cAAc,EAAE,MAAM,EAAE,CAAC;IAEzB;;;;;;;;;;;OAWG;IACH,mBAAmB,EAAE,OAAO,GAAG;QAAE,aAAa,EAAE,MAAM,CAAA;KAAE,CAAC;CACzD;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,aAAa;IACzB,qFAAqF;;;;;;;IAOrF,4DAA4D;;;;;;;CAOnB,CAAC"}

package/dist/cdk/blocks-defaults.js

@@ -0,0 +1,27 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { RemovalPolicy } from 'aws-cdk-lib';
+/**
+ * Prepared starting points for {@link BlocksDefaults}. Pick one and override
+ * individual fields with a spread:
+ *
+ * ```ts
+ * defaults: { ...BlocksPresets.production, deletionProtection: false }
+ * ```
+ */
+export const BlocksPresets = {
+    /** Disposable development stacks: tear down cleanly, no delete guard, no backups. */
+    sandbox: {
+        removalPolicy: RemovalPolicy.DESTROY,
+        deletionProtection: false,
+        allowedOrigins: ['^https?://(localhost|127\\.0\\.0\\.1)(:\\d+)?$'],
+        pointInTimeRecovery: false,
+    },
+    /** Durable, protected posture for permanent deployments. */
+    production: {
+        removalPolicy: RemovalPolicy.RETAIN,
+        deletionProtection: true,
+        allowedOrigins: [],
+        pointInTimeRecovery: true,
+    },
+};

package/dist/cdk/blocks-defaults.test.d.ts

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

package/dist/cdk/blocks-defaults.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blocks-defaults.test.d.ts","sourceRoot":"","sources":["../../src/cdk/blocks-defaults.test.ts"],"names":[],"mappings":""}

package/dist/cdk/blocks-defaults.test.js

@@ -0,0 +1,24 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * BlocksPresets carry the expected posture. Resolution/anchoring (a block
+ * reading its owning backend's defaults, and two backends in one stack keeping
+ * separate postures) is covered in blocks-backend.test.ts, which has the
+ * fixtures to construct real backends.
+ */
+import { test, describe } from 'node:test';
+import assert from 'node:assert';
+import { RemovalPolicy } from 'aws-cdk-lib';
+import { BlocksPresets } from './blocks-defaults.js';
+describe('BlocksPresets', () => {
+    test('sandbox is disposable: DESTROY + deletion protection off + no PITR', () => {
+        assert.strictEqual(BlocksPresets.sandbox.removalPolicy, RemovalPolicy.DESTROY);
+        assert.strictEqual(BlocksPresets.sandbox.deletionProtection, false);
+        assert.strictEqual(BlocksPresets.sandbox.pointInTimeRecovery, false);
+    });
+    test('production is durable: RETAIN + deletion protection on + PITR on', () => {
+        assert.strictEqual(BlocksPresets.production.removalPolicy, RemovalPolicy.RETAIN);
+        assert.strictEqual(BlocksPresets.production.deletionProtection, true);
+        assert.strictEqual(BlocksPresets.production.pointInTimeRecovery, true);
+    });
+});

package/dist/cdk/blocks-stack.test.js

@@ -1,12 +1,49 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
-import { test, describe, before } from 'node:test';
 import assert from 'node:assert';
-import { fileURLToPath } from 'node:url';
 import { dirname, join } from 'node:path';
+import { before, describe, test } from 'node:test';
+import { fileURLToPath } from 'node:url';
 import * as cdk from 'aws-cdk-lib';
+import * as apigateway from 'aws-cdk-lib/aws-apigateway';
+import * as lambda from 'aws-cdk-lib/aws-lambda-nodejs';
+import { BLOCKS_RPC_PREFIX } from '../constants.js';
 import { BlocksBackend } from './blocks-backend.js';
-import { BlocksStack, Scope } from './index.js';
+import { Compute } from './compute/compute.js';
+import { BlocksStack, BlocksPresets, Scope } from './index.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
+// equivalent inline stub: a Compute that owns a NodejsFunction + API Gateway,
+// so create() can build the default and the handler/gateway/apiUrl accessors
+// and synth-shape assertions have something real to resolve to. It is passed to
+// each create() via the internal `defaultComputeFactory` option (see makeStack /
+// makeBackend), exactly as @aws-blocks/blocks injects LambdaCompute.
+class StubLambdaCompute extends Compute {
+    fn;
+    apiGateway;
+    apiUrl;
+    constructor(scope, id) {
+        super(id, { parent: scope });
+        this.fn = new lambda.NodejsFunction(this, 'Handler', {
+            entry: this.backendHandlerPath,
+            runtime: cdk.aws_lambda.Runtime.NODEJS_22_X,
+            handler: 'handler',
+            role: this.executionRole,
+            environment: { BLOCKS_STACK_NAME: this.backendStackName },
+            bundling: { minify: true, esbuildArgs: { '--conditions': 'aws-runtime' } },
+        });
+        this.apiGateway = new apigateway.RestApi(this, 'API', { restApiName: 'Blocks API' });
+        this.apiGateway.root.addProxy({
+            defaultIntegration: new apigateway.LambdaIntegration(this.fn),
+            anyMethod: true,
+        });
+        this.apiUrl = `${this.apiGateway.url}${BLOCKS_RPC_PREFIX.slice(1)}`;
+    }
+    setEnv(key, value) {
+        this.fn.addEnvironment(key, value);
+    }
+}
+const stubComputeFactory = (root) => new StubLambdaCompute(root, 'DefaultCompute');
 // Simulate the CDK condition being active (tests import CDK files directly)
 before(() => {
     process.env.NODE_OPTIONS = (process.env.NODE_OPTIONS ?? '') + ' --conditions=cdk';
@@ -15,17 +52,15 @@ const __dirname = dirname(fileURLToPath(import.meta.url));
 const handlerPath = join(__dirname, '__fixtures__', 'handler.js');
 const sideEffectBackendPath = join(__dirname, '__fixtures__', 'side-effect-backend.js');
 const factoryBackendPath = join(__dirname, '__fixtures__', 'factory-backend.js');
+// Wrap create(), injecting the stub default-compute factory the way
+// @aws-blocks/blocks injects LambdaCompute — so tests don't repeat it.
+const makeStack = (scope, id, backendCDKPath) => BlocksStack.create(scope, id, { backendHandlerPath: handlerPath, backendCDKPath, defaults: BlocksPresets.production, defaultComputeFactory: stubComputeFactory });
+const makeBackend = (scope, id, backendCDKPath) => BlocksBackend.create(scope, id, { backendHandlerPath: handlerPath, backendCDKPath, defaults: BlocksPresets.production, defaultComputeFactory: stubComputeFactory });
 describe('ESM cache-busting (multi-stage)', () => {
     test('BlocksStack.create() with same backendCDKPath but different IDs produces constructs in each', async () => {
         const app = new cdk.App();
-        const stack1 = await BlocksStack.create(app, 'PipelineStage1', {
-            backendHandlerPath: handlerPath,
-            backendCDKPath: sideEffectBackendPath,
-        });
-        const stack2 = await BlocksStack.create(app, 'PipelineStage2', {
-            backendHandlerPath: handlerPath,
-            backendCDKPath: sideEffectBackendPath,
-        });
+        const stack1 = await makeStack(app, 'PipelineStage1', sideEffectBackendPath);
+        const stack2 = await makeStack(app, 'PipelineStage2', sideEffectBackendPath);
         const findMarker = (scope) => scope.node.tryFindChild('SideEffectMarker');
         assert.ok(findMarker(stack1), 'First stack should have SideEffectMarker from module side effect');
         assert.ok(findMarker(stack2), 'Second stack should have SideEffectMarker from re-executed module (cache busted)');
@@ -34,10 +69,7 @@ describe('ESM cache-busting (multi-stage)', () => {
 describe('factory function support', () => {
     test('BlocksStack.create() calls default export function with the stack instance', async () => {
         const app = new cdk.App();
-        const stack = await BlocksStack.create(app, 'FactoryBlocksStack', {
-            backendHandlerPath: handlerPath,
-            backendCDKPath: factoryBackendPath,
-        });
+        const stack = await makeStack(app, 'FactoryBlocksStack', factoryBackendPath);
         const marker = stack.node.tryFindChild('FactoryMarker');
         assert.ok(marker, 'Factory function should have created FactoryMarker on the stack');
     });
@@ -46,10 +78,7 @@ describe('legacy side-effect mode (no default export)', () => {
     test('module with only side effects still registers constructs via globalThis', async () => {
         const app = new cdk.App();
         const stack = new cdk.Stack(app, 'LegacyTestStack');
-        const backend = await BlocksBackend.create(stack, 'LegacyStage', {
-            backendHandlerPath: handlerPath,
-            backendCDKPath: sideEffectBackendPath,
-        });
+        const backend = await makeBackend(stack, 'LegacyStage', sideEffectBackendPath);
         const marker = backend.node.tryFindChild('SideEffectMarker');
         assert.ok(marker, 'Side-effect-only module should register construct via globalThis.CURRENT_BLOCKS_STACK');
     });
@@ -61,20 +90,14 @@ describe('shared execution role (BlocksStack)', () => {
     // executionRole — a separate code path from BlocksBackend's constructor.
     test('BlocksStack wires executionRole via its constructor', async () => {
         const app = new cdk.App();
-        const stack = await BlocksStack.create(app, 'StackRoleStack', {
-            backendHandlerPath: handlerPath,
-            backendCDKPath: sideEffectBackendPath,
-        });
+        const stack = await makeStack(app, 'StackRoleStack', sideEffectBackendPath);
         assert.ok(stack.executionRole, 'BlocksStack should expose a populated .executionRole');
     });
 });
 describe('executionRole globalThis fallback', () => {
     test('resolves via globalThis.CURRENT_BLOCKS_STACK when no owner is in the tree', async () => {
         const app = new cdk.App();
-        const stack = await BlocksStack.create(app, 'FallbackStack', {
-            backendHandlerPath: handlerPath,
-            backendCDKPath: sideEffectBackendPath,
-        });
+        const stack = await makeStack(app, 'FallbackStack', sideEffectBackendPath);
         // A Scope whose construct-tree ancestry has no BlocksStack/BlocksBackend
         // (parented under a plain cdk.Stack) exhausts the tree-walk and falls back
         // to globalThis.CURRENT_BLOCKS_STACK. The `as any` is test plumbing — a
@@ -85,6 +108,29 @@ describe('executionRole globalThis fallback', () => {
         assert.strictEqual(orphan.executionRole, stack.executionRole, 'fallback resolves to the ambient stack role');
     });
 });
+describe('root is bound to the owning stack (multi-stack synth)', () => {
+    test('a block under each of two stacks resolves its OWN stack, not the last globalThis', async () => {
+        // `root` is resolved once at Scope construction (not re-walked per getter),
+        // and `create()` mutates globalThis.CURRENT_BLOCKS_STACK for each stack it
+        // builds. With two stacks in one synth, a block constructed under the first
+        // must stay bound to the first even after the second stack is created and
+        // overwrites globalThis — otherwise its root-derived accessors (handler,
+        // executionRole, backendStackName) would silently point at the wrong stack.
+        const app = new cdk.App();
+        const stackA = await makeStack(app, 'RootBindingA', sideEffectBackendPath);
+        // A block explicitly parented under stackA (construct-tree walk resolves
+        // stackA regardless of the ambient globalThis).
+        const blockA = new Scope('blockA', { parent: stackA });
+        // Building the second stack overwrites globalThis.CURRENT_BLOCKS_STACK.
+        const stackB = await makeStack(app, 'RootBindingB', sideEffectBackendPath);
+        const blockB = new Scope('blockB', { parent: stackB });
+        assert.strictEqual(blockA.executionRole, stackA.executionRole, 'blockA stays bound to stackA');
+        assert.strictEqual(blockB.executionRole, stackB.executionRole, 'blockB binds to stackB');
+        assert.notStrictEqual(stackA.executionRole, stackB.executionRole, 'the two stacks have distinct roles');
+        assert.strictEqual(blockA.backendStackName, 'RootBindingA', 'blockA derives its own stack name');
+        assert.strictEqual(blockB.backendStackName, 'RootBindingB', 'blockB derives its own stack name');
+    });
+});
 describe('assertCdkConditionActive', () => {
     test('BlocksStack.create() throws when --conditions=cdk is missing', async () => {
         const origNodeOptions = process.env.NODE_OPTIONS;
@@ -93,10 +139,7 @@ describe('assertCdkConditionActive', () => {
         process.execArgv = [];
         try {
             const app = new cdk.App();
-            await assert.rejects(BlocksStack.create(app, 'MissingConditionStack', {
-                backendHandlerPath: handlerPath,
-                backendCDKPath: sideEffectBackendPath,
-            }), (err) => {
+            await assert.rejects(makeStack(app, 'MissingConditionStack', sideEffectBackendPath), (err) => {
                 assert.ok(err.message.includes('Missing --conditions=cdk'), `Expected condition error, got: ${err.message}`);
                 return true;
             });

package/dist/cdk/bundling.d.ts

@@ -0,0 +1,42 @@
+import { type BundlingOptions } from 'aws-cdk-lib/aws-lambda-nodejs';
+/**
+ * Wrap a `NodejsFunction` `bundling` config with the framework's hardened esbuild
+ * defaults, so every Lambda the framework bundles behaves consistently.
+ *
+ * **What it fixes.** `NodejsFunction` bundles to **CommonJS**, where `import.meta` is
+ * empty. Any bundled code that does `fileURLToPath(import.meta.url)` (a customer
+ * handler, a Building Block's `aws-runtime` code, or a dependency) would otherwise
+ * become `fileURLToPath(undefined)` and throw at Lambda load — esbuild only *warns*
+ * (`empty-import-meta`), so the broken bundle deploys and 502s on first invocation.
+ *
+ * **How.** For CJS output this shims `import.meta.url` / `import.meta.dirname` /
+ * `import.meta.filename` to their CommonJS equivalents (`pathToFileURL(__filename)`,
+ * `__dirname`, `__filename`) via an esbuild `--define` + `banner`. This is the same
+ * approach esbuild blesses (defining `import.meta` also suppresses the warning) and
+ * that Rollup applies by default, so:
+ * - a handler that reads `import.meta.url` no longer crashes at load, and
+ * - a bundled dependency that merely *contains* `import.meta` (even in dead code) no
+ *   longer trips a build failure.
+ *
+ * The value resolves to the **bundled output file** (esbuild flattens the module tree),
+ * which is correct for the common cases — a value computed at synth (e.g. a
+ * `migrationsPath`) or dead interop fallbacks — but note it does not point at your
+ * source layout. Runtime code that must read a file relative to itself should not rely
+ * on `import.meta.url` inside a bundle; resolve such paths at synth time or ship the
+ * file as an asset. ESM output (`OutputFormat.ESM`) supports `import.meta` natively and
+ * is left untouched.
+ *
+ * All other options (`minify`, `commandHooks`, `externalModules`, other `esbuildArgs`
+ * such as `--conditions`, and any caller `banner`) are preserved.
+ *
+ * @param options - The site-specific `NodejsFunction` bundling options (optional).
+ * @returns The same options with the CJS `import.meta` shim merged in.
+ *
+ * @example
+ * new lambda.NodejsFunction(scope, 'Handler', {
+ *   entry,
+ *   bundling: blocksNodejsBundling({ minify: true, esbuildArgs: { '--conditions': 'aws-runtime' } }),
+ * });
+ */
+export declare function blocksNodejsBundling(options?: BundlingOptions): BundlingOptions;
+//# sourceMappingURL=bundling.d.ts.map

package/dist/cdk/bundling.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundling.d.ts","sourceRoot":"","sources":["../../src/cdk/bundling.ts"],"names":[],"mappings":"AAGA,OAAO,EAAgB,KAAK,eAAe,EAAE,MAAM,+BAA+B,CAAC;AASnF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,GAAE,eAAoB,GAAG,eAAe,CAwBnF"}

package/dist/cdk/bundling.js

@@ -0,0 +1,72 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { OutputFormat } from 'aws-cdk-lib/aws-lambda-nodejs';
+/** Banner-defined identifiers the shim substitutes `import.meta.*` with (CJS only). */
+const IMPORT_META_SHIM = {
+    url: '__blocksImportMetaUrl',
+    dirname: '__blocksImportMetaDirname',
+    filename: '__blocksImportMetaFilename',
+};
+/**
+ * Wrap a `NodejsFunction` `bundling` config with the framework's hardened esbuild
+ * defaults, so every Lambda the framework bundles behaves consistently.
+ *
+ * **What it fixes.** `NodejsFunction` bundles to **CommonJS**, where `import.meta` is
+ * empty. Any bundled code that does `fileURLToPath(import.meta.url)` (a customer
+ * handler, a Building Block's `aws-runtime` code, or a dependency) would otherwise
+ * become `fileURLToPath(undefined)` and throw at Lambda load — esbuild only *warns*
+ * (`empty-import-meta`), so the broken bundle deploys and 502s on first invocation.
+ *
+ * **How.** For CJS output this shims `import.meta.url` / `import.meta.dirname` /
+ * `import.meta.filename` to their CommonJS equivalents (`pathToFileURL(__filename)`,
+ * `__dirname`, `__filename`) via an esbuild `--define` + `banner`. This is the same
+ * approach esbuild blesses (defining `import.meta` also suppresses the warning) and
+ * that Rollup applies by default, so:
+ * - a handler that reads `import.meta.url` no longer crashes at load, and
+ * - a bundled dependency that merely *contains* `import.meta` (even in dead code) no
+ *   longer trips a build failure.
+ *
+ * The value resolves to the **bundled output file** (esbuild flattens the module tree),
+ * which is correct for the common cases — a value computed at synth (e.g. a
+ * `migrationsPath`) or dead interop fallbacks — but note it does not point at your
+ * source layout. Runtime code that must read a file relative to itself should not rely
+ * on `import.meta.url` inside a bundle; resolve such paths at synth time or ship the
+ * file as an asset. ESM output (`OutputFormat.ESM`) supports `import.meta` natively and
+ * is left untouched.
+ *
+ * All other options (`minify`, `commandHooks`, `externalModules`, other `esbuildArgs`
+ * such as `--conditions`, and any caller `banner`) are preserved.
+ *
+ * @param options - The site-specific `NodejsFunction` bundling options (optional).
+ * @returns The same options with the CJS `import.meta` shim merged in.
+ *
+ * @example
+ * new lambda.NodejsFunction(scope, 'Handler', {
+ *   entry,
+ *   bundling: blocksNodejsBundling({ minify: true, esbuildArgs: { '--conditions': 'aws-runtime' } }),
+ * });
+ */
+export function blocksNodejsBundling(options = {}) {
+    // ESM output has real `import.meta` — nothing to shim, and `require` in the banner
+    // wouldn't resolve. Only the CommonJS bundle needs the shim.
+    if (options.format === OutputFormat.ESM)
+        return options;
+    const shimBanner = [
+        `const ${IMPORT_META_SHIM.url}=require('url').pathToFileURL(__filename).href;`,
+        `const ${IMPORT_META_SHIM.dirname}=__dirname;`,
+        `const ${IMPORT_META_SHIM.filename}=__filename;`,
+    ].join('');
+    return {
+        ...options,
+        // Prepend the shim definitions; keep any caller-supplied banner after them.
+        banner: options.banner ? `${shimBanner}\n${options.banner}` : shimBanner,
+        esbuildArgs: {
+            ...options.esbuildArgs,
+            // Substitute import.meta.* with the banner identifiers. Also suppresses esbuild's
+            // empty-import-meta warning, so import.meta anywhere in the graph is safe.
+            '--define:import.meta.url': IMPORT_META_SHIM.url,
+            '--define:import.meta.dirname': IMPORT_META_SHIM.dirname,
+            '--define:import.meta.filename': IMPORT_META_SHIM.filename,
+        },
+    };
+}

package/dist/cdk/bundling.test.d.ts

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

package/dist/cdk/bundling.test.d.ts.map

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

package/dist/cdk/bundling.test.js

@@ -0,0 +1,80 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { test, describe } from 'node:test';
+import assert from 'node:assert';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { createRequire } from 'node:module';
+import { build } from 'esbuild';
+import { OutputFormat } from 'aws-cdk-lib/aws-lambda-nodejs';
+import { blocksNodejsBundling } from './bundling.js';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const importMetaFixture = join(__dirname, '__fixtures__', 'import-meta-handler.js');
+const requireCjs = createRequire(import.meta.url);
+describe('blocksNodejsBundling', () => {
+    test('injects the import.meta.* CJS shim for the default (CJS) output', () => {
+        const out = blocksNodejsBundling({ minify: true, esbuildArgs: { '--conditions': 'aws-runtime' } });
+        // Caller options are preserved.
+        assert.equal(out.minify, true);
+        assert.equal(out.esbuildArgs?.['--conditions'], 'aws-runtime');
+        // All three import.meta path properties are substituted.
+        assert.ok(out.esbuildArgs?.['--define:import.meta.url']);
+        assert.ok(out.esbuildArgs?.['--define:import.meta.dirname']);
+        assert.ok(out.esbuildArgs?.['--define:import.meta.filename']);
+        // The banner defines the substituted identifiers via CommonJS primitives.
+        assert.match(out.banner ?? '', /pathToFileURL\(__filename\)/);
+        assert.match(out.banner ?? '', /__dirname/);
+        assert.match(out.banner ?? '', /__filename/);
+    });
+    test('leaves ESM output untouched (import.meta works natively there)', () => {
+        const input = { format: OutputFormat.ESM, esbuildArgs: { '--conditions': 'aws-runtime' } };
+        const out = blocksNodejsBundling(input);
+        assert.deepEqual(out, input);
+        assert.equal(out.esbuildArgs?.['--define:import.meta.url'], undefined);
+        assert.equal(out.banner, undefined);
+    });
+    test('prepends the shim while keeping a caller-supplied banner', () => {
+        const out = blocksNodejsBundling({ banner: '// caller banner' });
+        assert.match(out.banner ?? '', /pathToFileURL\(__filename\)/);
+        assert.ok((out.banner ?? '').includes('// caller banner'));
+    });
+    test('a CJS bundle built with the shim resolves import.meta.url at load (no crash)', async () => {
+        // Bundle the fixture exactly as NodejsFunction would: apply the helper's `banner`
+        // and its `--define:import.meta.*` esbuildArgs. Without the shim this fixture's
+        // top-level `fileURLToPath(import.meta.url)` becomes `fileURLToPath(undefined)`
+        // and throws when the module is loaded.
+        const opts = blocksNodejsBundling({ minify: true });
+        const define = {};
+        for (const [key, value] of Object.entries(opts.esbuildArgs ?? {})) {
+            const m = key.match(/^--define:(.+)$/);
+            if (m)
+                define[m[1]] = String(value);
+        }
+        const tmp = mkdtempSync(join(tmpdir(), 'bb-shim-'));
+        const outfile = join(tmp, 'out.cjs');
+        try {
+            await build({
+                entryPoints: [importMetaFixture],
+                bundle: true,
+                platform: 'node',
+                format: 'cjs',
+                minify: true,
+                banner: { js: opts.banner ?? '' },
+                define,
+                outfile,
+                logLevel: 'silent',
+            });
+            // Loading the bundle must not throw, and import.meta.url must resolve to a real
+            // (file-URL-derived) path rather than being undefined.
+            const mod = requireCjs(outfile);
+            assert.equal(typeof mod.moduleDir, 'string');
+            assert.ok(mod.moduleDir.length > 0, 'moduleDir should resolve to a non-empty path');
+            assert.equal(typeof mod.handler, 'function');
+        }
+        finally {
+            rmSync(tmp, { recursive: true, force: true });
+        }
+    });
+});

package/dist/cdk/compute/compute.d.ts

@@ -0,0 +1,33 @@
+import { Scope } from '../index.js';
+/**
+ * Base class for a Blocks *compute* — a runtime that executes handler code
+ * (Lambda today; containers later). A compute owns the physical function/service
+ * plus its ingress, and receives config via {@link setEnv}.
+ *
+ * The backend entry and stack name a compute needs are inherited from
+ * {@link Scope} (`backendHandlerPath` / `backendStackName`), which resolve them
+ * from the owning BlocksStack/BlocksBackend — never caller-supplied, so every
+ * compute in an app runs the same backend and agrees on the resource-name
+ * namespace.
+ *
+ * The abstract base lives in core (a framework primitive); concrete computes
+ * live in their own packages (e.g. `LambdaCompute` in `@aws-blocks/bb-lambda-compute`).
+ *
+ * @internal Not exported from the package's public entry points. Customers
+ * cannot instantiate a compute until the customer-facing surface exists.
+ */
+export declare abstract class Compute extends Scope {
+    /**
+     * API namespaces assigned to run on this compute — recorded so request
+     * routing can map a namespace to the compute that hosts it. Currently
+     * unpopulated (no compute assignment surface yet).
+     */
+    readonly namespaces: string[];
+    /**
+     * Inject a runtime configuration value (an environment variable) into this
+     * compute. The framework calls this instead of `handler.addEnvironment()`
+     * directly so config targets the right compute.
+     */
+    abstract setEnv(key: string, value: string): void;
+}
+//# sourceMappingURL=compute.d.ts.map

package/dist/cdk/compute/compute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compute.d.ts","sourceRoot":"","sources":["../../../src/cdk/compute/compute.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAEpC;;;;;;;;;;;;;;;;GAgBG;AACH,8BAAsB,OAAQ,SAAQ,KAAK;IAC1C;;;;OAIG;IACH,QAAQ,CAAC,UAAU,EAAE,MAAM,EAAE,CAAM;IAEnC;;;;OAIG;IACH,QAAQ,CAAC,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;CACjD"}

package/dist/cdk/compute/compute.js

@@ -0,0 +1,28 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { Scope } from '../index.js';
+/**
+ * Base class for a Blocks *compute* — a runtime that executes handler code
+ * (Lambda today; containers later). A compute owns the physical function/service
+ * plus its ingress, and receives config via {@link setEnv}.
+ *
+ * The backend entry and stack name a compute needs are inherited from
+ * {@link Scope} (`backendHandlerPath` / `backendStackName`), which resolve them
+ * from the owning BlocksStack/BlocksBackend — never caller-supplied, so every
+ * compute in an app runs the same backend and agrees on the resource-name
+ * namespace.
+ *
+ * The abstract base lives in core (a framework primitive); concrete computes
+ * live in their own packages (e.g. `LambdaCompute` in `@aws-blocks/bb-lambda-compute`).
+ *
+ * @internal Not exported from the package's public entry points. Customers
+ * cannot instantiate a compute until the customer-facing surface exists.
+ */
+export class Compute extends Scope {
+    /**
+     * API namespaces assigned to run on this compute — recorded so request
+     * routing can map a namespace to the compute that hosts it. Currently
+     * unpopulated (no compute assignment surface yet).
+     */
+    namespaces = [];
+}

package/dist/cdk/compute/default-compute-factory.d.ts

@@ -0,0 +1,33 @@
+import type * as cdk from 'aws-cdk-lib';
+import type { Compute } from './compute.js';
+import type { BlocksStack } from '../index.js';
+import type { BlocksBackend } from '../blocks-backend.js';
+/**
+ * Lambda-shaped surface of the default compute that the legacy
+ * `handler` / `gateway` / `apiUrl` accessors on BlocksStack/BlocksBackend read.
+ * The default compute (`LambdaCompute` from `@aws-blocks/bb-lambda-compute`)
+ * satisfies this structurally, so core exposes those accessors without
+ * importing the concrete class. To be removed with those accessors once
+ * consumers move to the multi-compute model.
+ *
+ * @internal
+ */
+export interface LambdaShapedCompute extends Compute {
+    readonly fn: cdk.aws_lambda_nodejs.NodejsFunction;
+    readonly apiGateway: cdk.aws_apigateway.RestApi;
+    readonly apiUrl: string;
+}
+/**
+ * Builds the default {@link Compute} for a stack/backend. `create()` reads it
+ * from its props (`CoreBlocksStackProps.defaultComputeFactory`) and calls it to
+ * build the default without importing a concrete compute class — the factory is
+ * supplied by whoever owns both core and a concrete compute package (the
+ * umbrella `@aws-blocks/blocks`, which injects `LambdaCompute`). It lives on
+ * `CoreBlocksStackProps`/`CoreBlocksBackendProps`, which the umbrella derives
+ * from the customer-facing props, so it is absent from `BlocksStackProps` and
+ * customers cannot set it.
+ *
+ * @internal
+ */
+export type DefaultComputeFactory = (root: BlocksStack | BlocksBackend) => Compute;
+//# sourceMappingURL=default-compute-factory.d.ts.map

package/dist/cdk/compute/default-compute-factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-compute-factory.d.ts","sourceRoot":"","sources":["../../../src/cdk/compute/default-compute-factory.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,KAAK,GAAG,MAAM,aAAa,CAAC;AACxC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAE1D;;;;;;;;;GASG;AACH,MAAM,WAAW,mBAAoB,SAAQ,OAAO;IACnD,QAAQ,CAAC,EAAE,EAAE,GAAG,CAAC,iBAAiB,CAAC,cAAc,CAAC;IAClD,QAAQ,CAAC,UAAU,EAAE,GAAG,CAAC,cAAc,CAAC,OAAO,CAAC;IAChD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,qBAAqB,GAAG,CAAC,IAAI,EAAE,WAAW,GAAG,aAAa,KAAK,OAAO,CAAC"}

package/dist/cdk/compute/default-compute-factory.js

@@ -0,0 +1,3 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+export {};