uql-orm 0.81.0 → 0.83.0

package/dist/dialect/abstractSqlDialect.js

@@ -1,12 +1,12 @@
 import { fieldOf, getMeta, relationOf, soleIdOf } from '../entity/index.js';
 import { COUNT_RESULT_KEY, parseQueryLock, QueryRaw, RAW_ALIAS, } from '../type/index.js';
 import { isInlinedExpression } from '../util/field.util.js';
-import { asSelectMap, assertNonNegativeInteger, escapeSqlId, fillOnFields, filterFieldKeys, getInsertFieldKeys, getKeys, getRelationRequestSummary, getSoftDeleteValue, hasKeys, idOnlyQuery, columnFamily, countedRelations, fieldUpdateOf, fulltextIndexOver, fulltextWeights, isFieldUpdateOp, isJsonObject, isJsonUpdateOp, isOperatorMap, isOperatorKey, isVectorSearch, normalizeScalarFieldSelection, parentJoins, rankedTextSearch, targetKeyColumns, textSearchFields, textSortOf, textWeightSteps, parseGroupMap, parseRelationAtKey, parseRelationSize, populatesRelations, aggregateOf, raw, refs, throwUnknownAggregateColumn, withoutSoftDeleteFilter, } from '../util/index.js';
+import { asSelectMap, assertNonNegativeInteger, assertWhere, definedEntries, escapeSqlId, fillOnFields, filterFieldKeys, getInsertFieldKeys, getKeys, getRelationRequestSummary, getSoftDeleteValue, hasKeys, idOnlyQuery, columnFamily, countedRelations, fieldUpdateOf, fulltextIndexOver, fulltextWeights, isFieldUpdateOp, isJsonObject, isJsonUpdateOp, isOperatorMap, isOperatorKey, isVectorSearch, normalizeScalarFieldSelection, parentJoins, rankedTextSearch, targetKeyColumns, textSearchFields, textSortOf, textWeightSteps, parseGroupMap, parseRelationAtKey, parseRelationSize, populatesRelations, aggregateOf, raw, refs, throwUnknownAggregateColumn, withoutSoftDeleteFilter, } from '../util/index.js';
 import { escapeAnsiSqlLiteral } from '../util/sqlLiteral.js';
 import { kindOf, UqlUsageError } from '../util/uqlError.js';
 import { AGGREGATE_PAGE_ALIAS, AGGREGATE_VALUE_ALIAS, ROWS_ALIAS, JSON_ELEM_ALIAS, JSON_PULL_ALIAS, relationSortColumn, } from './aliases.js';
 import { holdsOperator, isJsonScalar, jsonCompareMode, jsonElemExists, jsonPath, } from './jsonSql.js';
-import { betweenBounds, COMPARE_OPS, EQUALITY_OPS, GROUP_OPS, groupClauses, inOperands, isGroupOp, isOrderedOp, isVectorQuery, LIKE_OPS, ORDERED_OPS, VECTOR_QUERY_KEY_SET, whereOperators, } from './operators.js';
+import { betweenBounds, COMPARE_OPS, EQUALITY_OPS, GROUP_OPS, groupClauses, inOperands, isGroupOp, isOrderedOp, isVectorQuery, LIKE_OPS, namesRows, ORDERED_OPS, VECTOR_QUERY_KEY_SET, whereOperators, } from './operators.js';
 import { SqlQueryContext } from './queryContext.js';
 import { groupPathField, NO_JOINS, aggregateColumnField, resolveGroupJoins, resolveQueryJoins, relationSortTerms, resolveSortableJoin, } from './queryJoins.js';
 import { resolveVectorCast } from './vectorCast.js';
@@ -34,6 +34,13 @@ function orRefuse(value, refusal) {
     }
     return value;
 }
