uql-orm 0.82.0 → 0.83.1

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/http/handler.js

@@ -42,13 +42,12 @@ export function createRequestHandler(opts) {
     };
     async function run(entity, { op, method, id }, req) {
         const meta = getMeta(entity);
-        // QUERY (RFC 10008) carries the JSON query in the body instead of the query string
-        const rawQuery = method === 'QUERY' ? req.body : req.query;
         const hookCtx = {
             meta,
             op,
             method,
-            query: parseQueryParams(rawQuery),
+            // QUERY (RFC 10008) carries the JSON query in the body instead of the query string
+            query: parseQueryParams(method === 'QUERY' ? req.body : req.query),
             body: req.body,
             context: req.context,
         };
@@ -69,11 +68,9 @@ export function createRequestHandler(opts) {
             else {
                 await preFilter?.(hookCtx);
             }
-            const resp = await dispatch();
-            if (post) {
-                await post(hookCtx, resp.body);
-            }
-            return resp;
+            const envelope = await dispatch();
+            await post?.(hookCtx, envelope);
+            return { status: 200, body: envelope };
         });
         function dispatch() {
             // read post-hooks so both in-place mutation and reassignment of hookCtx.query apply
@@ -84,59 +81,59 @@ export function createRequestHandler(opts) {
                 case 'findOne':
                     return withQuerier(async (querier) => {
                         const data = await querier.findOne(entity, query);
-                        return ok({ data, count: data ? 1 : 0 });
+                        return { data, count: data ? 1 : 0 };
                     });
                 case 'count':
                     return withQuerier(async (querier) => {
                         const count = await querier.count(entity, query);
-                        return ok({ data: count, count });
+                        return { data: count, count };
                     });
                 case 'findOneById':
                     return withQuerier(async (querier) => {
                         const data = await querier.findOne(entity, buildIdQuery(meta, id, query));
-                        return ok({ data, count: data ? 1 : 0 });
+                        return { data, count: data ? 1 : 0 };
                     });
                 case 'findMany':
                     return withQuerier(async (querier) => {
                         const findManyPromise = querier.findMany(entity, query);
                         const countPromise = flags.count ? querier.count(entity, query) : undefined;
                         const [data, count] = await Promise.all([findManyPromise, countPromise]);
-                        return ok({ data, count });
+                        return { data, count };
                     });
                 case 'insertOne':
                     return withTransaction(async (querier) => {
                         const data = await querier.insertOne(entity, hookCtx.body);
-                        return ok({ data, count: 1 });
+                        return { data, count: 1 };
                     });
                 case 'insertMany':
                     return withTransaction(async (querier) => {
                         const data = await querier.insertMany(entity, hookCtx.body);
-                        return ok({ data, count: data.length });
+                        return { data, count: data.length };
                     });
                 case 'saveOne':
                     return withTransaction(async (querier) => {
                         const data = await querier.saveOne(entity, hookCtx.body);
-                        return ok({ data, count: 1 });
+                        return { data, count: 1 };
                     });
                 case 'saveMany':
                     return withTransaction(async (querier) => {
                         const data = await querier.saveMany(entity, hookCtx.body);
-                        return ok({ data, count: data.length });
+                        return { data, count: data.length };
                     });
                 case 'updateOneById':
                     return withTransaction(async (querier) => {
                         const count = await querier.updateMany(entity, buildIdQuery(meta, id, query), hookCtx.body);
-                        return ok({ data: id, count });
+                        return { data: id, count };
                     });
                 case 'updateMany':
                     return withTransaction(async (querier) => {
                         const count = await querier.updateMany(entity, query, hookCtx.body);
-                        return ok({ data: count, count });
+                        return { data: count, count };
                     });
                 case 'deleteOneById':
                     return withTransaction(async (querier) => {
                         const count = await querier.deleteMany(entity, buildIdQuery(meta, id, query), { hardDelete });
-                        return ok({ data: id, count });
+                        return { data: id, count };
                     });
                 case 'deleteMany':
                     return withTransaction(async (querier) => {
@@ -148,15 +145,12 @@ export function createRequestHandler(opts) {
                             ids = founds.map((found) => found[idKey]);
                             count = await querier.deleteMany(entity, { $where: whereIds(meta, ids) }, { hardDelete });
                         }
-                        return ok({ data: ids, count });
+                        return { data: ids, count };
                     });
             }
         }
     }
 }
