@cosmicdrift/kumiko-framework 0.387.0 → 0.388.0

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,6 +21,7 @@ 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";
@@ -28,8 +31,8 @@ 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,12 +8,14 @@ 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";
@@ -22,7 +25,7 @@ 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

@@ -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/query.d.ts

@@ -1,9 +1,9 @@
 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 { 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 +30,8 @@ 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 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>;
@@ -92,7 +80,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>;