@aws-blocks/bb-distributed-data 0.1.3 → 0.1.6

package/DESIGN.md

@@ -75,6 +75,7 @@ The core insight: PGlite supports everything DSQL doesn't. Without validation, c
 | `SET TRANSACTION ISOLATION LEVEL` | Fixed Repeatable Read |
 | `COLLATE` | C collation only |
 | `CREATE INDEX ... ASC/DESC` | Sort direction on index keys (NULLS FIRST/LAST is allowed) |
+| `ALTER TABLE ... DROP [COLUMN]` | Not in DSQL's supported ALTER TABLE subset (`DROP CONSTRAINT` and `ALTER COLUMN ... DROP DEFAULT/NOT NULL/EXPRESSION/IDENTITY` are supported) |
 
 ### Transaction Tracking
 

package/README.md

@@ -90,6 +90,10 @@ CREATE INDEX ASYNC idx_users_email ON users(email);
 
 Migrations are validated at dev time — unsupported features (FK, SERIAL, TRUNCATE, etc.) are caught before deploy.
 
+> **Set `migrationsPath` to a path relative to your project root** (e.g. `'./aws-blocks/dsql-migrations'`); it's resolved at synth from the directory you run `cdk` / `npm run deploy` in. That's the simplest reliable pattern.
+>
+> You don't need `fileURLToPath(import.meta.url)` for this. Your backend module runs as ESM locally but is bundled to **CommonJS** in Lambda, where `import.meta` is empty. AWS Blocks shims `import.meta.url` / `import.meta.dirname` in the bundle so it won't crash at load — but at runtime those resolve to the **bundled output** location, not your source tree. So don't use `import.meta.url` to read a file relative to your source at request time; inline the data or ship it as a Lambda asset instead.
+
 ## DSQL Limitations
 
 DSQL is a subset of PostgreSQL. The local mock enforces these restrictions so code that works locally also works in production.
@@ -109,6 +113,7 @@ DSQL is a subset of PostgreSQL. The local mock enforces these restrictions so co
 | Extensions | Not available |
 | ADD COLUMN with DEFAULT | Add column without default, handle nulls in app |
 | Index key sort direction (`ASC`/`DESC`) | Omit it; enforce ordering with `ORDER BY` in queries (`NULLS FIRST/LAST` is supported) |
+| `ALTER TABLE DROP [COLUMN]` | Leave the column in place and stop referencing it; or rebuild the table (create new → `INSERT INTO ... SELECT` → `DROP` → `RENAME TO`, one migration file per step) |
 
 ### Transaction Constraints
 

package/dist/e2e-mock.test.js