-function ok(body) {
-    return { status: 200, body };
-}
 function buildIdQuery(meta, id, query) {
     query.$where = whereWith(soleIdOf(meta, 'the HTTP handler'), id, query.$where);
     return query;

package/dist/http/query.d.ts

@@ -1,9 +1,9 @@
 import type { WireQuery } from '../type/index.js';
 /**
- * Parse raw query-string entries (with JSON-stringified values) into a UQL query object.
- * Symmetric counterpart of {@link stringifyQuery}. Only {@link ALLOWED_QUERY_KEYS} are honored.
+ * Parse raw query-string entries (with JSON-stringified values), or a `QUERY` body, into a UQL query
+ * object. Symmetric counterpart of {@link stringifyQuery}. Only {@link ALLOWED_QUERY_KEYS} are honored.
  */
-export declare function parseQueryParams<E = unknown>(params?: Record<string, unknown>): WireQuery<E>;
+export declare function parseQueryParams<E = unknown>(params?: unknown): WireQuery<E>;
 /**
  * Serialize a UQL query object into a percent-encoded query string where object values
  * are JSON-stringified. Symmetric counterpart of {@link parseQueryParams}.

package/dist/http/query.js

@@ -4,7 +4,7 @@ import { QUERY_BOOLEAN_CLAUSES, QUERY_NUMBER_CLAUSES, QUERY_OBJECT_CLAUSES, QUER
 // with it, in the browser bundle, which is on a size budget
 import { RAW_VALUE } from '../type/queryRaw.js';
 // the specific util module, not the barrel, so the browser bundle does not pull in entity metadata
-import { getKeys, isWhereMap } from '../util/object.util.js';
+import { getKeys, isRecord, isWhereMap } from '../util/object.util.js';
 // the error class alone, from its own leaf module: `queryError.ts` carries every driver's code map
 import { UqlUsageError } from '../util/uqlError.js';
 /**
@@ -30,10 +30,13 @@ const ALLOWED_QUERY_KEYS = new Set([
  */
 const REJECTED_QUERY_KEYS = new Set(['$lock']);
 /**
- * Parse raw query-string entries (with JSON-stringified values) into a UQL query object.
- * Symmetric counterpart of {@link stringifyQuery}. Only {@link ALLOWED_QUERY_KEYS} are honored.
+ * Parse raw query-string entries (with JSON-stringified values), or a `QUERY` body, into a UQL query
+ * object. Symmetric counterpart of {@link stringifyQuery}. Only {@link ALLOWED_QUERY_KEYS} are honored.
  */
 export function parseQueryParams(params = {}) {
+    if (!isRecord(params)) {
+        throw new UqlUsageError('the query must be a JSON object');
+    }
     const query = {};
     for (const key of getKeys(params)) {
         if (REJECTED_QUERY_KEYS.has(key)) {

package/dist/maria/mariadbQuerierPool.js

@@ -9,8 +9,10 @@ export class MariadbQuerierPool extends AbstractSqlQuerierPool {
     constructor(opts, extra) {
         super(new MariaDialect(dialectOptionsFrom(extra)), extra);
         // BIGINT stays the driver's `bigint`, which `MariadbQuerier` decodes by the rule every driver here
-        // shares (`decodeWideNumber`) - not `bigIntAsNumber`, which rounds past 2^53 without a word.
-        this.pool = createPool(opts);
+        // shares (`decodeWideNumber`) - not `bigIntAsNumber`, which rounds past 2^53 without a word. A date
+        // reads as its UTC text, which hydration decodes, since the connector would take it for local time
+        // whatever `timezone` says; that only sets the session's zone, UTC, so `NOW()` agrees.
+        this.pool = createPool({ timezone: 'Z', dateStrings: true, ...opts });
         // `mariadb` fires 'error' at runtime without declaring it, hence the cast; this makes it visible.
         attachPoolErrorHandler(this.pool, 'Idle MariaDB pool connection encountered an error', extra?.logger);
     }

package/dist/migrate/builder/expressions.d.ts

@@ -13,6 +13,8 @@ export type DialectDefaults = {
     readonly expressions: SqlExpressionMap;
     /** Column types whose `DEFAULT` this engine takes only as a parenthesized expression. */
     readonly wrapTypes?: RegExp;
+    /** Column types whose `CURRENT_TIMESTAMP` default must repeat their precision, captured by the pattern. */
+    readonly preciseTypes?: RegExp;
 };
 /**
  * Looked up by name rather than carried on the dialect, which keeps DDL data out of the query

package/dist/migrate/builder/expressions.js

@@ -15,6 +15,8 @@ const MYSQL = {
 };
 /** MySQL 8.0.13+ rejects `DEFAULT 'x'` on these but accepts `DEFAULT ('x')`, whatever the value. */
 const MYSQL_LARGE_TYPES = /^\s*(TINY|MEDIUM|LONG)?(TEXT|BLOB)|^\s*(JSON|GEOMETRY)\b/i;
+/** A `DATETIME(3)` or `TIMESTAMP(3)`, whose fractional-second precision is captured. */
+const MYSQL_PRECISE_TYPES = /^\s*(?:DATETIME|TIMESTAMP)\((\d)\)/i;
 /**
  * Looked up by name rather than carried on the dialect, which keeps DDL data out of the query
  * bundle - the same split that keeps `CANONICAL_TO_SQL` in `schema/canonicalType.ts`. `uuidv7()` is
@@ -24,8 +26,12 @@ const MYSQL_LARGE_TYPES = /^\s*(TINY|MEDIUM|LONG)?(TEXT|BLOB)|^\s*(JSON|GEOMETRY
 export const DIALECT_DEFAULTS = {
     postgres: { expressions: { ...PG, uuidv7: 'uuidv7()' } },
     cockroachdb: { expressions: PG },
-    mysql: { expressions: MYSQL, wrapTypes: MYSQL_LARGE_TYPES },
-    mariadb: { expressions: { ...MYSQL, uuidv7: 'UUID_v7()' }, wrapTypes: MYSQL_LARGE_TYPES },
+    mysql: { expressions: MYSQL, wrapTypes: MYSQL_LARGE_TYPES, preciseTypes: MYSQL_PRECISE_TYPES },
+    mariadb: {
+        expressions: { ...MYSQL, uuidv7: 'UUID_v7()' },
+        wrapTypes: MYSQL_LARGE_TYPES,
+        preciseTypes: MYSQL_PRECISE_TYPES,
+    },
     sqlite: { expressions: ANSI },
     // `SYSUTCDATETIME()` over `CURRENT_TIMESTAMP`, which is local time in the server's zone. No
     // `uuidv7`: `NEWSEQUENTIALID()` is an ordered v4 GUID, so it carries no readable timestamp and
@@ -80,7 +86,7 @@ export const expr = {
  * the result needs wrapping, which MySQL demands on its large types whatever the value.
  */
 export function formatDefaultValue(value, dialect, columnType) {
-    const sql = defaultLiteral(value, dialect);
+    const sql = defaultLiteral(value, dialect, columnType);
     const { wrapTypes } = DIALECT_DEFAULTS[dialect.dialectName];
     return columnType !== undefined && wrapTypes?.test(columnType) ? `(${sql})` : sql;
 }
@@ -114,23 +120,26 @@ export function sameDefault(desired, current, dialect) {
  * cannot serve stay here: a boolean is `1` where booleans are integers, and a plain object or array
  * is JSON rather than the throw and the IN-list `escape` gives them.
  */
-function defaultLiteral(value, dialect) {
+function defaultLiteral(value, dialect, columnType) {
     if (value === undefined || value === null) {
         return 'NULL';
     }
     if (SqlExpression.isExpression(value)) {
-        return expressionSql(value, dialect);
+        return expressionSql(value, dialect, columnType);
     }
     if (typeof value === 'boolean') {
         return dialect.booleanLiteral === 'native' ? (value ? 'TRUE' : 'FALSE') : value ? '1' : '0';
     }
     return dialect.escape(typeof value === 'object' && !(value instanceof Date) ? JSON.stringify(value) : value);
 }
-function expressionSql(expression, dialect) {
-    const { expressions } = DIALECT_DEFAULTS[dialect.dialectName];
-    const sql = expression.kind === 'raw' ? expression.sql : expressions[expression.kind];
+function expressionSql(expression, dialect, columnType) {
+    const { expressions, preciseTypes } = DIALECT_DEFAULTS[dialect.dialectName];
+    const raw = expression.kind === 'raw';
+    const sql = raw ? expression.sql : expressions[expression.kind];
     if (sql == null) {
         throw new UqlUsageError(`${dialect.dialectName} has no '${expression.kind}' default; pass expr.raw(...) with SQL this engine accepts`);
     }
-    return sql;
+    // A raw default is the caller's SQL, never rewritten.
+    const precision = raw || columnType === undefined ? undefined : preciseTypes?.exec(columnType)?.[1];
+    return precision === undefined ? sql : sql.replaceAll('CURRENT_TIMESTAMP', `CURRENT_TIMESTAMP(${precision})`);
 }

package/dist/migrate/builder/tableBuilder.js

@@ -144,7 +144,7 @@ export class TableBuilder {
         return this.timestampNow('updatedAt');
     }
     timestampNow(name) {
-        return this.add(name, { category: 'timestamp' }, { defaultValue: expr.now() });
+        return this.timestamptz(name, { defaultValue: expr.now() });
     }
     timestamps() {
         this.createdAt();

package/dist/migrate/generator/mongoSchemaGenerator.d.ts

@@ -33,7 +33,7 @@ export declare class MongoSchemaGenerator extends MongoDialect implements Schema
     generateDropTable(tableName: string): string;
     /** A collection's indexes: each dropped, then each created, an alter as both. */
     generateAlterTable(diff: SchemaDiff): string[];
-    /** MongoDB has no triggers, and a write to an entity declaring one is refused, so there is none to reconcile. */
+    /** MongoDB runs no trigger within a write, and a write to an entity declaring one is refused, so there is none to reconcile. */
     generateTriggers(): string[];
     generateTriggersDown(): string[];
     generateTriggerDrops(): string[];

package/dist/migrate/generator/mongoSchemaGenerator.js

@@ -115,7 +115,7 @@ export class MongoSchemaGenerator extends MongoDialect {
             ...sides(diff.indexes, 'to').map((index) => this.generateCreateIndex(diff.tableName, index)),
         ];
     }
-    /** MongoDB has no triggers, and a write to an entity declaring one is refused, so there is none to reconcile. */
+    /** MongoDB runs no trigger within a write, and a write to an entity declaring one is refused, so there is none to reconcile. */
     generateTriggers() {
         return [];
     }

package/dist/migrate/introspection/mongoIntrospector.d.ts

@@ -10,7 +10,7 @@ export declare class MongoSchemaIntrospector implements SchemaIntrospector {
     /** `listIndexes` reports keys, uniqueness and text weights; a `partialFilterExpression` is no SQL predicate. */
     readonly indexFacets: ReadonlySet<IndexFacet>;
     constructor(pool: QuerierPool);
-    /** MongoDB has no triggers, so none is ever installed. */
+    /** MongoDB runs no trigger within a write, so uql installs none. */
     ownedTriggers(): Promise<InstalledTriggers>;
     introspect(tables?: readonly string[]): Promise<SchemaAST>;
     getTableSchema(tableName: string): Promise<TableSchema | undefined>;

package/dist/migrate/introspection/mongoIntrospector.js

@@ -15,7 +15,7 @@ export class MongoSchemaIntrospector {
     constructor(pool) {
         this.pool = pool;
     }
-    /** MongoDB has no triggers, so none is ever installed. */
+    /** MongoDB runs no trigger within a write, so uql installs none. */
     async ownedTriggers() {
         return new Map();
     }

package/dist/migrate/introspection/mssqlIntrospector.js

@@ -1,3 +1,4 @@
+import { defaultTimestampPrecision } from '../../schema/canonicalType.js';
 import { AbstractSqlSchemaIntrospector, } from './abstractSqlSchemaIntrospector.js';
 /**
  * SQL Server schema introspector.
@@ -137,7 +138,7 @@ export class MsSqlSchemaIntrospector extends AbstractSqlSchemaIntrospector {
             const bytes = this.toNumber(row.max_length);
             return {
                 name: row.column_name,
-                type: bytes === -1 && CHARACTER_TYPES.has(type) ? `${type}(MAX)` : type,
+                type: spelledType(type, bytes, this.toNumber(row.numeric_scale)),
                 nullable: Boolean(row.is_nullable),
                 defaultValue: this.parseDefaultValue(row.column_default),
                 isAutoIncrement: Boolean(row.is_identity),
@@ -183,6 +184,17 @@ export class MsSqlSchemaIntrospector extends AbstractSqlSchemaIntrospector {
 /** The types whose `max_length` is a width rather than a fixed storage size. */
 const CHARACTER_TYPES = new Set(['CHAR', 'NCHAR', 'VARCHAR', 'NVARCHAR', 'BINARY', 'VARBINARY']);
 const NUMERIC_TYPES = new Set(['DECIMAL', 'NUMERIC']);
+/** `(MAX)` on an unbounded character type, and a timestamp's fractional digits where not the engine's default. */
+function spelledType(type, bytes, scale) {
+    if (bytes === -1 && CHARACTER_TYPES.has(type)) {
+        return `${type}(MAX)`;
+    }
+    return (type === 'DATETIME2' || type === 'DATETIMEOFFSET') &&
+        scale !== undefined &&
+        scale !== defaultTimestampPrecision('mssql')
+        ? `${type}(${scale})`
+        : type;
+}
 /**
  * A column's declared width from `max_length`, which is bytes: an `N` type holds two a character, a
  * `VECTOR` is an 8-byte header and four a dimension, and `MAX` is `-1`. Read as bytes, every Unicode

package/dist/migrate/introspection/mysqlIntrospector.d.ts

@@ -29,6 +29,7 @@ export declare class MysqlSchemaIntrospector extends AbstractSqlSchemaIntrospect
 }
 type MysqlColumnRow = {
     column_name: string;
+    data_type: string;
     column_type: string;
     is_nullable: string;
     column_default: string | null;
@@ -36,6 +37,7 @@ type MysqlColumnRow = {
     extra: string;
     character_maximum_length: number | bigint | null;
     numeric_precision: number | bigint | null;
+    datetime_precision: number | bigint | null;
     numeric_scale: number | null;
     column_comment: string | null;
     generated_as: string | null;

package/dist/migrate/introspection/mysqlIntrospector.js

@@ -47,6 +47,7 @@ export class MysqlSchemaIntrospector extends AbstractSqlSchemaIntrospector {
         CHARACTER_MAXIMUM_LENGTH as character_maximum_length,
         NUMERIC_PRECISION as numeric_precision,
         NUMERIC_SCALE as numeric_scale,
+        DATETIME_PRECISION as datetime_precision,
         COLUMN_KEY as column_key,
         EXTRA as extra,
         CASE WHEN EXTRA LIKE '%STORED GENERATED%' THEN GENERATION_EXPRESSION END as generated_as,
@@ -113,7 +114,8 @@ export class MysqlSchemaIntrospector extends AbstractSqlSchemaIntrospector {
             isUnique: row.column_key === 'UNI',
             // A `VECTOR`'s is its bytes, four a dimension, which `column_type` already states as dimensions.
             length: /^vector/i.test(row.column_type) ? undefined : this.toNumber(row.character_maximum_length),
-            precision: this.toNumber(row.numeric_precision),
+            // A timestamp's fractional digits, stated even when 0, which uql's own unstated `DATETIME(3)` is not.
+            precision: this.toNumber(TIMESTAMP_TYPES.has(row.data_type) ? row.datetime_precision : row.numeric_precision),
             scale: this.toNumber(row.numeric_scale),
             comment: row.column_comment || undefined,
             generatedAs: row.generated_as ?? undefined,
@@ -146,7 +148,8 @@ export class MysqlSchemaIntrospector extends AbstractSqlSchemaIntrospector {
         if (normalized === 'NULL') {
             return null;
         }
-        if (normalized === 'CURRENT_TIMESTAMP' || normalized === 'CURRENT_TIMESTAMP()') {
+        // Whatever precision it repeats from its column, which the column's own type already states.
+        if (/^CURRENT_TIMESTAMP(?:\(\d?\))?$/.test(normalized)) {
             return 'CURRENT_TIMESTAMP';
         }
         if (/^-?\d+(\.\d+)?$/.test(defaultValue)) {
@@ -158,6 +161,7 @@ export class MysqlSchemaIntrospector extends AbstractSqlSchemaIntrospector {
         return quoted ? unescapeMysqlString(quoted[1]) : literal;
     }
 }
+const TIMESTAMP_TYPES = new Set(['datetime', 'timestamp']);
 /**
  * MariaDB reads out of the same `information_schema` as MySQL, save for one column type it does not
  * have: `JSON` there is an alias for `LONGTEXT` plus a `json_valid()` check constraint named after

package/dist/migrate/introspection/postgresIntrospector.js

@@ -75,7 +75,7 @@ export class PostgresSchemaIntrospector extends AbstractSqlSchemaIntrospector {
         c.is_identity,
         c.identity_generation,
         CASE WHEN a.attgenerated = 's' THEN c.generation_expression END AS generated_as,
-        CASE WHEN c.data_type IN ('USER-DEFINED', 'vector') AND a.atttypmod > -1
+        CASE WHEN (c.data_type IN ('USER-DEFINED', 'vector') OR c.data_type LIKE 'timestamp%') AND a.atttypmod > -1
           THEN format_type(a.atttypid, a.atttypmod) END AS formatted_type,
         EXISTS (
           SELECT 1 FROM information_schema.table_constraints tc

package/dist/migrate/storage/databaseStorage.js

@@ -32,7 +32,7 @@ export class DatabaseMigrationStorage {
     async createTableIfNotExists(querier) {
         const table = new TableBuilder(this.tableName);
         table.string('name', { length: 255, primaryKey: true });
-        table.timestamp('executed_at', { defaultValue: expr.now() });
+        table.timestamptz('executed_at', { defaultValue: expr.now() });
         const generator = new SqlSchemaGenerator(querier.dialect);
         for (const sql of generator.generateCreateTableFromDefinition(table.build(), { ifNotExists: true })) {
             await querier.run(sql);

package/dist/mongo/mongoDialect.js

@@ -1,12 +1,12 @@
 import { ObjectId } from 'mongodb';
 import { AbstractDialect } from '../dialect/abstractDialect.js';
 import { AGGREGATE_VALUE_ALIAS, REL_NESTED_KEY, REL_TEMP_PREFIX, SUM_COUNT_ALIAS, nullsSortField, sortAggregateField, TEXT_SCORE_ALIAS, } from '../dialect/aliases.js';
-import { betweenBounds, GROUP_OPS, groupClauses, isGroupOp, whereOperators } from '../dialect/operators.js';
+import { betweenBounds, GROUP_OPS, groupClauses, isGroupOp, LIKE_OPS, likeRegex, whereOperators, } from '../dialect/operators.js';
 import { aggregateColumnField, groupPathField, resolveGroupJoins, relationSortTerms, resolveQueryJoins, resolveSortableJoin, } from '../dialect/queryJoins.js';
 import { assertSoleId, fieldOf, getMeta, relationOf, soleIdOf } from '../entity/index.js';
 import { COUNT_RESULT_KEY } from '../type/query.js';
 import { QueryRaw } from '../type/queryRaw.js';
-import { aggregateOf, asSelectMap, assertAggregateColumns, assertNonNegativeInteger, columnFamily, countedRelations, entityName, fieldUpdateOf, fillOnFields, filterFieldKeys, findVectorIndex, findVectorSort, getKeys, getRelationRequestSummary, hasKeys, isFieldUpdateOp, isJsonObject, isJsonUpdateOp, isOperatorMap, isOperatorObject, isRecord, isVectorSearch, normalizeScalarFieldSelection, parentJoins, parseGroupMap, parseRelationAtKey, parseRelationSize, rankedTextSearch, someKey, targetKeyColumns, textSortOf, vectorDistanceOf, } from '../util/index.js';
+import { aggregateOf, isSelectList, assertAggregateColumns, assertNonNegativeInteger, columnFamily, countedRelations, entityName, fieldUpdateOf, fillOnFields, filterFieldKeys, findVectorIndex, findVectorSort, getKeys, getRelationRequestSummary, hasKeys, isFieldUpdateOp, isJsonObject, isJsonUpdateOp, isOperatorMap, isOperatorObject, isRecord, isVectorSearch, normalizeScalarFieldSelection, parentJoins, parseGroupMap, parseRelationAtKey, parseRelationSize, rankedTextSearch, someKey, targetKeyColumns, textSortOf, vectorDistanceOf, } from '../util/index.js';
 import { UqlUsageError } from '../util/uqlError.js';
 import { decodeBigIntsExcept } from '../util/wideNumber.js';
 import { textLanguage } from './textLanguage.js';
@@ -71,17 +71,6 @@ function compareCount(count, size) {
     }
     return comparisons.length === 1 ? comparisons[0] : { $and: comparisons };
 }
-/** String operators -> { pattern: (v) => regex, caseInsensitive } */
-const REGEX_OP_MAP = new Map([
-    ['$startsWith', { wrap: (v) => `^${v}`, ci: false }],
-    ['$istartsWith', { wrap: (v) => `^${v}`, ci: true }],
-    ['$endsWith', { wrap: (v) => `${v}$`, ci: false }],
-    ['$iendsWith', { wrap: (v) => `${v}$`, ci: true }],
-    ['$includes', { wrap: (v) => String(v), ci: false }],
-    ['$iincludes', { wrap: (v) => String(v), ci: true }],
-    ['$like', { wrap: (v) => String(v).replace(/%/g, '.*').replace(/_/g, '.'), ci: false }],
-    ['$ilike', { wrap: (v) => String(v).replace(/%/g, '.*').replace(/_/g, '.'), ci: true }],
-]);
 /** MongoDB native operators - pass through as-is. */
 const NATIVE_OPS = new Set([
     '$all',
@@ -361,11 +350,11 @@ export class MongoDialect extends AbstractDialect {
                 result[op] = val;
                 continue;
             }
-            // String/pattern -> regex operators (8 variants including $like/$ilike)
-            const regexEntry = REGEX_OP_MAP.get(op);
-            if (regexEntry) {
-                result['$regex'] = regexEntry.wrap(val);
-                if (regexEntry.ci)
+            // The `$like` family, as the regex matching what its `LIKE` pattern matches on SQL.
+            const like = LIKE_OPS.get(op);
+            if (like) {
+                result['$regex'] = likeRegex(like.pattern(String(val)));
+                if (like.insensitive)
                     result['$options'] = 'i';
                 continue;
             }
@@ -429,17 +418,16 @@ export class MongoDialect extends AbstractDialect {
         if (!select && !exclude) {
             return {};
         }
-        if (Array.isArray(select)) {
+        if (isSelectList(select)) {
             throw new UqlUsageError('raw $select is not supported on MongoDB');
         }
-        const selectMap = asSelectMap(select);
         // Projected by column, not by field key; `normalizeId` maps them back on the way out.
-        const projection = normalizeScalarFieldSelection(meta, selectMap, exclude).reduce((acc, key) => {
+        const projection = normalizeScalarFieldSelection(meta, select, exclude).reduce((acc, key) => {
             // A computed field writing SQL leaves the document nothing to project: refused asked for by
             // name, skipped swept in with the rest. A relation aggregate is on it by now, like any column.
             const field = meta.fields[key];
             if (field?.computed && !aggregateOf(field)) {
-                if (selectMap && key in selectMap) {
+                if (select && key in select) {
                     assertReadable(meta, key);
                 }
                 return acc;
@@ -450,7 +438,7 @@ export class MongoDialect extends AbstractDialect {
         // MongoDB returns `_id` unless it is explicitly excluded, so subtracting the primary key needs
         // `_id: 0` - the one inclusion/exclusion mix MongoDB allows - or `$exclude: { id: true }` would
         // have no effect at all.
-        if (this.subtractsKey(soleIdOf(meta, 'MongoDB'), selectMap, exclude)) {
+        if (this.subtractsKey(soleIdOf(meta, 'MongoDB'), select, exclude)) {
             projection[ID_KEY] = 0;
         }
         return projection;
@@ -565,7 +553,7 @@ export class MongoDialect extends AbstractDialect {
     /** The relation aggregates a read projects or sorts by; its `$where` puts its own on the document. */
     aggregateKeys(entity, q) {
         const meta = getMeta(entity);
-        const projected = normalizeScalarFieldSelection(meta, asSelectMap(q.$select), q.$exclude);
+        const projected = normalizeScalarFieldSelection(meta, isSelectList(q.$select) ? undefined : q.$select, q.$exclude);
         return [...projected, ...Object.keys(q.$sort ?? {})].filter((key) => aggregateOf(meta.fields[key]));
     }
     /**

package/dist/mongo/mongodbQuerier.js

@@ -13,12 +13,13 @@ function asksForNoRows(q) {
     return q.$limit === 0;
 }
 /**
- * MongoDB has no triggers, so a write to an entity declaring one - a stamp included - would skip it
- * silently. Refused instead, as a query naming SQL is.
+ * MongoDB runs no trigger within a write (Atlas Database Triggers fire after the commit), so a write to
+ * an entity declaring one - a stamp included - would skip it silently. Refused instead, as a query naming
+ * SQL is. The why, in `architecture/triggers.md`.
  */
 function refuseTriggers(entity) {
     if (hasTriggers(getMeta(entity))) {
-        throw new UqlUsageError(`'${entity.name}' declares triggers, which MongoDB has none of: a write here would skip them. ` +
+        throw new UqlUsageError(`'${entity.name}' declares triggers, which MongoDB cannot run within a write: a write here would skip them. ` +
             'Keep the entity on a SQL engine, or drop its triggers and stamps.');
     }
 }

package/dist/mssql/mssqlQuerier.d.ts

@@ -1,3 +1,4 @@
+import { DateTime2 } from 'mssql';
 import { AbstractPoolQuerier } from '../querier/abstractPoolQuerier.js';
 import type { QueryUpdateResult, RawRow, TransactionOptions } from '../type/index.js';
 /** What `tedious` hands back for one statement, whichever shape it took. */
@@ -17,6 +18,7 @@ type MsSqlRowStream = AsyncIterable<unknown> & {
 /** The part of an `mssql` `Request` a querier drives. */
 type MsSqlRequest = {
     input(name: string, value: unknown): unknown;
+    input(name: string, type: typeof DateTime2, value: unknown): unknown;
     query(command: string): Promise<MsSqlResult>;
     toReadableStream(): MsSqlRowStream;
     cancel(): unknown;

package/dist/mssql/mssqlQuerier.js

@@ -1,4 +1,4 @@
-import { ISOLATION_LEVEL } from 'mssql';
+import { DateTime2, ISOLATION_LEVEL } from 'mssql';
 import { AbstractPoolQuerier } from '../querier/abstractPoolQuerier.js';
 import { decodeWireTypes } from './mssqlWireTypes.js';
 /**
@@ -9,13 +9,16 @@ import { decodeWireTypes } from './mssqlWireTypes.js';
 export class MsSqlQuerier extends AbstractPoolQuerier {
     #transaction;
     /**
-     * Values bind by name, `@p1` upward, matching {@link MsSqlDialect.placeholder}. `tedious` infers
-     * a type from the JS value, which is why a `Date` and a `Uint8Array` reach it unconverted - the
-     * inference is right for both, and wrong only for a bare `null`, which it calls `NVarChar`.
+     * Values bind by name, `@p1` upward, matching {@link MsSqlDialect.placeholder}. `mssql` infers a type
+     * from the JS value, right for a `Uint8Array` and harmlessly wrong for a bare `null` (`NVarChar`), but
+     * a `Date` it binds as the legacy `DATETIME`, whose 1/300 s steps no `DATETIME2` column compares equal to.
      */
     #request(values) {
         const request = this.#transaction ? this.#transaction.request() : this.getConn().request();
-        values?.forEach((value, index) => request.input(`p${index + 1}`, value));
+        values?.forEach((value, index) => {
+            const name = `p${index + 1}`;
+            return value instanceof Date ? request.input(name, DateTime2, value) : request.input(name, value);
+        });
         return request;
     }
     async internalAll(query, values) {

package/dist/mysql/mysql2QuerierPool.d.ts

@@ -4,6 +4,7 @@ import type { ExtraOptions } from '../type/index.js';
 import { MySql2Querier } from './mysql2Querier.js';
 import { MySqlDialect } from './mysqlDialect.js';
 export declare class MySql2QuerierPool extends AbstractSqlQuerierPool<MySql2Querier, MySqlDialect> {
+    #private;
     readonly pool: Pool;
     constructor(opts: PoolOptions, extra?: ExtraOptions);
     getQuerier(): Promise<MySql2Querier>;