@cosmicdrift/kumiko-framework 0.387.0 → 0.389.0

package/dist/db/event-store-executor.js

@@ -1,12 +1,13 @@
 import { buildExecutorContext } from "./event-store-executor-context.js";
 import { createReadVerbs } from "./event-store-executor-read.js";
 import { createWriteVerbs } from "./event-store-executor-write.js";
+import { withOwnTransactionOnPool } from "./event-store-executor-write-atomic.js";
 export { WritePurposes } from "@cosmicdrift/kumiko-types/event-store-executor-types";
 export { entityEventName } from "./event-store-executor-context.js";
 export function createEventStoreExecutor(table, entity, options) {
     const ctx = buildExecutorContext(table, entity, options);
     return {
-        ...createWriteVerbs(ctx),
+        ...withOwnTransactionOnPool(createWriteVerbs(ctx)),
         ...createReadVerbs(ctx),
     };
 }

package/dist/db/executor-managed-tables.js

@@ -20,7 +20,7 @@ export function registerExecutorManagedWriteRunner(runner) {
     executorManagedWriteRunners.add(runner);
 }
 // WeakSet.has never reads a property off runner, so a fail-closed guard Proxy stays untouched.
-// postgres.js clients are callable (tagged templates), so a runner can be a function.
+// Bun.SQL clients are callable (tagged templates), so a runner can be a function.
 export function hasExecutorManagedWriteCapability(runner) {
     if (typeof runner !== "object" && typeof runner !== "function")
         return false;

package/dist/db/index.d.ts

@@ -1,3 +1,4 @@
+export { isTimestamptzType } from "./aggregate-sql.ts";
 export { applyEntityEvent } from "./apply-entity-event.ts";
 export { assertExistsIn } from "./assert-exists-in.ts";
 export { nullBlindIndexesForSubject, recordEventsOwnedExclusivelyByTenant, recordRowExistsInTenant, recordRowOwningTenantId, subjectRowExistsInTenant, } from "./blind-index-cleanup.ts";
@@ -10,6 +11,7 @@ export type { CursorQueryOptions, CursorResult, DecodedKeysetCursor } from "./cu
 export { decodeCursor, decodeKeysetCursor, encodeCursor, encodeKeysetCursor } from "./cursor.ts";
 export type { SchemaTable, SelectQuery, TableColumns } from "./dialect.ts";
 export { bigint, bigserial, boolean, extractTableName, index, instant, instantToDriver, integer, jsonb, moneyAmount, numeric, primaryKey, serial, sql, table, text, timestamp, uniqueIndex, uuid, } from "./dialect.ts";
+export { instantToTimestamptzParam } from "./driver-value-preparation.ts";
 export type { EagerLoadEntityResolver, EagerLoadViewer, EagerloadedRow } from "./eagerload.ts";
 export { collectReferenceFields, enrichRowWithReferences, enrichWithReferences, } from "./eagerload.ts";
 export { collectEncryptedFieldNames, configuredEntityFieldEncryption, configureEntityFieldEncryption, decryptEntityFieldValues, encryptEntityFieldValues, } from "./entity-field-encryption.ts";
@@ -19,17 +21,18 @@ export { defineUnmanagedTable, deriveEntityTableMeta, } from "./entity-table-met
 export type { EntityLifecycleVerb, EventStoreExecutor, EventStoreExecutorOptions, LockGuardOption, WritePurpose, } from "./event-store-executor.ts";
 export { createEventStoreExecutor, entityEventName, WritePurposes, } from "./event-store-executor.ts";
 export { enumerateFeatureTableSources, type FeatureTableSource, } from "./feature-table-sources.ts";
+export { answerListAggregate, labelListAggregateGroups } from "./list-aggregate-labels.ts";
 export { flattenLocatedTimestamp, type LocatedTimestampRead, rehydrateLocatedTimestamp, } from "./located-timestamp.ts";
 export { assertUniqueTableNames, assertValidMigrationName, diffSnapshots, type GenerateMigrationInput, type GenerateMigrationOutput, generateMigration, loadSnapshotJson, renderMigrationSql, type SchemaDiff, type Snapshot, snapshotFromMetas, writeSnapshotJson, } from "./migrate-generator.ts";
 export { type AppliedMigration, type ApplyResult, type BaselineResult, baselineMigrations, fetchAppliedMigrations, loadMigrationsFromDir, type Migration, MigrationChecksumMismatchError, readMigrationSqlTexts, runMigrations, runMigrationsFromDir, splitSqlStatements, } from "./migrate-runner.ts";
 export { flattenMoney, type MoneyRead, moneyPayloadToMinorUnits, rehydrateMoney } from "./money.ts";
-export { constraintOf, extractPgError, isTableAlreadyExists, isUniqueViolation, type PgErrorInfo, } from "./pg-error.ts";
+export { constraintOf, extractPgError, isTableAlreadyExists, isUndefinedTable, isUniqueViolation, type PgErrorInfo, } from "./pg-error.ts";
 export { acquireNamespacedAdvisoryLock } from "./queries/advisory-lock.ts";
 export { readDatabaseNow } from "./queries/database-now.ts";
 export { toPostgresArrayLiteral } from "./queries/postgres-array-literal.ts";
 export { executeRawQuery, executeRawQueryRead } from "./queries/raw-sql.ts";
-export type { DeleteManyBatchedOptions, DeleteManyBatchedResult, IncrementCounterOptions, InnerJoinRow, InnerJoinSpec, InsertOnConflictDoNothingOptions, JoinColumnPair, JsonTextMatch, SelectOptions, TableInfo, UpsertOnConflictOptions, WhereObject, WhereOperator, WhereValue, } from "./query.ts";
-export { aggregateWhere, asEntityTableMeta, asRawClient, countWhere, deleteMany, deleteManyBatched, extractTableInfo, fetchOne, incrementCounter, insertMany, insertOnConflictDoNothing, insertOne, instantToTimestamptzParam, isTimestamptzType, requireEntityTableMeta, runInSavepoint, runInSavepointIfSupported, runnerCanBeginTransaction, selectInnerJoin, selectMany, transaction, unsafeReadRetrying, updateMany, upsertByPk, upsertOnConflict, } from "./query.ts";
+export type { DeleteManyBatchedOptions, DeleteManyBatchedResult, IncrementCounterOptions, InnerJoinRow, InnerJoinSpec, InsertOnConflictDoNothingOptions, JoinColumnPair, JsonTextMatch, SelectOptions, UpsertOnConflictOptions, WhereObject, WhereOperator, WhereValue, } from "./query.ts";
+export { aggregateWhere, asEntityTableMeta, asRawClient, countWhere, deleteMany, deleteManyBatched, fetchOne, incrementCounter, insertMany, insertOnConflictDoNothing, insertOne, requireEntityTableMeta, runInSavepoint, runInSavepointIfSupported, runnerCanBeginTransaction, selectInnerJoin, selectMany, transaction, unsafeReadRetrying, updateMany, upsertByPk, upsertOnConflict, } from "./query.ts";
 export { readRebuildMarker, rebuildTablesFromDiff, writeRebuildMarker, } from "./rebuild-marker.ts";
 export { seedReferenceData } from "./reference-data.ts";
 export { renderTableDdl, renderTablesDdl } from "./render-ddl.ts";
@@ -38,5 +41,6 @@ export { findCommentedDropTables, isRetiredFrameworkTable, type RetiredFramework
 export { tableExists } from "./schema-inspection.ts";
 export { withoutStatementTimeout } from "./statement-timeout.ts";
 export { buildBaseColumns, buildEntityTable, declareGlobalTenancy, type EntityRow, type EntityTable, type ExecutorManagedRunner, type ExecutorManagedWriteCapability, physicalColumnName, toSnakeCase, toTableName, type Writable, type WritableSchemaTable, type WritableTable, } from "./table-builder.ts";
+export { extractTableInfo, type TableInfo } from "./table-info.ts";
 export type { CreateTenantDbOptions, ExecutorManagedTenantDb, OutsideTransactionContext, TenantDb, TenantDbGrants, TenantDbMode, UncheckedSystemDb, } from "./tenant-db.ts";
 export { castTenantRows, createSystemDbView, createTenantDataDestroyDb, createTenantDb, hasOutsideTransactionDb, requireOutsideTransactionDb, runInOwnTransaction, SYSTEM_SCOPE_CHECK_BRAND, scopeTenantDbToTenant, } from "./tenant-db.ts";

package/dist/db/index.js

@@ -1,3 +1,4 @@
+export { isTimestamptzType } from "./aggregate-sql.js";
 export { applyEntityEvent } from "./apply-entity-event.js";
 export { assertExistsIn } from "./assert-exists-in.js";
 export { nullBlindIndexesForSubject, recordEventsOwnedExclusivelyByTenant, recordRowExistsInTenant, recordRowOwningTenantId, subjectRowExistsInTenant, } from "./blind-index-cleanup.js";
@@ -7,22 +8,24 @@ export { seedConfigValues } from "./config-seed.js";
 export { createDbConnection, DEFAULT_OUTSIDE_TRANSACTION_POOL_MAX, dbConnectionOptionsFromEnv, outsideTransactionPoolOptionsFromEnv, serverTimeoutOptionsFromEnv, } from "./connection.js";
 export { decodeCursor, decodeKeysetCursor, encodeCursor, encodeKeysetCursor } from "./cursor.js";
 export { bigint, bigserial, boolean, extractTableName, index, instant, instantToDriver, integer, jsonb, moneyAmount, numeric, primaryKey, serial, sql, table, text, timestamp, uniqueIndex, uuid, } from "./dialect.js";
+export { instantToTimestamptzParam } from "./driver-value-preparation.js";
 export { collectReferenceFields, enrichRowWithReferences, enrichWithReferences, } from "./eagerload.js";
 export { collectEncryptedFieldNames, configuredEntityFieldEncryption, configureEntityFieldEncryption, decryptEntityFieldValues, encryptEntityFieldValues, } from "./entity-field-encryption.js";
 export { entityTableFromRegistry } from "./entity-table-from-registry.js";
 export { defineUnmanagedTable, deriveEntityTableMeta, } from "./entity-table-meta.js";
 export { createEventStoreExecutor, entityEventName, WritePurposes, } from "./event-store-executor.js";
 export { enumerateFeatureTableSources, } from "./feature-table-sources.js";
+export { answerListAggregate, labelListAggregateGroups } from "./list-aggregate-labels.js";
 export { flattenLocatedTimestamp, rehydrateLocatedTimestamp, } from "./located-timestamp.js";
 export { assertUniqueTableNames, assertValidMigrationName, diffSnapshots, generateMigration, loadSnapshotJson, renderMigrationSql, snapshotFromMetas, writeSnapshotJson, } from "./migrate-generator.js";
 export { baselineMigrations, fetchAppliedMigrations, loadMigrationsFromDir, MigrationChecksumMismatchError, readMigrationSqlTexts, runMigrations, runMigrationsFromDir, splitSqlStatements, } from "./migrate-runner.js";
 export { flattenMoney, moneyPayloadToMinorUnits, rehydrateMoney } from "./money.js";
-export { constraintOf, extractPgError, isTableAlreadyExists, isUniqueViolation, } from "./pg-error.js";
+export { constraintOf, extractPgError, isTableAlreadyExists, isUndefinedTable, isUniqueViolation, } from "./pg-error.js";
 export { acquireNamespacedAdvisoryLock } from "./queries/advisory-lock.js";
 export { readDatabaseNow } from "./queries/database-now.js";
 export { toPostgresArrayLiteral } from "./queries/postgres-array-literal.js";
 export { executeRawQuery, executeRawQueryRead } from "./queries/raw-sql.js";
-export { aggregateWhere, asEntityTableMeta, asRawClient, countWhere, deleteMany, deleteManyBatched, extractTableInfo, fetchOne, incrementCounter, insertMany, insertOnConflictDoNothing, insertOne, instantToTimestamptzParam, isTimestamptzType, requireEntityTableMeta, runInSavepoint, runInSavepointIfSupported, runnerCanBeginTransaction, selectInnerJoin, selectMany, transaction, unsafeReadRetrying, updateMany, upsertByPk, upsertOnConflict, } from "./query.js";
+export { aggregateWhere, asEntityTableMeta, asRawClient, countWhere, deleteMany, deleteManyBatched, fetchOne, incrementCounter, insertMany, insertOnConflictDoNothing, insertOne, requireEntityTableMeta, runInSavepoint, runInSavepointIfSupported, runnerCanBeginTransaction, selectInnerJoin, selectMany, transaction, unsafeReadRetrying, updateMany, upsertByPk, upsertOnConflict, } from "./query.js";
 export { readRebuildMarker, rebuildTablesFromDiff, writeRebuildMarker, } from "./rebuild-marker.js";
 export { seedReferenceData } from "./reference-data.js";
 export { renderTableDdl, renderTablesDdl } from "./render-ddl.js";
@@ -31,4 +34,5 @@ export { findCommentedDropTables, isRetiredFrameworkTable, retiredFrameworkTable
 export { tableExists } from "./schema-inspection.js";
 export { withoutStatementTimeout } from "./statement-timeout.js";
 export { buildBaseColumns, buildEntityTable, declareGlobalTenancy, physicalColumnName, toSnakeCase, toTableName, } from "./table-builder.js";
+export { extractTableInfo } from "./table-info.js";
 export { castTenantRows, createSystemDbView, createTenantDataDestroyDb, createTenantDb, hasOutsideTransactionDb, requireOutsideTransactionDb, runInOwnTransaction, SYSTEM_SCOPE_CHECK_BRAND, scopeTenantDbToTenant, } from "./tenant-db.js";

package/dist/db/list-aggregate-labels.d.ts

@@ -0,0 +1,14 @@
+import type { ListAggregateResult } from "@cosmicdrift/kumiko-types/list-aggregate-types";
+import type { EntityDefinition } from "../engine/types/index.ts";
+import type { EagerLoadEntityResolver, EagerLoadViewer } from "./eagerload.ts";
+import type { EventStoreExecutor } from "./event-store-executor.ts";
+import type { TenantDb } from "./tenant-db.ts";
+type LabelDeps = {
+    readonly entity: EntityDefinition;
+    readonly resolveEntity: EagerLoadEntityResolver;
+    readonly viewer: EagerLoadViewer;
+};
+export declare function labelListAggregateGroups(result: ListAggregateResult, groupByField: string | undefined, deps: LabelDeps, db: TenantDb): Promise<ListAggregateResult>;
+type AggregateRequest = Parameters<EventStoreExecutor["aggregate"]>[0];
+export declare function answerListAggregate(executor: Pick<EventStoreExecutor, "aggregate">, request: AggregateRequest, user: Parameters<EventStoreExecutor["aggregate"]>[1], db: TenantDb, runtimeOptions: Parameters<EventStoreExecutor["aggregate"]>[3], labelDeps: LabelDeps): Promise<ListAggregateResult>;
+export {};

package/dist/db/list-aggregate-labels.js

@@ -0,0 +1,26 @@
+import { enrichWithReferences } from "./eagerload.js";
+function labelOf(ref, labelField) {
+    if (typeof ref !== "object" || ref === null || Array.isArray(ref))
+        return null;
+    const value = Reflect.get(ref, labelField);
+    return typeof value === "string" ? value : null;
+}
+// Labels come from the same eager-load path as list rows, so they carry its
+// ownership and field-read gating instead of a second label query.
+export async function labelListAggregateGroups(result, groupByField, deps, db) {
+    if (groupByField === undefined || result.groups.length === 0)
+        return result;
+    const def = deps.entity.fields[groupByField];
+    if (def?.type !== "reference" || def.multiple === true)
+        return result;
+    const enriched = await enrichWithReferences(result.groups.map((g) => ({ [groupByField]: g.key })), deps.entity, deps.resolveEntity, db, deps.viewer);
+    const groups = result.groups.map((group, i) => {
+        const ref = Reflect.get(enriched[i]?.["_refs"] ?? {}, groupByField);
+        return { ...group, label: labelOf(ref, def.labelField ?? "id") };
+    });
+    return { ...result, groups };
+}
+export async function answerListAggregate(executor, request, user, db, runtimeOptions, labelDeps) {
+    const result = await executor.aggregate(request, user, db, runtimeOptions);
+    return labelListAggregateGroups(result, request.aggregate.groupBy, labelDeps, db);
+}

package/dist/db/migrate-generator.js

@@ -79,100 +79,85 @@ function indexesByName(meta) {
         m.set(indexMetaKey(i), i);
     return m;
 }
-function diffOneTable(prev, next) {
-    const prevCols = columnsByName(prev);
-    const nextCols = columnsByName(next);
-    const newColumns = [];
-    const droppedColumns = [];
-    const changedColumns = [];
-    for (const [name, nextCol] of nextCols) {
-        const prevCol = prevCols.get(name);
-        if (!prevCol) {
-            newColumns.push(nextCol);
-            continue;
-        }
-        const change = { name };
-        if (prevCol.notNull !== nextCol.notNull) {
-            Object.assign(change, {
-                nullabilityChanged: { from: prevCol.notNull, to: nextCol.notNull },
-            });
-        }
-        if (prevCol.defaultSql !== nextCol.defaultSql) {
-            Object.assign(change, {
-                defaultChanged: { from: prevCol.defaultSql, to: nextCol.defaultSql },
-            });
-        }
-        if (prevCol.pgType !== nextCol.pgType) {
-            Object.assign(change, {
-                typeChanged: { from: prevCol.pgType, to: nextCol.pgType },
-            });
-        }
-        if (change.nullabilityChanged || change.defaultChanged || change.typeChanged) {
-            changedColumns.push(change);
-        }
-    }
-    for (const name of prevCols.keys()) {
-        if (!nextCols.has(name))
-            droppedColumns.push(name);
-    }
-    const prevIdx = indexesByName(prev);
-    const nextIdx = indexesByName(next);
-    const newIndexes = [];
-    const droppedIndexes = [];
-    const changedIndexes = [];
-    for (const [name, idx] of nextIdx) {
-        const prevI = prevIdx.get(name);
-        if (!prevI) {
-            newIndexes.push(idx);
+function strictEqual(a, b) {
+    return a === b;
+}
+function fromToWhenDifferent(from, to, isEqual = strictEqual) {
+    return isEqual(from, to) ? undefined : { from, to };
+}
+// added and changed follow next's order, dropped follows prev's order; the
+// rendered migration depends on both.
+function diffByName(prev, next, compare) {
+    const added = [];
+    const changed = [];
+    for (const [name, nextItem] of next) {
+        const prevItem = prev.get(name);
+        if (prevItem === undefined) {
+            added.push(nextItem);
             continue;
         }
-        const columnsChanged = indexColumnsEqual(prevI.columns, idx.columns)
-            ? undefined
-            : { from: prevI.columns, to: idx.columns };
-        const uniqueChanged = (prevI.unique ?? false) === (idx.unique ?? false)
-            ? undefined
-            : { from: prevI.unique ?? false, to: idx.unique ?? false };
-        // Whitespace-only re-rendering of the predicate must not drop and rebuild a large index.
-        const whereSqlChanged = whereSqlEqual(prevI.whereSql, idx.whereSql)
-            ? undefined
-            : { from: prevI.whereSql, to: idx.whereSql };
-        const needsManualWhereChanged = (prevI.needsManualWhere ?? false) === (idx.needsManualWhere ?? false)
-            ? undefined
-            : { from: prevI.needsManualWhere ?? false, to: idx.needsManualWhere ?? false };
-        if (columnsChanged || uniqueChanged || whereSqlChanged || needsManualWhereChanged) {
-            // Single literal typed as IndexChange so a misspelled key fails to compile instead of silently dropping the change.
-            const change = {
-                name,
-                ...(columnsChanged && { columnsChanged }),
-                ...(uniqueChanged && { uniqueChanged }),
-                ...(whereSqlChanged && { whereSqlChanged }),
-                ...(needsManualWhereChanged && { needsManualWhereChanged }),
-            };
-            changedIndexes.push(change);
-        }
+        const change = compare(name, prevItem, nextItem);
+        if (change !== undefined)
+            changed.push(change);
     }
-    for (const name of prevIdx.keys()) {
-        if (!nextIdx.has(name))
-            droppedIndexes.push(name);
+    const dropped = [...prev.keys()].filter((name) => !next.has(name));
+    return { added, dropped, changed };
+}
+function compareColumns(name, prevCol, nextCol) {
+    const nullabilityChanged = fromToWhenDifferent(prevCol.notNull, nextCol.notNull);
+    const defaultChanged = fromToWhenDifferent(prevCol.defaultSql, nextCol.defaultSql);
+    const typeChanged = fromToWhenDifferent(prevCol.pgType, nextCol.pgType);
+    if (!nullabilityChanged && !defaultChanged && !typeChanged)
+        return undefined;
+    return {
+        name,
+        ...(nullabilityChanged && { nullabilityChanged }),
+        ...(defaultChanged && { defaultChanged }),
+        ...(typeChanged && { typeChanged }),
+    };
+}
+function compareIndexes(name, prevIndex, nextIndex) {
+    const columnsChanged = fromToWhenDifferent(prevIndex.columns, nextIndex.columns, indexColumnsEqual);
+    const uniqueChanged = fromToWhenDifferent(prevIndex.unique ?? false, nextIndex.unique ?? false);
+    // Whitespace-only re-rendering of the predicate must not drop and rebuild a large index.
+    const whereSqlChanged = fromToWhenDifferent(prevIndex.whereSql, nextIndex.whereSql, whereSqlEqual);
+    const needsManualWhereChanged = fromToWhenDifferent(prevIndex.needsManualWhere ?? false, nextIndex.needsManualWhere ?? false);
+    if (!columnsChanged && !uniqueChanged && !whereSqlChanged && !needsManualWhereChanged) {
+        return undefined;
     }
-    const isEmpty = newColumns.length === 0 &&
-        droppedColumns.length === 0 &&
-        changedColumns.length === 0 &&
-        newIndexes.length === 0 &&
-        droppedIndexes.length === 0 &&
-        changedIndexes.length === 0;
-    if (isEmpty)
-        return null;
+    // Single literal typed as IndexChange so a misspelled key fails to compile instead of silently dropping the change.
     return {
+        name,
+        ...(columnsChanged && { columnsChanged }),
+        ...(uniqueChanged && { uniqueChanged }),
+        ...(whereSqlChanged && { whereSqlChanged }),
+        ...(needsManualWhereChanged && { needsManualWhereChanged }),
+    };
+}
+function hasNoTableChanges(diff) {
+    return [
+        diff.newColumns,
+        diff.droppedColumns,
+        diff.changedColumns,
+        diff.newIndexes,
+        diff.droppedIndexes,
+        diff.changedIndexes,
+    ].every((list) => list.length === 0);
+}
+function diffOneTable(prev, next) {
+    const columns = diffByName(columnsByName(prev), columnsByName(next), compareColumns);
+    const indexes = diffByName(indexesByName(prev), indexesByName(next), compareIndexes);
+    const diff = {
         tableName: prev.tableName,
-        newColumns,
-        droppedColumns,
-        changedColumns,
-        newIndexes,
-        droppedIndexes,
-        changedIndexes,
+        newColumns: columns.added,
+        droppedColumns: columns.dropped,
+        changedColumns: columns.changed,
+        newIndexes: indexes.added,
+        droppedIndexes: indexes.dropped,
+        changedIndexes: indexes.changed,
         nextMeta: next,
     };
+    return hasNoTableChanges(diff) ? null : diff;
 }
 export function diffSnapshots(prev, next) {
     const prevByName = new Map();

package/dist/db/migrate-runner.js

@@ -188,16 +188,16 @@ function migrationClient(db) {
         if (hasBegin(client))
             return client;
     }
-    throw new Error("migrate-runner: db argument has no .unsafe() and .begin() (need a postgres-js Sql or drizzle DbConnection)");
+    throw new Error("migrate-runner: db argument has no .unsafe() and .begin() (need a Bun.SQL pool or a DbConnection)");
 }
-// Raw-SQL via postgres-js .unsafe().
+// Raw-SQL via Bun.SQL .unsafe().
 async function executeRaw(db, sqlText) {
     await migrationClient(db).unsafe(sqlText);
 }
 async function reserveConnection(db) {
     const client = migrationClient(db);
     if (typeof client.reserve !== "function") {
-        throw new Error("migrate-runner: db argument has no .reserve() (need a postgres-js Sql)");
+        throw new Error("migrate-runner: db argument has no .reserve() (need a Bun.SQL pool)");
     }
     return client.reserve();
 }
@@ -280,7 +280,10 @@ export async function runMigrations(db, migrations) {
             return { applied: appliedIds, skipped: skippedIds };
         }
         finally {
-            await conn.unsafe(`SELECT pg_advisory_unlock(${MIGRATION_ADVISORY_LOCK_KEY})`);
+            // A dropped session already released its lock; failing here would mask the migration error.
+            await conn
+                .unsafe(`SELECT pg_advisory_unlock(${MIGRATION_ADVISORY_LOCK_KEY})`)
+                .catch(() => undefined);
         }
     }
     finally {

package/dist/db/pg-error.js

@@ -1,28 +1,33 @@
-// Drizzle wraps postgres-js errors in `DrizzleQueryError`; the original PG
-// error (with SQLSTATE `code` and `constraint_name`) lives in `.cause`. We
-// unwrap both layers so callers don't have to know which layer produced the
-// error. Used by the event-store to distinguish a unique-violation on the
-// aggregate-version index (optimistic-concurrency conflict) from the one on
-// the idempotency-key index (caller-side replay signal).
+// Bun.SQL server errors carry the SQLSTATE in `errno` and the constraint in
+// `constraint` (`code` is the generic ERR_POSTGRES_SERVER_ERROR). Client-side
+// failures have no `errno`, so their `code` (e.g. ERR_POSTGRES_CONNECTION_CLOSED)
+// is returned instead. The `.cause` chain is walked so wrapped errors resolve too.
+import { propertyOf } from "@cosmicdrift/kumiko-types/type-guards";
 const MAX_CAUSE_DEPTH = 8;
+function stringOrUndefined(value) {
+    return typeof value === "string" ? value : undefined;
+}
+function infoOfLayer(layer) {
+    const sqlState = stringOrUndefined(propertyOf(layer, "errno"));
+    if (sqlState !== undefined) {
+        return {
+            code: sqlState,
+            constraint_name: stringOrUndefined(propertyOf(layer, "constraint")),
+        };
+    }
+    const code = stringOrUndefined(propertyOf(layer, "code"));
+    return code === undefined ? null : { code, constraint_name: undefined };
+}
 export function extractPgError(e) {
-    if (typeof e !== "object" || e === null)
-        return null;
-    const layers = [];
     let current = e;
     // Depth cap doubles as cycle protection for self-referential causes.
-    while (typeof current === "object" && current !== null && layers.length < MAX_CAUSE_DEPTH) {
-        layers.push(current);
-        // @cast-boundary error-details — DrizzleQueryError wraps PG-error in .cause
-        current = current.cause;
-    }
-    for (const layer of layers) {
-        // @cast-boundary error-details — postgres-js error shape (code, constraint_name)
-        const code = layer.code;
-        const constraintName = layer.constraint_name; // @cast-boundary error-details
-        if (code !== undefined || constraintName !== undefined) {
-            return { code, constraint_name: constraintName };
-        }
+    for (let depth = 0; depth < MAX_CAUSE_DEPTH; depth++) {
+        if (typeof current !== "object" || current === null)
+            return null;
+        const info = infoOfLayer(current);
+        if (info !== null)
+            return info;
+        current = propertyOf(current, "cause");
     }
     return null;
 }

package/dist/db/queries/backfill-pii.js

@@ -499,7 +499,7 @@ async function rekeyTenantKeyedValue(deps, target) {
     const userSubject = keyedUnder?.kind === "tenant" && keyedUnder.tenantId === target.tenantId
         ? rekeyTargetOfTenantKeyedValue(target)
         : keyedUnder?.kind === "user"
-            ? currentProjectionOwnerIfOther(target, keyedUnder.userId)
+            ? currentProjectionOwnerIfOther(target, fieldDef.userOwned.ownerField, keyedUnder.userId)
             : null;
     if (userSubject === null)
         return { kind: "unchanged" };
@@ -536,11 +536,8 @@ function rekeyTargetOfTenantKeyedValue(target) {
 // A value keyed under a previous owner moves to the owner the row has now. The
 // projection of the event's own tenant is authoritative here: the payload of
 // an old created event still names the owner the row had back then.
-function currentProjectionOwnerIfOther(target, keyedUserId) {
-    const fieldDef = target.entity.fields[target.field];
-    if (fieldDef === undefined || !("userOwned" in fieldDef) || !fieldDef.userOwned)
-        return null;
-    const owner = nonEmptyString(target.projectionOwnerRow?.[fieldDef.userOwned.ownerField]);
+function currentProjectionOwnerIfOther(target, ownerField, keyedUserId) {
+    const owner = nonEmptyString(target.projectionOwnerRow?.[ownerField]);
     return owner === null || owner === keyedUserId ? null : { kind: "user", userId: owner };
 }
 // Only the row's own tenant key or a user key counts: another tenant's key is

package/dist/db/queries/database-now.js

@@ -1,7 +1,8 @@
 import { executeRawQueryRead } from "./raw-sql.js";
 // Called by createTenantDb with its inner runner; keeps raw SQL out of consumers.
+// timestamptz(3): events.created_at has millisecond precision, a microsecond now() would compare later.
 export async function queryDatabaseNow(runner) {
-    const [row] = await executeRawQueryRead(runner, "SELECT now() AS now");
+    const [row] = await executeRawQueryRead(runner, "SELECT now()::timestamptz(3) AS now");
     if (!row)
         throw new Error("SELECT now() returned no row");
     return row.now;

package/dist/db/queries/shadow-swap.js

@@ -19,6 +19,7 @@
 // partial index whose WHERE the renderer can't express is rejected up-front.
 import { isUuid, parseTenantId } from "@cosmicdrift/kumiko-types/identifiers";
 import { configuredBlindIndexKey } from "../../crypto/index.js";
+import { extractPgError } from "../pg-error.js";
 import { asEntityTableMeta, asRawClient } from "../query.js";
 import { renderTableDdl } from "../render-ddl.js";
 import { columnNamesOf, tableExists } from "../schema-inspection.js";
@@ -27,9 +28,7 @@ import { quoteTableIdent } from "./table-ops.js";
 export const PROJECTION_REBUILD_SCHEMA = "kumiko_rebuild";
 const SCHEMA_IDENT = quoteTableIdent(PROJECTION_REBUILD_SCHEMA);
 function isDuplicateSchemaError(e) {
-    if (typeof e !== "object" || e === null || !("code" in e))
-        return false;
-    const { code } = e;
+    const code = extractPgError(e)?.code;
     // 42P06 duplicate_schema, 23505 unique_violation on pg_namespace — both
     // surface from the well-known CREATE SCHEMA IF NOT EXISTS race.
     return code === "42P06" || code === "23505";

package/dist/db/query.d.ts

@@ -1,9 +1,11 @@
 import type { AggregateRow, AggregateSpec } from "@cosmicdrift/kumiko-types/aggregate-types";
 import type { DbRunner, DbTx } from "@cosmicdrift/kumiko-types/db-connection";
 import type { ExecutorManagedRunner, ExecutorManagedWriteCapability, WritableTable } from "@cosmicdrift/kumiko-types/executor-brand";
-import { Temporal } from "@cosmicdrift/kumiko-types/temporal";
 import type { SelectOptions, WhereObject } from "@cosmicdrift/kumiko-types/where-clause-types";
+import { type ClosedConnectionContext } from "./closed-connection.ts";
+import { type PreparedValue } from "./driver-value-preparation.ts";
 import type { EntityTableMeta } from "./entity-table-meta.ts";
+import { type TableInfo } from "./table-info.ts";
 import { asEntityTableMeta, requireEntityTableMeta } from "./table-introspection.ts";
 export { asEntityTableMeta, requireEntityTableMeta };
 export type ReservedClient = {
@@ -30,20 +32,9 @@ export declare function runInSavepointIfSupported<T>(db: unknown, fn: (sp: DbRun
 export type AnyDb = DbRunner | unknown;
 type AnyRow = any;
 export type { JsonTextMatch, OrderByClause, SelectOptions, WhereObject, WhereOperator, WhereValue, } from "@cosmicdrift/kumiko-types/where-clause-types";
-type TableLike = EntityTableMeta | any;
-export type TableInfo = {
-    readonly name: string;
-    readonly columnOf: (field: string) => string;
-    readonly pgTypeOf: (column: string) => string | undefined;
-    readonly bigintJsModeOf: (column: string) => "number" | "bigint" | undefined;
-    readonly fieldOf: (column: string) => string;
-    readonly hasColumn: (fieldOrColumn: string) => boolean;
-};
-export declare function extractTableInfo(table: TableLike): TableInfo;
+export type TableLike = EntityTableMeta | any;
 export declare function coerceRow<TOut = Record<string, unknown>>(row: Record<string, unknown>, info: TableInfo): TOut;
-export declare function instantToTimestamptzParam(instant: Temporal.Instant): string;
-export declare function isClosedConnectionError(err: unknown): boolean;
-export declare function describeClosedConnectionFailure(raw: unknown, err: unknown, attempts: number): Record<string, unknown> | undefined;
+export declare function unsafeLoggingClosedConnection<TRow = unknown>(db: AnyDb, sqlText: string, params: readonly unknown[], context: ClosedConnectionContext): Promise<readonly TRow[]>;
 export declare function unsafeReadRetrying<TRow>(db: AnyDb, sqlText: string, params: readonly unknown[]): Promise<readonly TRow[]>;
 export declare function selectMany<TRow = AnyRow>(db: AnyDb, table: TableLike, where?: WhereObject, options?: SelectOptions): Promise<readonly TRow[]>;
 export declare function fetchOne<TRow = AnyRow>(db: AnyDb, table: TableLike, where: WhereObject): Promise<TRow | undefined>;
@@ -75,7 +66,18 @@ export declare function updateMany<TRow = AnyRow>(db: AnyDb, table: WritableTabl
 export declare function updateMany<TRow = AnyRow>(db: ExecutorManagedWriteCapability, table: EntityTableMeta, set: Record<string, unknown>, where: WhereObject): Promise<readonly TRow[]>;
 export declare function deleteMany(db: AnyDb, table: WritableTable, where: WhereObject): Promise<number>;
 export declare function deleteMany(db: ExecutorManagedWriteCapability, table: EntityTableMeta, where: WhereObject): Promise<number>;
+export type InsertEntry = {
+    readonly field: string;
+    readonly col: string;
+    readonly prepared: PreparedValue;
+};
+export declare function insertEntries(info: TableInfo, values: Record<string, unknown>): InsertEntry[];
 export declare function resolveConflictColumns(table: TableLike, info: TableInfo, conflictKeys: readonly string[] | undefined): readonly string[];
+export declare function conflictUpdateParts(info: TableInfo, entries: readonly InsertEntry[], update: Record<string, unknown> | undefined, skipCols: ReadonlySet<string>, params: unknown[]): string[];
+export declare function buildInsertSql(info: TableInfo, entries: readonly InsertEntry[]): {
+    sqlPrefix: string;
+    params: unknown[];
+};
 export type UpsertOnConflictOptions = {
     readonly conflictKeys: readonly string[];
     /** Columns to set on conflict. Default: EXCLUDED for every inserted non-key column. */
@@ -92,7 +94,6 @@ export type DeleteManyBatchedResult = {
     readonly batches: number;
 };
 export declare function countWhere(db: AnyDb, table: TableLike, where?: WhereObject): Promise<number>;
-export declare function isTimestamptzType(pgType: string | undefined): boolean;
 export declare function aggregateWhere(db: AnyDb, table: TableLike, spec: AggregateSpec, where?: WhereObject): Promise<readonly AggregateRow[]>;
 export declare function upsertOnConflict<TRow = AnyRow>(db: AnyDb, table: WritableTable, values: Record<string, unknown>, options: UpsertOnConflictOptions): Promise<TRow | undefined>;
 export declare function upsertOnConflict<TRow = AnyRow>(db: ExecutorManagedWriteCapability, table: EntityTableMeta, values: Record<string, unknown>, options: UpsertOnConflictOptions): Promise<TRow | undefined>;