@@ -157,6 +157,10 @@ describe('DsqlMockEngine — CREATE INDEX ASYNC parity', () => {
     it('rejects CREATE INDEX ASYNC with a DESC sort order on a key', async () => {
         await assert.rejects(() => engine.withDdl(() => db.execute(sql `CREATE INDEX ASYNC idx_users_email_desc ON users (email DESC)`)), /sort order/i);
     });
+    it('rejects ALTER TABLE DROP COLUMN', async () => {
+        await engine.withDdl(() => db.execute(sql `CREATE TABLE legacy (id TEXT PRIMARY KEY, obsolete TEXT)`));
+        await assert.rejects(() => engine.withDdl(() => db.execute(sql `ALTER TABLE legacy DROP COLUMN obsolete`)), /DROP COLUMN/i);
+    });
     it('does not strip ASYNC outside of CREATE INDEX (column named "async")', async () => {
         await engine.withDdl(() => db.execute(sql `CREATE TABLE jobs (id TEXT PRIMARY KEY, async BOOLEAN)`));
         await db.execute(sql `INSERT INTO jobs (id, async) VALUES (${'j1'}, ${true})`);

package/dist/engines/dsql-mock-engine.d.ts

@@ -1,10 +1,31 @@
-import type { DatabaseEngine, TransactionHandle } from '@aws-blocks/data-common';
+/**
+ * PGlite engine wrapped with DSQL validation layer for local development.
+ */
+import { PGlite } from '@electric-sql/pglite';
+import { type DatabaseEngine, type TransactionHandle } from '@aws-blocks/data-common';
 export declare class DsqlMockEngine implements DatabaseEngine {
     private db;
     private closed;
     private shouldConflict;
     private _allowDdl;
-    constructor(dataDir: string);
+    private readonly dataDir;
+    private readonly createClient;
+    private ready?;
+    /**
+     * @param dataDir - directory the PGlite mock persists to.
+     * @param createClient - factory for the underlying PGlite instance; defaults
+     *   to a real `PGlite`. Exposed as a seam so tests can inject an instance
+     *   that simulates a WASM init trap.
+     */
+    constructor(dataDir: string, createClient?: (dataDir: string) => PGlite);
+    private createDb;
+    /**
+     * Force PGlite's lazy WASM initialization, retrying past intermittent
+     * `_pg_initdb` `unreachable` traps by recreating the instance. Runs once per
+     * engine; a permanent failure is not cached, so a later query can retry once
+     * transient memory pressure eases.
+     */
+    private ensureReady;
     /** Test helper: simulate OCC conflict on next commit. */
     simulateConflict(): void;
     /**

package/dist/engines/dsql-mock-engine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dsql-mock-engine.d.ts","sourceRoot":"","sources":["../../src/engines/dsql-mock-engine.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAoCjF,qBAAa,cAAe,YAAW,cAAc;IACnD,OAAO,CAAC,EAAE,CAAS;IACnB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,cAAc,CAAS;IAC/B,OAAO,CAAC,SAAS,CAAS;gBAEd,OAAO,EAAE,MAAM;IAM3B,yDAAyD;IACzD,gBAAgB,IAAI,IAAI;IAExB;;;OAGG;IACG,OAAO,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAK5C,KAAK,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC;IAMvD,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC;IAMvE,gBAAgB,IAAI,OAAO,CAAC,iBAAiB,CAAC;IAK9C,iBAAiB,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC;IAc3D,mBAAmB,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC;IAK7D,kBAAkB,CAAC,CAAC,EAAE,MAAM,EAAE,iBAAiB,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC;IAO/F,oBAAoB,CAAC,MAAM,EAAE,iBAAiB,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC;IAW/G,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAK/B"}
+{"version":3,"file":"dsql-mock-engine.d.ts","sourceRoot":"","sources":["../../src/engines/dsql-mock-engine.ts"],"names":[],"mappings":"AAGA;;GAEG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAG9C,OAAO,EAA6B,KAAK,cAAc,EAAE,KAAK,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAoCjH,qBAAa,cAAe,YAAW,cAAc;IACnD,OAAO,CAAC,EAAE,CAAS;IACnB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,cAAc,CAAS;IAC/B,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAA8B;IAC3D,OAAO,CAAC,KAAK,CAAC,CAAkB;IAEhC;;;;;OAKG;gBACS,OAAO,EAAE,MAAM,EAAE,YAAY,GAAE,CAAC,OAAO,EAAE,MAAM,KAAK,MAAiC;IAMjG,OAAO,CAAC,QAAQ;IAMhB;;;;;OAKG;IACH,OAAO,CAAC,WAAW;IA6BnB,yDAAyD;IACzD,gBAAgB,IAAI,IAAI;IAExB;;;OAGG;IACG,OAAO,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAK5C,KAAK,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC;IAMvD,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC;IAMvE,gBAAgB,IAAI,OAAO,CAAC,iBAAiB,CAAC;IAQ9C,iBAAiB,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC;IAc3D,mBAAmB,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC;IAK7D,kBAAkB,CAAC,CAAC,EAAE,MAAM,EAAE,iBAAiB,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC;IAO/F,oBAAoB,CAAC,MAAM,EAAE,iBAAiB,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC;IAW/G,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAK/B"}

package/dist/engines/dsql-mock-engine.js

@@ -6,6 +6,7 @@
 import { PGlite } from '@electric-sql/pglite';
 import { existsSync, unlinkSync, mkdirSync } from 'node:fs';
 import { join } from 'node:path';
+import { initializePgliteWithRetry } from '@aws-blocks/data-common';
 import { DistributedDatabaseErrors, PG_SERIALIZATION_FAILURE, translateDsqlError } from '../errors.js';
 import { validateStatement, classifyStatement, TransactionTracker } from '../validation.js';
 function cleanStaleLock(dataDir) {
@@ -44,10 +45,58 @@ export class DsqlMockEngine {
     closed = false;
     shouldConflict = false;
     _allowDdl = false;
-    constructor(dataDir) {
-        cleanStaleLock(dataDir);
-        mkdirSync(dataDir, { recursive: true });
-        this.db = new PGlite(dataDir);
+    dataDir;
+    createClient;
+    ready;
+    /**
+     * @param dataDir - directory the PGlite mock persists to.
+     * @param createClient - factory for the underlying PGlite instance; defaults
+     *   to a real `PGlite`. Exposed as a seam so tests can inject an instance
+     *   that simulates a WASM init trap.
+     */
+    constructor(dataDir, createClient = (dir) => new PGlite(dir)) {
+        this.dataDir = dataDir;
+        this.createClient = createClient;
+        this.db = this.createDb();
+    }
+    createDb() {
+        cleanStaleLock(this.dataDir);
+        mkdirSync(this.dataDir, { recursive: true });
+        return this.createClient(this.dataDir);
+    }
+    /**
+     * Force PGlite's lazy WASM initialization, retrying past intermittent
+     * `_pg_initdb` `unreachable` traps by recreating the instance. Runs once per
+     * engine; a permanent failure is not cached, so a later query can retry once
+     * transient memory pressure eases.
+     */
+    ensureReady() {
+        if (!this.ready) {
+            this.ready = initializePgliteWithRetry(this.db, () => (this.db = this.createDb()), {
+                onRetry: (attempt, error) => console.warn(`[DsqlMockEngine] PGlite init trap on attempt ${attempt}; recreating instance`, error),
+            })
+                // Pin this.db to the settled instance explicitly (not just via the recreate closure).
+                .then((db) => (this.db = db))
+                .catch((error) => {
+                // Init retry is exhausted; initializePgliteWithRetry has already closed
+                // the last trapped instance, so this.db now points at a dead handle.
+                // Reset readiness AND swap in a fresh, un-probed instance. Without the
+                // swap, the next call would re-probe the CLOSED handle, whose error is a
+                // "closed" error (not an `unreachable` trap) and is therefore classified
+                // non-retryable — permanently wedging the engine and defeating the
+                // "a later query can retry" recovery documented above. Recreating here
+                // is best effort; if it throws we keep propagating the original init error.
+                this.ready = undefined;
+                try {
+                    this.db = this.createDb();
+                }
+                catch {
+                    // Leave the dead handle in place; the original init error is more useful.
+                }
+                throw error;
+            });
+        }
+        return this.ready;
     }
     /** Test helper: simulate OCC conflict on next commit. */
     simulateConflict() { this.shouldConflict = true; }
@@ -67,6 +116,7 @@ export class DsqlMockEngine {
     async query(sql, params) {
         const normalized = preprocessSqlForDsqlMock(sql, { allowDdl: this._allowDdl });
         try {
+            await this.ensureReady();
             return (await this.db.query(normalized, params)).rows;
         }
         catch (e) {
@@ -76,6 +126,7 @@ export class DsqlMockEngine {
     async execute(sql, params) {
         const normalized = preprocessSqlForDsqlMock(sql, { allowDdl: this._allowDdl });
         try {
+            await this.ensureReady();
             return { rowCount: (await this.db.query(normalized, params)).affectedRows ?? 0 };
         }
         catch (e) {
@@ -83,8 +134,14 @@ export class DsqlMockEngine {
         }
     }
     async beginTransaction() {
-        await this.db.query('BEGIN');
-        return { active: true, tracker: new TransactionTracker() };
+        try {
+            await this.ensureReady();
+            await this.db.query('BEGIN');
+            return { active: true, tracker: new TransactionTracker() };
+        }
+        catch (e) {
+            translateDsqlError(e);
+        }
     }
     async commitTransaction(handle) {
         if (this.shouldConflict) {

package/dist/engines/dsql-mock-engine.test.d.ts

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

package/dist/engines/dsql-mock-engine.test.d.ts.map

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

package/dist/engines/dsql-mock-engine.test.js

@@ -0,0 +1,112 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { test, afterEach } from 'node:test';
+import assert from 'node:assert';
+import { PGlite } from '@electric-sql/pglite';
+import { rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { DsqlMockEngine } from './dsql-mock-engine.js';
+import { DistributedDatabaseErrors } from '../errors.js';
+const TEST_DIR = '.bb-data-dsql-mock-test-' + process.pid;
+let engine;
+afterEach(async () => {
+    if (engine)
+        await engine.destroy().catch(() => { });
+    rmSync(TEST_DIR, { recursive: true, force: true });
+});
+// --- Regression #188: PGlite WASM `_pg_initdb` `unreachable` init trap ---
+// The DSQL mock wraps PGlite; the same lazy-init WASM trap kills the dev server
+// during runMigrations. A factory injects a first instance that traps on the
+// init probe; recovery falls through to a REAL PGlite so data round-trips.
+test('recovers when the first PGlite instance traps during init', async () => {
+    const dir = join(TEST_DIR, 'init-trap-recover');
+    let creates = 0;
+    const factory = (d) => {
+        creates++;
+        if (creates === 1) {
+            return {
+                query: async () => {
+                    throw new Error('Aborted(). Build with -sASSERTIONS for more info. RuntimeError: unreachable');
+                },
+                close: async () => { },
+            };
+        }
+        return new PGlite(d);
+    };
+    engine = new DsqlMockEngine(dir, factory);
+    await engine.withDdl(() => engine.execute('CREATE TABLE t (id TEXT PRIMARY KEY)'));
+    await engine.execute("INSERT INTO t (id) VALUES ('ok')");
+    const rows = await engine.query('SELECT id FROM t');
+    assert.deepStrictEqual(rows, [{ id: 'ok' }]);
+    assert.strictEqual(creates, 2, 'engine should recreate the trapped instance exactly once');
+});
+test('surfaces a QueryFailed error when init keeps trapping', async () => {
+    const dir = join(TEST_DIR, 'init-trap-persistent');
+    const factory = () => ({
+        query: async () => {
+            throw new Error('RuntimeError: unreachable');
+        },
+        close: async () => { },
+    });
+    engine = new DsqlMockEngine(dir, factory);
+    await assert.rejects(() => engine.execute("INSERT INTO t (id) VALUES ('x')"), (err) => {
+        assert.strictEqual(err.name, DistributedDatabaseErrors.QueryFailed);
+        return true;
+    });
+});
+// beginTransaction() forces the same lazy WASM init as query()/execute(); an
+// exhausted init-retry at transaction start must also normalize to QueryFailed
+// rather than leaking a raw `RuntimeError: unreachable`.
+test('surfaces a QueryFailed error when init keeps trapping during beginTransaction', async () => {
+    const dir = join(TEST_DIR, 'init-trap-begin-transaction');
+    const factory = () => ({
+        query: async () => {
+            throw new Error('RuntimeError: unreachable');
+        },
+        close: async () => { },
+    });
+    engine = new DsqlMockEngine(dir, factory);
+    await assert.rejects(() => engine.beginTransaction(), (err) => {
+        assert.strictEqual(err.name, DistributedDatabaseErrors.QueryFailed);
+        return true;
+    });
+});
+// --- Regression #188 (recovery): a later call must succeed after the init
+// retry budget is fully exhausted, once the factory stops trapping. The
+// exhausted attempt closes the last instance; keeping that dead handle would
+// make the next call re-probe a CLOSED instance whose error is a "closed"
+// error (NOT `unreachable`) and thus non-retryable, wedging the engine
+// permanently. Trapped instances model a real PGlite: `unreachable` while
+// open, a "closed" error after close().
+test('recovers on a later call after the init-retry budget is exhausted', async () => {
+    const dir = join(TEST_DIR, 'init-trap-exhaust-recover');
+    let creates = 0;
+    const factory = (d) => {
+        creates++;
+        if (creates <= 3) {
+            let closed = false;
+            return {
+                query: async () => {
+                    throw new Error(closed ? 'PGlite is closed' : 'Aborted(). RuntimeError: unreachable');
+                },
+                close: async () => {
+                    closed = true;
+                },
+            };
+        }
+        return new PGlite(d);
+    };
+    engine = new DsqlMockEngine(dir, factory);
+    // First call exhausts the 3-attempt retry budget and rejects.
+    await assert.rejects(() => engine.withDdl(() => engine.execute('CREATE TABLE t (id TEXT PRIMARY KEY)')), (err) => {
+        assert.strictEqual(err.name, DistributedDatabaseErrors.QueryFailed);
+        return true;
+    });
+    // Once the factory stops trapping, a later call must recover on a fresh
+    // instance instead of re-probing the closed handle forever.
+    await engine.withDdl(() => engine.execute('CREATE TABLE t (id TEXT PRIMARY KEY)'));
+    await engine.execute("INSERT INTO t (id) VALUES ('ok')");
+    const rows = await engine.query('SELECT id FROM t');
+    assert.deepStrictEqual(rows, [{ id: 'ok' }]);
+    assert.ok(creates >= 4, 'engine should build a fresh instance after exhaustion');
+});

package/dist/index.aws.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.aws.d.ts","sourceRoot":"","sources":["../src/index.aws.ts"],"names":[],"mappings":"AAGA;;;GAGG;AAEH,OAAO,EAAE,KAAK,EAA0B,MAAM,kBAAkB,CAAC;AACjE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,EAAgB,KAAK,QAAQ,EAAE,KAAK,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAIxF,OAAO,KAAK,EAAE,0BAA0B,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAGjF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEzD,qBAAa,mBAAoB,SAAQ,KAAK;IAC5C,OAAO,CAAC,KAAK,CAA6B;IAE1C,2FAA2F;IAC3F,SAAS,CAAC,GAAG,EAAE,WAAW,CAAC;gBAEf,KAAK,EAAE,WAAW,EAAE,EAAE,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,0BAA0B;IAQjF,OAAO,KAAK,IAAI,GAiBf;IAED,KAAK,CAAC,CAAC,EAAE,KAAK,EAAE,QAAQ,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC;IACvC,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,QAAQ,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;IAC/C,OAAO,CAAC,KAAK,EAAE,QAAQ,GAAG,OAAO,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC;IAEvD;;;;;OAKG;IACG,WAAW,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE,kBAAkB,GAAG,OAAO,CAAC,CAAC,CAAC;IAInG,gBAAgB;IAChB,SAAS;CACV;AAED,OAAO,EAAE,GAAG,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACnE,YAAY,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AACrE,OAAO,EAAE,yBAAyB,EAAE,MAAM,aAAa,CAAC;AACxD,YAAY,EAAE,0BAA0B,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.aws.d.ts","sourceRoot":"","sources":["../src/index.aws.ts"],"names":[],"mappings":"AAGA;;;GAGG;AAEH,OAAO,EAAE,KAAK,EAA0B,MAAM,kBAAkB,CAAC;AACjE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,EAAgB,KAAK,QAAQ,EAAE,KAAK,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAIxF,OAAO,KAAK,EAAE,0BAA0B,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAGjF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAGzD,qBAAa,mBAAoB,SAAQ,KAAK;IAC5C,OAAO,CAAC,KAAK,CAA6B;IAE1C,2FAA2F;IAC3F,SAAS,CAAC,GAAG,EAAE,WAAW,CAAC;gBAEf,KAAK,EAAE,WAAW,EAAE,EAAE,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,0BAA0B;IAQjF,OAAO,KAAK,IAAI,GAiBf;IAED,KAAK,CAAC,CAAC,EAAE,KAAK,EAAE,QAAQ,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC;IACvC,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,QAAQ,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;IAC/C,OAAO,CAAC,KAAK,EAAE,QAAQ,GAAG,OAAO,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC;IAEvD;;;;;OAKG;IACG,WAAW,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE,kBAAkB,GAAG,OAAO,CAAC,CAAC,CAAC;IAInG,gBAAgB;IAChB,SAAS;CACV;AAED,OAAO,EAAE,GAAG,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACnE,YAAY,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AACrE,OAAO,EAAE,yBAAyB,EAAE,MAAM,aAAa,CAAC;AACxD,YAAY,EAAE,0BAA0B,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC"}

package/dist/index.aws.js

@@ -11,12 +11,13 @@ import { DsqlEngine } from './engines/dsql-engine.js';
 import { transactionWithRetry } from './transaction.js';
 import { ENV_SANITIZE, sanitizeDbRoleName } from './constants.js';
 import { Logger } from '@aws-blocks/bb-logger';
+import { BB_NAME, BB_VERSION } from './version.js';
 export class DistributedDatabase extends Scope {
     _base = null;
     /** @internal Logger for internal operations. Defaults to error-level when not provided. */
     log;
     constructor(scope, id, _options) {
-        super(id, { parent: scope });
+        super(id, { parent: scope, bbName: BB_NAME, bbVersion: BB_VERSION });
         this.log = _options?.logger ?? new Logger(this, 'logger', { level: 'error' });
         const envName = this.fullId.replace(ENV_SANITIZE, '_');
         const clusterEndpoint = process.env[`BLOCKS_${envName}_ENDPOINT`] ?? '';

package/dist/index.cdk.d.ts

@@ -8,6 +8,13 @@ import type { ScopeParent } from '@aws-blocks/core';
 import type { DistributedDatabaseOptions } from './types.js';
 export declare class DistributedDatabase extends Scope {
     constructor(scope: ScopeParent, id: string, options?: DistributedDatabaseOptions);
+    /**
+     * Runtime-only. This is the CDK (synth) build: it defines infrastructure and
+     * has no engine — queries run in the app Lambda against the deployed cluster.
+     * `createKyselyAdapter()` no longer calls this eagerly, so reaching it means a
+     * query ran at synth time (e.g. at module scope).
+     */
+    getEngine(): never;
 }
 export { sql, createKyselyAdapter } from '@aws-blocks/data-common';
 export type { SqlQuery, Transaction } from '@aws-blocks/data-common';

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

@@ -1 +1 @@
-{"version":3,"file":"index.cdk.d.ts","sourceRoot":"","sources":["../src/index.cdk.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AAEH,OAAO,EAAE,KAAK,EAAwB,MAAM,sBAAsB,CAAC;AACnE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAQpD,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,YAAY,CAAC;AAG7D,qBAAa,mBAAoB,SAAQ,KAAK;gBAChC,KAAK,EAAE,WAAW,EAAE,EAAE,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,0BAA0B;CAwFjF;AAaD,OAAO,EAAE,GAAG,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACnE,YAAY,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AACrE,OAAO,EAAE,yBAAyB,EAAE,MAAM,aAAa,CAAC;AACxD,YAAY,EAAE,0BAA0B,EAAE,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.cdk.d.ts","sourceRoot":"","sources":["../src/index.cdk.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AAEH,OAAO,EAAE,KAAK,EAA0D,MAAM,sBAAsB,CAAC;AACrG,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAQpD,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,YAAY,CAAC;AAG7D,qBAAa,mBAAoB,SAAQ,KAAK;gBAChC,KAAK,EAAE,WAAW,EAAE,EAAE,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,0BAA0B;IAgGhF;;;;;OAKG;IACH,SAAS,IAAI,KAAK;CAGnB;AAaD,OAAO,EAAE,GAAG,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACnE,YAAY,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AACrE,OAAO,EAAE,yBAAyB,EAAE,MAAM,aAAa,CAAC;AACxD,YAAY,EAAE,0BAA0B,EAAE,MAAM,YAAY,CAAC"}

package/dist/index.cdk.js

@@ -5,7 +5,7 @@
  * Provisions Aurora DSQL cluster via CloudFormation.
  * Optionally runs migrations via a CustomResource Lambda.
  */
-import { Scope, DEFAULT_NODE_RUNTIME } from '@aws-blocks/core/cdk';
+import { Scope, DEFAULT_NODE_RUNTIME, synthGuard, blocksNodejsBundling } from '@aws-blocks/core/cdk';
 import * as cdk from 'aws-cdk-lib';
 import * as iam from 'aws-cdk-lib/aws-iam';
 import * as lambda from 'aws-cdk-lib/aws-lambda-nodejs';
@@ -18,17 +18,23 @@ export class DistributedDatabase extends Scope {
     constructor(scope, id, options) {
         super(id, { parent: scope });
         const stack = cdk.Stack.of(this);
-        const isSandbox = stack.node.tryGetContext('sandboxMode') === 'true';
         const envName = this.fullId.replace(ENV_SANITIZE, '_');
         const region = stack.region;
         const dbRole = sanitizeDbRoleName(this.fullId);
-        // DSQL Cluster — respect explicit removalPolicy; default to DESTROY in sandbox, RETAIN otherwise.
-        const shouldDestroy = options?.removalPolicy === 'destroy' || (!options?.removalPolicy && isSandbox);
-        const removalPolicy = shouldDestroy ? cdk.RemovalPolicy.DESTROY : cdk.RemovalPolicy.RETAIN;
+        // Removal policy and deletion protection are resolved independently from the
+        // stack-wide `defaults` (per-block `removalPolicy` option wins for that field).
+        // Reading `defaults.deletionProtection` directly — rather than deriving it
+        // from `removalPolicy` — keeps every adopting block consistent: the same
+        // `defaults` object yields the same posture no matter which block reads it.
+        const removalPolicy = options?.removalPolicy === 'destroy'
+            ? cdk.RemovalPolicy.DESTROY
+            : options?.removalPolicy === 'retain'
+                ? cdk.RemovalPolicy.RETAIN
+                : this.defaults.removalPolicy;
         const cluster = new cdk.CfnResource(stack, `${this.fullId}DsqlCluster`, {
             type: 'AWS::DSQL::Cluster',
             properties: {
-                DeletionProtectionEnabled: removalPolicy !== cdk.RemovalPolicy.DESTROY,
+                DeletionProtectionEnabled: this.defaults.deletionProtection,
             },
         });
         cluster.applyRemovalPolicy(removalPolicy);
@@ -63,7 +69,7 @@ export class DistributedDatabase extends Scope {
                 APP_ROLE_ARN: appRoleArn,
                 DB_ROLE_NAME: dbRole,
             },
-            bundling: {
+            bundling: blocksNodejsBundling({
                 commandHooks: {
                     beforeBundling: () => [],
                     beforeInstall: () => [],
@@ -71,7 +77,7 @@ export class DistributedDatabase extends Scope {
                         ? [`cp -r ${resolvedMigrationsPath} ${outputDir}${LAMBDA_MIGRATIONS_DIR.replace('/var/task', '')}`]
                         : [],
                 },
-            },
+            }),
         });
         // Migration Lambda needs Admin access (DDL + role management)
         migrationFn.addToRolePolicy(new iam.PolicyStatement({
@@ -88,6 +94,15 @@ export class DistributedDatabase extends Scope {
         // Ensure migrations run after cluster is created
         migrationCR.node.addDependency(cluster);
     }
+    /**
+     * Runtime-only. This is the CDK (synth) build: it defines infrastructure and
+     * has no engine — queries run in the app Lambda against the deployed cluster.
+     * `createKyselyAdapter()` no longer calls this eagerly, so reaching it means a
+     * query ran at synth time (e.g. at module scope).
+     */
+    getEngine() {
+        return synthGuard('DistributedDatabase', 'getEngine');
+    }
 }
 /** Hash all .sql files in a directory to detect changes. */
 function hashMigrationsDir(dir) {

package/dist/index.cdk.test.js

@@ -12,7 +12,7 @@ import * as lambda from 'aws-cdk-lib/aws-lambda';
 import { Template, Match } from 'aws-cdk-lib/assertions';
 import { mkdirSync, writeFileSync, rmSync } from 'node:fs';
 import { join } from 'node:path';
-import { DEFAULT_NODE_RUNTIME } from '@aws-blocks/core/cdk';
+import { DEFAULT_NODE_RUNTIME, BlocksPresets } from '@aws-blocks/core/cdk';
 import { DistributedDatabase } from './index.cdk.js';
 const MIGRATIONS_DIR = '.bb-data/__test_cdk_migrations__';
 function synth(build) {
@@ -52,17 +52,35 @@ test('CDK: cluster has DeletionProtectionEnabled=true by default', () => {
         DeletionPolicy: 'Retain',
     });
 });
-test('CDK: removalPolicy=destroy disables deletion protection', () => {
-    const template = synth((stack) => {
-        new DistributedDatabase(scope(stack), 'mydsql', { removalPolicy: 'destroy' });
-    });
-    template.hasResource('AWS::DSQL::Cluster', {
-        Properties: { DeletionProtectionEnabled: false },
-        DeletionPolicy: 'Delete',
+test('CDK: per-block removalPolicy is independent of deletion protection', () => {
+    // Deletion protection is read from `defaults` independently of removalPolicy
+    // (consistent across all adopting blocks). Here: sandbox defaults (protection
+    // off) with a per-block `removalPolicy: 'retain'` override → the cluster is
+    // RETAINed on stack delete but not deletion-protected.
+    const app = new cdk.App();
+    const stack = new cdk.Stack(app, 'IndepStack');
+    const handler = new lambda.Function(stack, 'Handler', {
+        runtime: DEFAULT_NODE_RUNTIME,
+        handler: 'index.handler',
+        code: lambda.Code.fromInline('exports.handler = async () => {};'),
     });
+    stack.handler = handler;
+    stack.defaults = BlocksPresets.sandbox;
+    globalThis.CURRENT_BLOCKS_STACK = stack;
+    try {
+        new DistributedDatabase(scope(stack), 'mydsql', { removalPolicy: 'retain' });
+        const template = Template.fromStack(stack);
+        template.hasResource('AWS::DSQL::Cluster', {
+            Properties: { DeletionProtectionEnabled: false },
+            DeletionPolicy: 'Retain',
+        });
+    }
+    finally {
+        delete globalThis.CURRENT_BLOCKS_STACK;
+    }
 });
-test('CDK: sandboxMode=true disables deletion protection', () => {
-    const app = new cdk.App({ context: { sandboxMode: 'true' } });
+test('CDK: sandbox defaults disable deletion protection', () => {
+    const app = new cdk.App();
     const stack = new cdk.Stack(app, 'SandboxStack');
     const handler = new lambda.Function(stack, 'Handler', {
         runtime: DEFAULT_NODE_RUNTIME,
@@ -70,6 +88,9 @@ test('CDK: sandboxMode=true disables deletion protection', () => {
         code: lambda.Code.fromInline('exports.handler = async () => {};'),
     });
     stack.handler = handler;
+    // The cluster's removal/protection follows the stack-wide defaults (resolved
+    // via the globalThis fallback here), not the sandboxMode context.
+    stack.defaults = BlocksPresets.sandbox;
     globalThis.CURRENT_BLOCKS_STACK = stack;
     try {
         new DistributedDatabase(scope(stack), 'mydsql');

package/dist/index.mock.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.mock.d.ts","sourceRoot":"","sources":["../src/index.mock.ts"],"names":[],"mappings":"AAGA;;;GAGG;AAEH,OAAO,EAAE,KAAK,EAA0B,MAAM,kBAAkB,CAAC;AACjE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,EAAgB,KAAK,QAAQ,EAAE,KAAK,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAIxF,OAAO,KAAK,EAAE,0BAA0B,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAEjF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEzD,qBAAa,mBAAoB,SAAQ,KAAK;IAC5C,OAAO,CAAC,IAAI,CAAe;IAC3B,OAAO,CAAC,UAAU,CAAiB;IACnC,OAAO,CAAC,aAAa,CAA8B;IAEnD,2FAA2F;IAC3F,SAAS,CAAC,GAAG,EAAE,WAAW,CAAC;gBAEf,KAAK,EAAE,WAAW,EAAE,EAAE,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,0BAA0B;YAelE,KAAK;IAEnB,KAAK,CAAC,CAAC,EAAE,KAAK,EAAE,QAAQ,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC;IACvC,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,QAAQ,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;IAC/C,OAAO,CAAC,KAAK,EAAE,QAAQ,GAAG,OAAO,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC;IAEvD;;;;;OAKG;IACG,WAAW,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE,kBAAkB,GAAG,OAAO,CAAC,CAAC,CAAC;IAKnG,yDAAyD;IACzD,gBAAgB,IAAI,IAAI;IAExB,gBAAgB;IAChB,SAAS;CACV;AAED,OAAO,EAAE,GAAG,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACnE,YAAY,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AACrE,OAAO,EAAE,yBAAyB,EAAE,MAAM,aAAa,CAAC;AACxD,YAAY,EAAE,0BAA0B,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.mock.d.ts","sourceRoot":"","sources":["../src/index.mock.ts"],"names":[],"mappings":"AAGA;;;GAGG;AAEH,OAAO,EAAE,KAAK,EAA0B,MAAM,kBAAkB,CAAC;AACjE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,EAAgB,KAAK,QAAQ,EAAE,KAAK,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAIxF,OAAO,KAAK,EAAE,0BAA0B,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAEjF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAGzD,qBAAa,mBAAoB,SAAQ,KAAK;IAC5C,OAAO,CAAC,IAAI,CAAe;IAC3B,OAAO,CAAC,UAAU,CAAiB;IACnC,OAAO,CAAC,aAAa,CAA8B;IAEnD,2FAA2F;IAC3F,SAAS,CAAC,GAAG,EAAE,WAAW,CAAC;gBAEf,KAAK,EAAE,WAAW,EAAE,EAAE,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,0BAA0B;YAelE,KAAK;IAEnB,KAAK,CAAC,CAAC,EAAE,KAAK,EAAE,QAAQ,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC;IACvC,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,QAAQ,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;IAC/C,OAAO,CAAC,KAAK,EAAE,QAAQ,GAAG,OAAO,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC;IAEvD;;;;;OAKG;IACG,WAAW,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE,kBAAkB,GAAG,OAAO,CAAC,CAAC,CAAC;IAKnG,yDAAyD;IACzD,gBAAgB,IAAI,IAAI;IAExB,gBAAgB;IAChB,SAAS;CACV;AAED,OAAO,EAAE,GAAG,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACnE,YAAY,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AACrE,OAAO,EAAE,yBAAyB,EAAE,MAAM,aAAa,CAAC;AACxD,YAAY,EAAE,0BAA0B,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC"}

package/dist/index.mock.js

@@ -10,6 +10,7 @@ import { DsqlMockEngine } from './engines/dsql-mock-engine.js';
 import { runMigrations, loadMigrationsFromDir } from './migrations.js';
 import { transactionWithRetry } from './transaction.js';
 import { Logger } from '@aws-blocks/bb-logger';
+import { BB_NAME, BB_VERSION } from './version.js';
 export class DistributedDatabase extends Scope {
     base;
     mockEngine;
@@ -17,7 +18,7 @@ export class DistributedDatabase extends Scope {
     /** @internal Logger for internal operations. Defaults to error-level when not provided. */
     log;
     constructor(scope, id, options) {
-        super(id, { parent: scope });
+        super(id, { parent: scope, bbName: BB_NAME, bbVersion: BB_VERSION });
         this.log = options?.logger ?? new Logger(this, 'logger', { level: 'error' });
         this.mockEngine = new DsqlMockEngine(`.bb-data/${this.fullId}`);
         this.base = new DatabaseBase(this.mockEngine);

package/dist/index.test.d.ts

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

package/dist/index.test.d.ts.map

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

package/dist/index.test.js

@@ -0,0 +1,56 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Telemetry-registration tests for DistributedDatabase.
+ *
+ * `Scope.getRegisteredBlocks()` only names a block whose `bbName` is in
+ * OFFICIAL_BB_NAMES, and that set is generated from the umbrella's
+ * `aws-blocks.vendorize` map. These tests pin the three coupled artifacts to
+ * each other: the block's generated BB_NAME, its vendorize entry, and the
+ * generated name set. A block that omits `bbMeta` still constructs fine and
+ * every other test still passes, so that gap is only visible here.
+ *
+ * The package ships a distinct mock implementation (the default entry does not
+ * re-export the AWS class), so both `index.aws.ts` and `index.mock.ts` carry
+ * the `super()` change. Registration happens in `super()`, identical for both;
+ * these tests exercise the AWS class because its constructor is side-effect
+ * free (the mock eagerly spins up PGlite on disk), keeping the suite fast and
+ * deterministic.
+ */
+import { test, describe, beforeEach } from 'node:test';
+import assert from 'node:assert';
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { Scope } from '@aws-blocks/core';
+import { DistributedDatabase } from './index.aws.js';
+import { BB_NAME, BB_VERSION } from './version.js';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+let counter = 0;
+function makeDb() {
+    const scope = new Scope(`distdata-telemetry-${++counter}`);
+    return new DistributedDatabase(scope, 'db');
+}
+describe('DistributedDatabase telemetry registration', () => {
+    beforeEach(() => {
+        Scope._resetRegistry();
+    });
+    test('BB_NAME is the name the vendorize map and OFFICIAL_BB_NAMES carry', () => {
+        assert.strictEqual(BB_NAME, 'DistributedDatabase');
+    });
+    test('BB_VERSION tracks the package version', () => {
+        const pkg = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf-8'));
+        assert.strictEqual(BB_VERSION, pkg.version);
+    });
+    test('an instance carries bbName and bbVersion', () => {
+        const db = makeDb();
+        assert.strictEqual(db.bbName, BB_NAME);
+        assert.strictEqual(db.bbVersion, BB_VERSION);
+    });
+    test('registers as an official block, so telemetry is allowed to name it', () => {
+        makeDb();
+        const { blocks, customBlocksCount } = Scope.getRegisteredBlocks();
+        assert.deepStrictEqual(blocks.filter(b => b.name === BB_NAME), [{ name: BB_NAME, version: BB_VERSION }]);
+        assert.strictEqual(customBlocksCount, 0, 'must not be filtered out as an unnamed custom block');
+    });
+});

package/dist/types.d.ts

@@ -6,8 +6,10 @@ export interface DistributedDatabaseOptions {
     /** Path to directory containing numbered .sql migration files. */
     migrationsPath?: string;
     /**
-     * CloudFormation removal policy.
-     * @default 'retain'
+     * CloudFormation removal policy for the DSQL cluster. When omitted, the
+     * stack-wide `defaults` apply (`production` → RETAIN, `sandbox` → DESTROY).
+     * Pass `'destroy'`/`'retain'` to override for this one database. Deletion
+     * protection follows: on unless the cluster is being destroyed.
      */
     removalPolicy?: 'destroy' | 'retain';
     /** Optional logger for internal operations. When omitted, a default Logger at error level is created. */

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACzD,MAAM,WAAW,0BAA0B;IACzC,kEAAkE;IAClE,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;;;OAGG;IACH,aAAa,CAAC,EAAE,SAAS,GAAG,QAAQ,CAAC;IACtC,yGAAyG;IACzG,MAAM,CAAC,EAAE,WAAW,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC;;;;OAIG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACzD,MAAM,WAAW,0BAA0B;IACzC,kEAAkE;IAClE,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;;;;;OAKG;IACH,aAAa,CAAC,EAAE,SAAS,GAAG,QAAQ,CAAC;IACtC,yGAAyG;IACzG,MAAM,CAAC,EAAE,WAAW,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC;;;;OAIG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB"}

package/dist/validation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../src/validation.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,eAAe,EAAuB,MAAM,yBAAyB,CAAC;AAU/E,mEAAmE;AACnE,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CA6C5D;AA6BD,uFAAuF;AACvF,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAenD;AAED,kDAAkD;AAClD,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,KAAK,GAAG,KAAK,GAAG,OAAO,CAKtE;AAID,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,QAAQ,CAAK;IACrB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,QAAQ,CAAK;IAErB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAalC,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAUnC,KAAK,IAAI,IAAI;CACd;AAID,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAiB3E;AAED,OAAO,EAAE,eAAe,EAAE,CAAC"}
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../src/validation.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,eAAe,EAAuB,MAAM,yBAAyB,CAAC;AAU/E,mEAAmE;AACnE,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CA6C5D;AA8BD,uFAAuF;AACvF,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAenD;AAED,kDAAkD;AAClD,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,KAAK,GAAG,KAAK,GAAG,OAAO,CAKtE;AAID,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,QAAQ,CAAK;IACrB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,QAAQ,CAAK;IAErB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAalC,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAUnC,KAAK,IAAI,IAAI;CACd;AAID,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAiB3E;AAED,OAAO,EAAE,eAAe,EAAE,CAAC"}

package/dist/validation.js

@@ -73,6 +73,7 @@ const RULES = [
     { pattern: /\b(LISTEN|NOTIFY)\b/i, message: 'DSQL does not support LISTEN/NOTIFY.', severity: 'error' },
     { pattern: /\bCREATE\s+EXTENSION\b/i, message: 'DSQL does not support extensions.', severity: 'error' },
     { pattern: /\bALTER\s+TABLE\b[\s\S]*\bADD\s+COLUMN\b[\s\S]*\bDEFAULT\b/i, message: 'DSQL does not support ADD COLUMN with DEFAULT.', severity: 'error' },
+    { pattern: /\bALTER\s+TABLE\b[^;]*\bDROP\s+(?:COLUMN\b|IF\s+EXISTS\b|(?!(?:DEFAULT|NOT|EXPRESSION|IDENTITY|CONSTRAINT)\b)[\w"])/i, message: 'DSQL does not support ALTER TABLE DROP COLUMN. Leave the column in place and stop referencing it, or rebuild the table (create a new table → INSERT INTO ... SELECT → DROP → RENAME TO). (DSQL: "unsupported ALTER TABLE DROP COLUMN statement")', severity: 'error' },
     { pattern: /\bALTER\s+DEFAULT\s+PRIVILEGES\b/i, message: 'DSQL does not support ALTER DEFAULT PRIVILEGES.', severity: 'error' },
     { pattern: /\b(CREATE\s+POLICY|ENABLE\s+ROW\s+LEVEL\s+SECURITY)\b/i, message: 'DSQL does not support Row Level Security.', severity: 'error' },
     { pattern: /\bCREATE\s+(TEMP|TEMPORARY)\s+TABLE\b/i, message: 'DSQL does not support temporary tables.', severity: 'error' },

package/dist/validation.test.js

@@ -45,12 +45,38 @@ describe('validateStatement', () => {
         ['ISOLATION LEVEL', 'SET TRANSACTION ISOLATION LEVEL SERIALIZABLE'],
         // DSQL only supports C collation — locale-aware sorting is not available
         ['COLLATE', 'SELECT * FROM t ORDER BY name COLLATE "en_US"'],
+        // DROP COLUMN is not in DSQL's supported ALTER TABLE subset — rebuild the table instead
+        ['DROP COLUMN', 'ALTER TABLE t DROP COLUMN x'],
+        // Postgres allows omitting the COLUMN keyword — same DROP COLUMN action, same rejection
+        ['DROP COLUMN shorthand', 'ALTER TABLE t DROP x'],
+        ['DROP COLUMN IF EXISTS shorthand', 'ALTER TABLE t DROP IF EXISTS x'],
+        ['DROP COLUMN quoted shorthand', 'ALTER TABLE t DROP "identity"'],
     ];
     for (const [label, sql] of rejects) {
         it(`rejects ${label}`, () => {
             assert.throws(() => validateStatement(sql), { name: 'DsqlValidationError' });
         });
     }
+    it('allows supported ALTER TABLE forms that contain DROP', () => {
+        // Per the DSQL ALTER TABLE grammar, the ALTER COLUMN ... DROP actions and
+        // DROP CONSTRAINT are supported — must not be confused with the
+        // unsupported DROP [COLUMN].
+        // https://docs.aws.amazon.com/aurora-dsql/latest/userguide/alter-table-syntax-support.html
+        assert.doesNotThrow(() => validateStatement('ALTER TABLE t ALTER COLUMN c DROP IDENTITY'));
+        assert.doesNotThrow(() => validateStatement('ALTER TABLE t ALTER COLUMN c DROP DEFAULT'));
+        assert.doesNotThrow(() => validateStatement('ALTER TABLE t ALTER COLUMN c DROP NOT NULL'));
+        assert.doesNotThrow(() => validateStatement('ALTER TABLE t ALTER COLUMN c DROP EXPRESSION'));
+        assert.doesNotThrow(() => validateStatement('ALTER TABLE t DROP CONSTRAINT c'));
+        assert.doesNotThrow(() => validateStatement('ALTER TABLE t DROP CONSTRAINT IF EXISTS c CASCADE'));
+        assert.doesNotThrow(() => validateStatement('ALTER TABLE t RENAME TO t2'));
+        assert.doesNotThrow(() => validateStatement('DROP TABLE t'));
+    });
+    it('allows a supported ALTER TABLE followed by an unrelated statement in one batch', () => {
+        // The DROP COLUMN rule must not match across a statement boundary: the
+        // ALTER TABLE here is a supported DROP DEFAULT, and the DROP TABLE that
+        // follows the semicolon belongs to a different statement.
+        assert.doesNotThrow(() => validateStatement('ALTER TABLE t ALTER COLUMN c DROP DEFAULT; DROP TABLE archived'));
+    });
 });
 describe('classifyStatement', () => {
     it('classifies DDL/DML/other', () => {

package/dist/version.d.ts

@@ -0,0 +1,3 @@
+export declare const BB_NAME = "DistributedDatabase";
+export declare const BB_VERSION = "0.1.6";
+//# sourceMappingURL=version.d.ts.map

package/dist/version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../src/version.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,OAAO,wBAAwB,CAAC;AAC7C,eAAO,MAAM,UAAU,UAAU,CAAC"}

package/dist/version.js

@@ -0,0 +1,3 @@
+// Auto-generated by scripts/generate-version.mjs — do not edit manually
+export const BB_NAME = 'DistributedDatabase';
+export const BB_VERSION = '0.1.6';

package/package.json

@@ -1,6 +1,15 @@
 {
   "name": "@aws-blocks/bb-distributed-data",
-  "version": "0.1.3",
+  "version": "0.1.6",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/aws-devtools-labs/aws-blocks.git",
+    "directory": "packages/bb-distributed-data"
+  },
+  "homepage": "https://github.com/aws-devtools-labs/aws-blocks/tree/main/packages/bb-distributed-data#readme",
+  "bugs": {
+    "url": "https://github.com/aws-devtools-labs/aws-blocks/issues"
+  },
   "author": "Amazon Web Services",
   "license": "Apache-2.0",
   "type": "module",
@@ -23,13 +32,14 @@
     }
   },
   "scripts": {
+    "prebuild": "node ../../scripts/generate-version.mjs DistributedDatabase",
     "build": "tsc --build",
     "test": "node --test 'dist/**/*.test.js'"
   },
   "dependencies": {
-    "@aws-blocks/core": "^0.1.1",
-    "@aws-blocks/data-common": "^0.1.1",
-    "@aws-blocks/bb-logger": "^0.1.2",
+    "@aws-blocks/core": "^0.2.0",
+    "@aws-blocks/data-common": "^0.1.4",
+    "@aws-blocks/bb-logger": "^0.1.4",
     "@aws-sdk/dsql-signer": "^3.700.0",
     "@electric-sql/pglite": "^0.2.0",
     "pg": "^8.13.0"