+/**
+ * Whether an assignment builds on what each row before it left: `$inc`, `$mul`, `$push`. A set-based
+ * `UPDATE` writes a target once however many rows of its set match it, so it would apply one of them.
+ */
+function accumulates(value) {
+    return isFieldUpdateOp(value) || (isJsonUpdateOp(value) && value.$push !== undefined);
+}
 /** Conditions joined by `AND`, parenthesized where there is more than one. */
 function conjunction(parts) {
     return parts.length > 1 ? `(${parts.join(' AND ')})` : parts.join('');
@@ -178,7 +185,7 @@ export class AbstractSqlDialect extends VectorSqlDialect {
     returningIdExpression(meta) {
         const [idKey] = meta.ids;
         return meta.ids.length === 1
-            ? `${this.returnedRowPrefix}${this.escapeId(this.columnOf(meta, idKey))} ${this.escapeId('id')}`
+            ? `${this.returnedRowPrefix}${this.escapedColumnName(meta, idKey)} ${this.escapeId('id')}`
             : '';
     }
     search(ctx, entity, q = {}, opts = {}, joins = NO_JOINS, order) {
@@ -423,7 +430,7 @@ export class AbstractSqlDialect extends VectorSqlDialect {
             join.relation.references.forEach((reference, index) => {
                 if (index > 0)
                     ctx.append(' AND ');
-                const foreign = this.escapeId(this.columnOf(join.meta, reference.foreign));
+                const foreign = this.escapedColumnName(join.meta, reference.foreign);
                 // Two calls rather than one over a union: the parent is either another join's entity or the
                 // queried one, and their metadata types have nothing in common.
                 const local = this.escapeId(join.parent ? this.columnOf(join.parent.meta, reference.local) : this.columnOf(meta, reference.local));
@@ -1254,30 +1261,99 @@ export class AbstractSqlDialect extends VectorSqlDialect {
         const meta = getMeta(entity);
         const [filledPayload] = fillOnFields(meta, payload, 'onUpdate');
         const keys = filterFieldKeys(meta, filledPayload, 'onUpdate');
-        const tableName = this.escapedTableName(meta);
-        ctx.append(`UPDATE ${tableName} SET `);
+        ctx.append(`UPDATE ${this.escapedTableName(meta)} SET `);
         for (let i = 0; i < keys.length; i++) {
             if (i > 0) {
                 ctx.append(', ');
             }
-            const key = keys[i];
-            const field = meta.fields[key];
-            const escapedCol = this.escapedColumnName(meta, key);
-            const value = filledPayload[key];
-            if (isJsonUpdateOp(value)) {
-                this.formatJsonUpdate(ctx, escapedCol, value, field);
-            }
-            else if (isFieldUpdateOp(value)) {
-                const [op, operand] = fieldUpdateOf(key, value);
-                ctx.append(`${escapedCol} = COALESCE(${escapedCol}, 0) ${SQL_ARITHMETIC[op]} `);
-                ctx.addValue(operand);
+            this.appendAssignment(ctx, meta, keys[i], filledPayload[keys[i]]);
+        }
+        this.search(ctx, entity, q, opts);
+    }
+    /** `col = value`, a JSON operator or a `$inc`/`$mul` spelled as the engine's. */
+    appendAssignment(ctx, meta, key, value) {
+        const field = meta.fields[key];
+        const escapedCol = this.escapedColumnName(meta, key);
+        if (isJsonUpdateOp(value)) {
+            this.formatJsonUpdate(ctx, escapedCol, value, field);
+        }
+        else if (isFieldUpdateOp(value)) {
+            const [op, operand] = fieldUpdateOf(key, value);
+            ctx.append(`${escapedCol} = COALESCE(${escapedCol}, 0) ${SQL_ARITHMETIC[op]} `);
+            ctx.addValue(operand);
+        }
+        else {
+            ctx.append(`${escapedCol} = `);
+            this.formatPersistableValue(ctx, field, value);
+        }
+    }
+    /**
+     * A write in a trigger's body. Only the columns it names, none filled in JavaScript - that would bake
+     * one value into the trigger - no id read back, and no entity filter, which a request resolves and a
+     * trigger has none of. `rows` is the `FROM` a set-based engine's body reads its rows through.
+     */
+    triggerWrite(ctx, write, rows) {
+        const meta = getMeta(write.entity);
+        const table = this.escapedTableName(meta);
+        if (write.kind === 'insert') {
+            const unfilled = definedEntries(meta.fields).find(([key, field]) => field.onInsert !== undefined && field.defaultValue === undefined && write.row[key] === undefined);
+            if (unfilled) {
+                throw new UqlUsageError(`'${meta.name}.${unfilled[0]}' is filled on insert by uql, which a trigger does not run: ` +
+                    'name it, or give it a defaultValue');
             }
-            else {
-                ctx.append(`${escapedCol} = `);
-                this.formatPersistableValue(ctx, field, value);
+            const entries = this.writtenEntries(meta, write.row);
+            const columns = entries.map(([key]) => this.escapedColumnName(meta, key)).join(', ');
+            const [open, close] = rows ? ['SELECT ', ` ${rows};`] : ['VALUES (', ');'];
+            ctx.append(`INSERT INTO ${table} (${columns}) ${open}`);
+            entries.forEach(([key, value], i) => {
+                if (i > 0) {
+                    ctx.append(', ');
+                }
+                this.formatPersistableValue(ctx, meta.fields[key], value);
+            });
+            ctx.append(close);
+            return;
+        }
+        assertWhere(meta, write.where);
+        if (!namesRows(write.where)) {
+            throw new UqlUsageError(`a trigger's ${write.kind} over '${meta.name}' names no rows, so it would address every one`);
+        }
+        if (write.kind === 'update') {
+            const entries = this.writtenEntries(meta, write.set);
+            const accumulating = rows && entries.find(([, value]) => accumulates(value));
+            if (accumulating) {
+                throw new UqlUsageError(`'${meta.name}.${accumulating[0]}' cannot accumulate per row in a trigger fired once per statement, ` +
+                    'which applies $inc, $mul and $push once');
             }
+            ctx.append(`UPDATE ${table} SET `);
+            entries.forEach(([key, value], i) => {
+                if (i > 0) {
+                    ctx.append(', ');
+                }
+                this.appendAssignment(ctx, meta, key, value);
+            });
         }
-        this.search(ctx, entity, q, opts);
+        else {
+            ctx.append(`DELETE FROM ${table}`);
+        }
+        if (rows) {
+            ctx.append(` ${rows}`);
+        }
+        // Qualified by the table: on a set-based engine `inserted` holds the same column names.
+        this.renderWhere(ctx, write.entity, write.where, { escapedPrefix: `${table}.` });
+        ctx.append(';');
+    }
+    /** The values a write names, refusing one the entity has no column for. */
+    writtenEntries(meta, values) {
+        const entries = Object.entries(values).filter(([, value]) => value !== undefined);
+        const unknown = entries.find(([key]) => !meta.fields[key]);
+        if (unknown) {
+            throw new UqlUsageError(`'${meta.name}' has no field '${unknown[0]}' for a trigger to write`);
+        }
+        if (!entries.length) {
+            throw new UqlUsageError(`a trigger's write to '${meta.name}' names no field`);
+        }
+        return entries;
     }
     /**
      * `INSERT ... ON CONFLICT ... DO UPDATE/NOTHING RETURNING`. The assignments are built before the insert
@@ -1312,23 +1388,18 @@ export class AbstractSqlDialect extends VectorSqlDialect {
         return fields
             .filter((col) => !conflictPaths[col])
             .map((col) => {
-            const field = meta.fields[col];
-            const columnName = this.resolveColumnName(col, field);
+            const column = this.escapedColumnName(meta, col);
             if (Object.hasOwn(sample, col)) {
-                return `${this.escapeId(columnName)} = ${callback(this.escapeId(columnName))}`;
+                return `${column} = ${callback(column)}`;
             }
-            const text = this.buildFragment(ctx, (fragmentCtx) => this.formatPersistableValue(fragmentCtx, field, filledPayload[col]));
-            return `${this.escapeId(columnName)} = ${text}`;
+            const text = this.buildFragment(ctx, (fragmentCtx) => this.formatPersistableValue(fragmentCtx, meta.fields[col], filledPayload[col]));
+            return `${column} = ${text}`;
         })
             .join(', ');
     }
     getUpsertConflictPathsStr(meta, conflictPaths) {
         return getKeys(conflictPaths)
-            .map((key) => {
-            const field = meta.fields[key];
-            const columnName = this.resolveColumnName(key, field);
-            return this.escapeId(columnName);
-        })
+            .map((key) => this.escapedColumnName(meta, key))
             .join(', ');
     }
     delete(ctx, entity, q, opts = {}) {
@@ -1337,10 +1408,8 @@ export class AbstractSqlDialect extends VectorSqlDialect {
         // Soft-delete (stamp only live rows) unless `hardDelete` is requested or the entity has no
         // soft-delete field (e.g. a cascade onto a non-soft-deletable child).
         if (!opts.hardDelete && meta.softDelete) {
-            const field = fieldOf(meta, meta.softDelete);
-            const columnName = this.resolveColumnName(meta.softDelete, field);
-            ctx.append(`UPDATE ${tableName} SET ${this.escapeId(columnName)} = `);
-            this.formatPersistableValue(ctx, field, getSoftDeleteValue(field));
+            ctx.append(`UPDATE ${tableName} SET `);
+            this.appendAssignment(ctx, meta, meta.softDelete, getSoftDeleteValue(fieldOf(meta, meta.softDelete)));
             this.search(ctx, entity, q, opts);
             return;
         }
@@ -1537,19 +1606,19 @@ export class AbstractSqlDialect extends VectorSqlDialect {
     jsonDiffers(elem, operand) {
         return `${elem} <> ${operand}`;
     }
-    compileDdl(sql, entity) {
+    compileDdl(sql, entity, { rows, escapedPrefix, operand } = {}) {
         const ctx = this.createContext({ inlineValues: true });
         if (sql instanceof QueryRaw) {
-            sql.render({ ctx, dialect: this, prefix: '', escapedPrefix: '', entity });
+            sql.render({ ctx, dialect: this, prefix: '', escapedPrefix: escapedPrefix ?? '', entity, rows });
         }
         else if (entity) {
-            this.renderWhere(ctx, entity, sql, { clause: false });
+            this.renderWhere(ctx, entity, sql, { clause: false, escapedPrefix, operand });
         }
         else {
-            throw new TypeError('a predicate compiles against the entity it is written for, and none was given');
+            throw new UqlUsageError('a predicate compiles against the entity it is written for, and none was given');
         }
         if (ctx.values.length) {
-            throw new TypeError(`DDL has no placeholder to bind a value into, and this SQL left one bound: ${ctx.sql}`);
+            throw new UqlUsageError(`DDL has no placeholder to bind a value into, and this SQL left one bound: ${ctx.sql}`);
         }
         return ctx.sql;
     }
@@ -1884,7 +1953,7 @@ export class AbstractSqlDialect extends VectorSqlDialect {
         const distance = (fragmentCtx) => this.appendVectorDistance(fragmentCtx, meta, key, near, prefix);
         return this.boundConditions(ctx, distance, bounds, (operand, op, val) => (isOrderedOp(op) ? this.operatorCondition(ctx, operand, op, val) : undefined), 'unsupported $near bound');
     }
-    /** ANSI-style single-quote escaping. MySQL-family dialects override this for backslash escaping. */
+    /** ANSI-style single-quote escaping. */
     escape(value) {
         return escapeAnsiSqlLiteral(value);
     }

package/dist/dialect/hydrateColumn.js

@@ -1,3 +1,4 @@
+import { decodeDate } from '../util/date.js';
 import { decodeWideNumber } from '../util/wideNumber.js';
 import { decodeFloat32s, parseVectorLiteral } from './vectorCast.js';
 /**
@@ -31,7 +32,7 @@ const float32Decoder = (value) => {
 const DECODERS = {
     // 0/1 from SQLite's INTEGER or MySQL's TINYINT(1). Already a boolean on Postgres.
     boolean: (value) => (typeof value === 'boolean' ? value : Boolean(value)),
-    date: (value) => (typeof value === 'string' ? (parseDate(value) ?? value) : value),
+    date: (value) => (typeof value === 'string' ? decodeDate(value) : value),
     // Only a string can be bytes that crossed JSON: bytes a driver already decoded stay as they are.
     bytes: (value) => typeof value === 'string' && value.startsWith(BYTES_PREFIX) ? hexBytes(value.slice(BYTES_PREFIX.length)) : value,
     // A number too, not just text: `type: BigInt` is BIGINT, which the pg pools decode at the wire.
@@ -61,17 +62,6 @@ const DECODERS = {
     halfvec: vectorDecoder('halfvec'),
     sparsevec: vectorDecoder('sparsevec'),
 };
-/**
- * An ISO 8601 timestamp as a `Date`, its fraction cut to the milliseconds one holds, and a bare date at
- * local midnight, which is how `pg` reads a `date`. `undefined` for text that is neither.
- */
-function parseDate(text) {
-    const day = /^(\d{4})-(\d{2})-(\d{2})$/.exec(text);
-    const date = day
-        ? new Date(Number(day[1]), Number(day[2]) - 1, Number(day[3]))
-        : new Date(text.replace(/(\.\d{3})\d+/, '$1'));
-    return Number.isNaN(date.getTime()) ? undefined : date;
-}
 /**
  * What bytes crossing JSON start with, before two hex digits per byte: Postgres's own text for `bytea`,
  * which every dialect spells, so a string a driver reads from a column on its own is never mistaken.

package/dist/dialect/mysqlLikeSqlDialect.d.ts

@@ -78,6 +78,8 @@ export declare abstract class MysqlLikeSqlDialect extends AbstractSqlDialect {
     /** Bytes as the hex text `decodeColumn` reads back, whole. */
     protected bytesAsText(expr: string): string;
     escape(value: unknown): string;
+    /** A date as UTC text, which a `DATETIME` stores as is, where a driver would convert it to its own zone. */
+    normalizeValue(value: unknown): unknown;
     /**
      * `MATCH(cols) AGAINST(?)`, which needs a `FULLTEXT` index over exactly those columns: without one
      * the server answers "Can't find FULLTEXT index matching the column list". Declare it with

package/dist/dialect/mysqlLikeSqlDialect.js

@@ -1,4 +1,5 @@
 import { getMeta } from '../entity/index.js';
+import { utcTimestamp } from '../util/date.js';
 import { textSearchFields } from '../util/index.js';
 import { escapeMysqlSqlLiteral, escapeSingleQuotes } from '../util/sqlLiteral.js';
 import { AbstractSqlDialect, } from './abstractSqlDialect.js';
@@ -187,6 +188,10 @@ export class MysqlLikeSqlDialect extends AbstractSqlDialect {
     escape(value) {
         return escapeMysqlSqlLiteral(value);
     }
+    /** A date as UTC text, which a `DATETIME` stores as is, where a driver would convert it to its own zone. */
+    normalizeValue(value) {
+        return value instanceof Date ? utcTimestamp(value) : super.normalizeValue(value);
+    }
     /**
      * `MATCH(cols) AGAINST(?)`, which needs a `FULLTEXT` index over exactly those columns: without one
      * the server answers "Can't find FULLTEXT index matching the column list". Declare it with

package/dist/dialect/operators.d.ts

@@ -1,4 +1,4 @@
-import { type QueryGroupOp, type QueryOrderedOp, type QueryVectorQuery, type QueryWhereArray, type QueryWhereFieldOp } from '../type/index.js';
+import { type QueryGroupOp, type QueryOrderedOp, type QueryVectorQuery, type QueryWhere, type QueryWhereArray, type QueryWhereFieldOp } from '../type/index.js';
 /**
  * How each grouping operator renders: the operator joining its clauses, and whether the group is
  * negated (`$not` is `NOT (a AND b)`). Total over {@link QueryGroupOp}.
@@ -29,6 +29,12 @@ export declare function isGroupOp(key: string): key is QueryGroupOp;
  * refuse the same payload rather than one throwing and the other failing further in.
  */
 export declare function groupClauses<E>(key: QueryGroupOp, val: QueryWhereArray<E> | undefined): QueryWhereArray<E>;
+/**
+ * Whether a `$where` names any rows, as the WHERE it renders would: an `undefined` value, an empty
+ * operator map and a group none of whose clauses names one all render nothing, which a write reads as
+ * the whole table.
+ */
+export declare function namesRows<E>(where: QueryWhere<E> | undefined): boolean;
 /**
  * A WHERE value as the operators it applies: an array is `$in`, an operator map its own entries, and
  * anything else `$eq`. Each key is checked here, once, refused as `refusal` where it is no operator.

package/dist/dialect/operators.js

@@ -1,5 +1,6 @@
-import { VECTOR_QUERY_KEYS, } from '../type/index.js';
+import { QueryRaw, VECTOR_QUERY_KEYS, } from '../type/index.js';
 import { isOperatorMap } from '../util/dialect.util.js';
+import { hasKeys, isWhereMap, someKey } from '../util/object.util.js';
 import { kindOf, UqlUsageError } from '../util/uqlError.js';
 /**
  * How each grouping operator renders: the operator joining its clauses, and whether the group is
@@ -26,6 +27,17 @@ export function groupClauses(key, val) {
     }
     return val ?? [];
 }
+/**
+ * Whether a `$where` names any rows, as the WHERE it renders would: an `undefined` value, an empty
+ * operator map and a group none of whose clauses names one all render nothing, which a write reads as
+ * the whole table.
+ */
+export function namesRows(where) {
+    return (where !== undefined &&
+        someKey(where, (key) => isGroupOp(key)
+            ? groupClauses(key, where[key]).some((clause) => clause instanceof QueryRaw || namesRows(clause))
+            : where[key] !== undefined && !(isWhereMap(where[key]) && !hasKeys(where[key]))));
+}
 /**
  * A WHERE value as the operators it applies: an array is `$in`, an operator map its own entries, and
  * anything else `$eq`. Each key is checked here, once, refused as `refusal` where it is no operator.

package/dist/dialect/pgLikeSqlDialect.d.ts

@@ -105,6 +105,7 @@ export declare abstract class PgLikeSqlDialect extends AbstractSqlDialect {
      * array takes its type from `operand`, so it needs none of the casts `bind` would give each value.
      */
     protected formatIn(ctx: QueryContext, operand: string, values: unknown[], negate: boolean, bind: (value: unknown) => string): string;
+    escape(value: unknown): string;
     protected numericCast(expr: string): string;
     protected appendJsonValue(ctx: QueryContext, value: unknown, type: JsonColumnType): void;
     /**

package/dist/dialect/pgLikeSqlDialect.js

@@ -1,6 +1,7 @@
 import { QueryRaw, } from '../type/index.js';
+import { utcTimestamp } from '../util/date.js';
 import { fulltextConfig, fulltextIndexOver, hasVectorNear, textSearchFields } from '../util/dialect.util.js';
-import { escapeSingleQuotes } from '../util/sqlLiteral.js';
+import { escapePgSqlLiteral, escapeSingleQuotes, PG_UTC } from '../util/sqlLiteral.js';
 import { AbstractSqlDialect } from './abstractSqlDialect.js';
 import { JSON_PULL_ALIAS, RELATION_ROW_ALIAS } from './aliases.js';
 import { BYTES_PREFIX } from './hydrateColumn.js';
@@ -128,10 +129,11 @@ export class PgLikeSqlDialect extends AbstractSqlDialect {
         return statements;
     }
     normalizeValue(value) {
-        if (value != null && typeof value === 'object' && Array.isArray(value)) {
-            return this.driverCapabilities.nativeArrays ? value : toPgArray(value);
+        if (Array.isArray(value)) {
+            const values = value.map(utcDate);
+            return this.driverCapabilities.nativeArrays ? values : toPgArray(values);
         }
-        return super.normalizeValue(value);
+        return super.normalizeValue(utcDate(value));
     }
     placeholder(index) {
         return `$${index}`;
@@ -240,6 +242,9 @@ export class PgLikeSqlDialect extends AbstractSqlDialect {
         const ph = this.addValue(ctx, values);
         return negate ? `${operand} <> ALL(${ph})` : `${operand} = ANY(${ph})`;
     }
+    escape(value) {
+        return escapePgSqlLiteral(value);
+    }
     numericCast(expr) {
         return `(${expr})::numeric`;
     }
@@ -306,6 +311,10 @@ export class PgLikeSqlDialect extends AbstractSqlDialect {
         return this.driverCapabilities.explicitJsonCast ? `(${ph}::text)::${type}` : `${ph}::${type}`;
     }
 }
+/** A date as UTC text, which a zoneless `TIMESTAMP` stores as is, where each driver would pick its own zone. */
+function utcDate(value) {
+    return value instanceof Date ? utcTimestamp(value, PG_UTC) : value;
+}
 /**
  * Converts a JS array to a Postgres array literal string: `{"val1","val2"}`.
  * Safely handles nesting and escaping of special characters.

package/dist/entity/metadata/definition.d.ts

@@ -45,7 +45,7 @@ export declare function fieldOf<E>(meta: EntityMeta<E>, key: string): FieldMeta;
 /** The relation `key` names, for a caller that took `key` from the metadata itself. */
 export declare function relationOf<E>(meta: EntityMeta<E>, key: RelationKey<E>): RelationMeta;
 /** A row of `E` as far as reading its key goes: a record or a write, whatever its values. */
-type KeyedRow<E> = {
+export type KeyedRow<E> = {
     readonly [K in keyof E]?: unknown;
 };
 /** Whether the row names every column of its primary key, `0` and `''` included. */
@@ -67,4 +67,3 @@ export declare function getMeta<E>(entity: Type<E>): EntityMeta<E>;
  * schema build constrains and a junction joins by, settling the relations holding them first.
  */
 export declare function foreignKeysOf<E>(meta: EntityMeta<E>): RelationMeta[];
-export {};