uql-orm 0.51.0 → 0.52.0

package/dist/migrate/introspection/mssqlIntrospector.js

@@ -0,0 +1,198 @@
+import { AbstractSqlSchemaIntrospector } from './abstractSqlSchemaIntrospector.js';
+/**
+ * SQL Server schema introspector.
+ *
+ * `INFORMATION_SCHEMA` answers columns and foreign keys, but not indexes: it has no view for them at
+ * all, and its `CONSTRAINT_COLUMN_USAGE` conflates a unique index with a unique constraint. Those
+ * come from `sys.indexes` instead, which is also the only place the filtered-index predicate and the
+ * included columns are readable.
+ */
+export class MsSqlSchemaIntrospector extends AbstractSqlSchemaIntrospector {
+    defaultSchemaExpr = 'SCHEMA_NAME()';
+    getTableNamesQuery() {
+        return /*sql*/ `
+      SELECT TABLE_NAME as table_name
+      FROM INFORMATION_SCHEMA.TABLES
+      WHERE TABLE_SCHEMA = ${this.schemaExpr}
+        AND TABLE_TYPE = 'BASE TABLE'
+      ORDER BY TABLE_NAME
+    `;
+    }
+    tableExistsQuery() {
+        return /*sql*/ `
+      SELECT COUNT(*) as count
+      FROM INFORMATION_SCHEMA.TABLES
+      WHERE TABLE_SCHEMA = ${this.schemaExpr}
+        AND TABLE_NAME = @p1
+    `;
+    }
+    parseTableExistsResult(results) {
+        return (this.toNumber(results[0]?.count) ?? 0) > 0;
+    }
+    /**
+     * `is_identity` and the default come from `sys`, not `INFORMATION_SCHEMA`: the latter has no
+     * identity flag, and reports a default already wrapped in the parentheses the engine reprints it
+     * with, which is the same text either way but only nameable as a constraint through `sys`.
+     */
+    getColumnsQuery(_tableName) {
+        return /*sql*/ `
+      SELECT
+        c.name as column_name,
+        t.name as data_type,
+        c.max_length as max_length,
+        c.precision as numeric_precision,
+        c.scale as numeric_scale,
+        c.is_nullable as is_nullable,
+        c.is_identity as is_identity,
+        d.definition as column_default
+      FROM sys.columns c
+      JOIN sys.objects o ON o.object_id = c.object_id
+      JOIN sys.schemas s ON s.schema_id = o.schema_id
+      JOIN sys.types t ON t.user_type_id = c.user_type_id
+      LEFT JOIN sys.default_constraints d ON d.object_id = c.default_object_id
+      WHERE s.name = ${this.schemaExpr} AND o.name = @p1
+      ORDER BY c.column_id
+    `;
+    }
+    /** `is_primary_key` is excluded: the key is read separately, the way every other engine reads it. */
+    getIndexesQuery(_tableName) {
+        return /*sql*/ `
+      SELECT
+        i.name as index_name,
+        i.is_unique as is_unique,
+        STRING_AGG(c.name, ',') WITHIN GROUP (ORDER BY ic.key_ordinal) as columns
+      FROM sys.indexes i
+      JOIN sys.objects o ON o.object_id = i.object_id
+      JOIN sys.schemas s ON s.schema_id = o.schema_id
+      JOIN sys.index_columns ic ON ic.object_id = i.object_id AND ic.index_id = i.index_id
+      JOIN sys.columns c ON c.object_id = ic.object_id AND c.column_id = ic.column_id
+      WHERE s.name = ${this.schemaExpr} AND o.name = @p1
+        AND i.is_primary_key = 0 AND i.name IS NOT NULL AND ic.is_included_column = 0
+      GROUP BY i.name, i.is_unique
+      ORDER BY i.name
+    `;
+    }
+    getForeignKeysQuery(_tableName) {
+        return /*sql*/ `
+      SELECT
+        fk.name as constraint_name,
+        STRING_AGG(pc.name, ',') WITHIN GROUP (ORDER BY fkc.constraint_column_id) as columns,
+        rt.name as referenced_table,
+        STRING_AGG(rc.name, ',') WITHIN GROUP (ORDER BY fkc.constraint_column_id) as referenced_columns,
+        fk.delete_referential_action_desc as delete_rule,
+        fk.update_referential_action_desc as update_rule
+      FROM sys.foreign_keys fk
+      JOIN sys.objects o ON o.object_id = fk.parent_object_id
+      JOIN sys.schemas s ON s.schema_id = o.schema_id
+      JOIN sys.foreign_key_columns fkc ON fkc.constraint_object_id = fk.object_id
+      JOIN sys.columns pc ON pc.object_id = fkc.parent_object_id AND pc.column_id = fkc.parent_column_id
+      JOIN sys.objects rt ON rt.object_id = fk.referenced_object_id
+      JOIN sys.columns rc ON rc.object_id = fkc.referenced_object_id AND rc.column_id = fkc.referenced_column_id
+      WHERE s.name = ${this.schemaExpr} AND o.name = @p1
+      GROUP BY fk.name, rt.name, fk.delete_referential_action_desc, fk.update_referential_action_desc
+      ORDER BY fk.name
+    `;
+    }
+    getPrimaryKeyQuery(_tableName) {
+        return /*sql*/ `
+      SELECT c.name as column_name, i.name as constraint_name
+      FROM sys.indexes i
+      JOIN sys.objects o ON o.object_id = i.object_id
+      JOIN sys.schemas s ON s.schema_id = o.schema_id
+      JOIN sys.index_columns ic ON ic.object_id = i.object_id AND ic.index_id = i.index_id
+      JOIN sys.columns c ON c.object_id = ic.object_id AND c.column_id = ic.column_id
+      WHERE s.name = ${this.schemaExpr} AND o.name = @p1 AND i.is_primary_key = 1
+      ORDER BY ic.key_ordinal
+    `;
+    }
+    /**
+     * `max_length` is in bytes, so an `NVARCHAR` column reports twice its declared length and `MAX`
+     * reports `-1`. Read as characters, every Unicode column would drift to double its width the first
+     * time it was diffed against the entity that declared it.
+     */
+    async mapColumnsResult(read, tableName, results) {
+        // One extra statement for both flags, and the reader sends it once: a column is in the key or
+        // uniquely indexed on its own, and `sys` is the only place either is readable per column.
+        const flags = await read(
+        /*sql*/ `
+      SELECT c.name as column_name, MAX(CAST(i.is_primary_key AS INT)) as is_primary_key
+      FROM sys.indexes i
+      JOIN sys.objects o ON o.object_id = i.object_id
+      JOIN sys.schemas s ON s.schema_id = o.schema_id
+      JOIN sys.index_columns ic ON ic.object_id = i.object_id AND ic.index_id = i.index_id
+      JOIN sys.columns c ON c.object_id = ic.object_id AND c.column_id = ic.column_id
+      WHERE s.name = ${this.schemaExpr} AND o.name = @p1
+        AND i.is_unique = 1 AND ic.is_included_column = 0
+        AND (SELECT COUNT(*) FROM sys.index_columns k
+             WHERE k.object_id = i.object_id AND k.index_id = i.index_id AND k.is_included_column = 0) = 1
+      GROUP BY c.name
+    `, [tableName]);
+        const unique = new Set(flags.map((row) => row.column_name));
+        const keys = new Set(flags.filter((row) => Boolean(row.is_primary_key)).map((row) => row.column_name));
+        return results.map((row) => {
+            const type = row.data_type.toUpperCase();
+            const wide = type.startsWith('N');
+            const bytes = this.toNumber(row.max_length);
+            const length = bytes === undefined || bytes < 0 || !CHARACTER_TYPES.has(type) ? undefined : wide ? bytes / 2 : bytes;
+            return {
+                name: row.column_name,
+                type: bytes === -1 && CHARACTER_TYPES.has(type) ? `${type}(MAX)` : type,
+                nullable: Boolean(row.is_nullable),
+                defaultValue: this.parseDefaultValue(row.column_default),
+                isAutoIncrement: Boolean(row.is_identity),
+                isPrimaryKey: keys.has(row.column_name),
+                isUnique: unique.has(row.column_name),
+                length,
+                precision: NUMERIC_TYPES.has(type) ? this.toNumber(row.numeric_precision) : undefined,
+                scale: NUMERIC_TYPES.has(type) ? this.toNumber(row.numeric_scale) : undefined,
+            };
+        });
+    }
+    async mapIndexesResult(_read, _tableName, results) {
+        return results.map((row) => ({
+            name: row.index_name,
+            entries: (row.columns ?? '').split(',').map((column) => ({ column })),
+            unique: Boolean(row.is_unique),
+        }));
+    }
+    async mapForeignKeysResult(_read, _tableName, results) {
+        return results.map((row) => ({
+            name: row.constraint_name,
+            columns: (row.columns || '').split(','),
+            references: { table: row.referenced_table, columns: (row.referenced_columns || '').split(',') },
+            // `sys` spells them with an underscore: `SET_NULL`, `NO_ACTION`.
+            onDelete: this.normalizeReferentialAction((row.delete_rule || '').replaceAll('_', ' ')),
+            onUpdate: this.normalizeReferentialAction((row.update_rule || '').replaceAll('_', ' ')),
+        }));
+    }
+    /**
+     * A default is stored wrapped in at least one layer of parentheses - `((0))` for a number,
+     * `(N'x')` for a string - because the engine reprints it from its own parse tree.
+     */
+    parseDefaultValue(defaultValue) {
+        if (defaultValue === null || defaultValue === undefined) {
+            return undefined;
+        }
+        let text = defaultValue.trim();
+        while (text.startsWith('(') && text.endsWith(')')) {
+            text = text.slice(1, -1).trim();
+        }
+        if (text.toUpperCase() === 'NULL') {
+            return null;
+        }
+        const unicode = text.startsWith("N'") ? text.slice(1) : text;
+        if (unicode.startsWith("'") && unicode.endsWith("'")) {
+            return unicode.slice(1, -1).replaceAll("''", "'");
+        }
+        if (/^-?\d+$/.test(text)) {
+            return Number.parseInt(text, 10);
+        }
+        if (/^-?\d+\.\d+$/.test(text)) {
+            return Number.parseFloat(text);
+        }
+        return text;
+    }
+}
+/** 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']);

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

@@ -0,0 +1,3 @@
+import type { QuerierPool, SchemaIntrospector } from '../../type/index.js';
+/** The introspector for `dialectName`, or `undefined` where the migrator has none for it. */
+export declare function introspectorFor(dialectName: string, pool: QuerierPool, schema?: string): SchemaIntrospector | undefined;

package/dist/migrate/introspection/registry.js

@@ -0,0 +1,28 @@
+import { MongoSchemaIntrospector } from './mongoIntrospector.js';
+import { MsSqlSchemaIntrospector } from './mssqlIntrospector.js';
+import { MariadbSchemaIntrospector, MysqlSchemaIntrospector } from './mysqlIntrospector.js';
+import { CockroachSchemaIntrospector, PostgresSchemaIntrospector } from './postgresIntrospector.js';
+import { SqliteSchemaIntrospector } from './sqliteIntrospector.js';
+/**
+ * Which introspector each engine gets. A table rather than a `switch` so `Migrator` names no
+ * constructor and adding an engine touches one line, not a control flow.
+ *
+ * Every entry is statically imported, so `uql-orm/migrate` still carries all of them; making the
+ * table's values dynamic imports would shrink that entry, at the cost of an async
+ * `createIntrospector` the constructor cannot await.
+ */
+const INTROSPECTORS = {
+    postgres: (pool, schema) => new PostgresSchemaIntrospector(pool, schema),
+    cockroachdb: (pool, schema) => new CockroachSchemaIntrospector(pool, schema),
+    mysql: (pool, schema) => new MysqlSchemaIntrospector(pool, schema),
+    mariadb: (pool, schema) => new MariadbSchemaIntrospector(pool, schema),
+    mssql: (pool, schema) => new MsSqlSchemaIntrospector(pool, schema),
+    // Neither has schemas to read: SQLite attaches database files and MongoDB takes its database from
+    // the connection, so both ignore the argument rather than filtering on it.
+    sqlite: (pool) => new SqliteSchemaIntrospector(pool),
+    mongodb: (pool) => new MongoSchemaIntrospector(pool),
+};
+/** The introspector for `dialectName`, or `undefined` where the migrator has none for it. */
+export function introspectorFor(dialectName, pool, schema) {
+    return INTROSPECTORS[dialectName]?.(pool, schema);
+}

package/dist/migrate/migrator.js

@@ -8,7 +8,7 @@ import { LoggerWrapper } from '../util/index.js';
 import { withQuerierForMigrations, withSqlQuerierForMigrations } from './acquireQuerierForMigrations.js';
 import { buildSqlQuerierMigrationModule, EMPTY_MANUAL_MIGRATION_DOWN_INNER, EMPTY_MANUAL_MIGRATION_UP_INNER, emitSqlRunCalls, } from './codegen/migrationFile.js';
 import { runMongoCommand } from './generator/mongoCommand.js';
-import { CockroachSchemaIntrospector, MariadbSchemaIntrospector, MongoSchemaIntrospector, MysqlSchemaIntrospector, PostgresSchemaIntrospector, SqliteSchemaIntrospector, } from './introspection/index.js';
+import { introspectorFor } from './introspection/registry.js';
 import { createSchemaGenerator } from './schemaGenerator.js';
 import { createSchemaGeneratorAsync } from './schemaGeneratorAsync.js';
 import { DatabaseMigrationStorage } from './storage/databaseStorage.js';
@@ -73,26 +73,7 @@ export class Migrator {
     }
     /** `schema` reads one namespace instead of the connection's own; see {@link BaseSqlIntrospector.schema}. */
     createIntrospector(schema) {
-        const d = this.dialectName;
-        if (!isKnownMigratorDialect(d)) {
-            return undefined;
-        }
-        switch (d) {
-            case 'postgres':
-                return new PostgresSchemaIntrospector(this.pool, schema);
-            case 'cockroachdb':
-                return new CockroachSchemaIntrospector(this.pool, schema);
-            case 'mysql':
-                return new MysqlSchemaIntrospector(this.pool, schema);
-            case 'mariadb':
-                return new MariadbSchemaIntrospector(this.pool, schema);
-            case 'sqlite':
-                return new SqliteSchemaIntrospector(this.pool);
-            case 'mongodb':
-                return new MongoSchemaIntrospector(this.pool);
-            default:
-                return undefined;
-        }
+        return introspectorFor(this.dialectName, this.pool, schema);
     }
     createGenerator() {
         if (!isKnownMigratorDialect(this.dialectName)) {

package/dist/mongo/mongoDialect.js

@@ -22,7 +22,10 @@ export const mongoDialectFeatures = {
     vectorIndexRequiresNotNull: false,
     vectorSupportsLength: false,
     supportsTimestamptz: false,
-    defaultStringAsText: false,
+    stringSizing: 'bounded-text',
+    supportsUnsigned: false,
+    multipleCascadePaths: true,
+    serverSideCursors: false,
 };
 /** What `toWireId` converts: the hex spelling of an `ObjectId`, and nothing looser. */
 const HEX_24 = /^[0-9a-f]{24}$/i;

package/dist/mssql/index.d.ts

@@ -0,0 +1,3 @@
+export * from './mssqlDialect.js';
+export * from './mssqlQuerier.js';
+export * from './mssqlQuerierPool.js';

package/dist/mssql/index.js

@@ -0,0 +1,3 @@
+export * from './mssqlDialect.js';
+export * from './mssqlQuerier.js';
+export * from './mssqlQuerierPool.js';

package/dist/mssql/mssqlDialect.d.ts

@@ -0,0 +1,144 @@
+import { MergeSqlDialect } from '../dialect/mergeSqlDialect.js';
+import type { DialectFeatures, EntityMeta, FieldOptions, InsertIdSource, Query, QueryContext, QueryOptions, QueryPager, QuerySizeComparisonOps, Type } from '../type/index.js';
+/**
+ * Microsoft SQL Server 2017 and up - the floor `STRING_AGG` sets, every other construct here being
+ * 2016 or older.
+ *
+ * Identifiers are `"`-quoted rather than bracketed: `escapeIdChar` is one character that doubles to
+ * escape itself, `"` is the ANSI spelling, and `tedious` enables `QUOTED_IDENTIFIER` by default.
+ * Brackets would buy nothing and cost the shared dialect spec, which reads that one character.
+ */
+export declare class MsSqlDialect extends MergeSqlDialect {
+    #private;
+    protected readonly featureDefaults: DialectFeatures;
+    readonly dialectName = "mssql";
+    readonly autoIncrementSuffix = "IDENTITY(1,1)";
+    readonly tableOptions = "";
+    readonly beginTransactionCommand = "BEGIN TRANSACTION";
+    readonly commitTransactionCommand = "COMMIT TRANSACTION";
+    readonly rollbackTransactionCommand = "ROLLBACK TRANSACTION";
+    /**
+     * The level rides the `BEGIN` rather than preceding it as its own statement: a `SET TRANSACTION
+     * ISOLATION LEVEL` sent on its own would go to whichever pooled connection served it, not the one
+     * the transaction opens on, and would then stick to that connection for unrelated later queries.
+     * `MsSqlQuerier` reads the level back off this command and hands it to the driver.
+     */
+    readonly isolationLevelStrategy = "inline";
+    readonly dropIndexSyntax = "on-table";
+    readonly booleanLiteral = "integer";
+    /** [The hard server limit](https://github.com/yiisoft/yii2/issues/10371), not a driver preference. */
+    readonly maxBindValues = 2100;
+    /** `OUTPUT` has no trailing form: it sits between the column list and `VALUES`. */
+    readonly returningPosition = "after-target";
+    readonly insertIdSource: InsertIdSource;
+    /** Holds the update key lock across the insert; without it two concurrent upserts of one key race. */
+    protected readonly mergeTargetHint = " WITH (HOLDLOCK)";
+    protected readonly statementTerminator = ";";
+    /**
+     * `TOP (0)`, the only way this engine says "no rows": `FETCH NEXT 0 ROWS ONLY` is rejected
+     * outright ("the number of rows provided for a FETCH clause must be greater then zero").
+     */
+    protected selectModifier<E>(q: Query<E>): string;
+    /**
+     * `TOP (0)` is the whole page when nothing is wanted: the engine refuses `TOP` alongside an
+     * `OFFSET`, and a skip into an empty result changes nothing, so no clause follows it.
+     */
+    pager(ctx: QueryContext, opts: QueryPager & {
+        $distinct?: boolean;
+    }, sorted?: boolean): void;
+    /**
+     * `SET IDENTITY_INSERT` around the insert, where the payload states a key the engine would
+     * otherwise generate: writing one is refused outright ("cannot insert explicit value for identity
+     * column ... when IDENTITY_INSERT is set to OFF") rather than ignored.
+     *
+     * Emitted only for that case, because the setting is per-session and only one table may hold it at
+     * a time, so it is turned back off in the same batch it was turned on.
+     */
+    insert<E>(ctx: QueryContext, entity: Type<E>, payload: E | E[], opts?: QueryOptions): void;
+    /** The table to toggle, or nothing when no record writes a key the engine would have generated. */
+    private identityInsertTarget;
+    /**
+     * A `DECIMAL` read back as the exact text it was written as, where the entity declared the field a
+     * `String`. `tedious` decodes the type to a JS number before anything here can see it, so the
+     * digits past 2^53 are gone at the wire unless the column is converted before it crosses - the same
+     * reason MariaDB reads a vector column through `VEC_ToText`. 41 characters covers `DECIMAL(38, s)`
+     * with room for the sign and the point.
+     */
+    protected selectFieldExpr(escapedColumn: string, field: FieldOptions): string;
+    /** Named parameters, which `tedious` binds by name rather than by position. */
+    placeholder(index: number): string;
+    /** `OUTPUT` reads the written row out of the `INSERTED` pseudo-table rather than `RETURNING` it. */
+    returningId<E>(meta: EntityMeta<E>): string;
+    protected returningIdExpression<E>(meta: EntityMeta<E>): string;
+    protected mergeReturning(expression: string): string;
+    /**
+     * A row lock is a hint on the table here, not a clause at the end of the statement, so
+     * {@link lockHint} emits it and this only keeps the guard - see the base declaration.
+     */
+    protected appendLock<E>(_ctx: QueryContext, entity: Type<E>, q: Query<E>): void;
+    protected lockHint<E>(q: Query<E>): string;
+    /**
+     * `N'...'`, always. A bare literal is `VARCHAR`, whose codepage silently destroys anything outside
+     * it, and every string column this dialect creates is `NVARCHAR`. Bound parameters need nothing -
+     * `tedious` binds a JS string as `NVarChar` already - so this reaches only inlined literals.
+     */
+    escape(value: unknown): string;
+    /**
+     * `REGEXP_LIKE` is SQL Server 2025 at database compatibility level 170; a server below that rejects
+     * it itself, neither the version nor the compatibility level being knowable here - the same terms
+     * `uuidv7()` is emitted on. It is a predicate rather than a value, so it stands alone.
+     */
+    protected regexCondition(operand: string, placeholder: string): string;
+    /** There is no `CREATE SCHEMA IF NOT EXISTS`, and `CREATE SCHEMA` has to be alone in its batch. */
+    createSchemaSql(schema: string): string;
+    /** The estimate the engine already keeps per partition, live without a stats refresh. */
+    estimatedCount<E>(ctx: QueryContext, entity: Type<E>): void;
+    protected numericCast(expr: string): string;
+    /**
+     * `JSON_VALUE` returns `NVARCHAR(4000)` and, in the lax mode that is the default, answers NULL
+     * rather than erroring for anything longer - so a long string read through it disappears without a
+     * word. `OPENJSON` has no such bound, so the path is split and its last segment matched as a key.
+     */
+    protected getJsonPathScalarExpr(escapedColumn: string, jsonPathStr: string): string;
+    /**
+     * The same read as the scalar one. `JSON_QUERY` answers NULL for anything that is not an object or
+     * an array, so it cannot serve the JSON access mode a boolean or a number operand asks for -
+     * `OPENJSON` returns both as text, and {@link jsonScalarParam} binds the operand as the matching
+     * text. An array or object comes back as its own JSON text, which is what `OPENJSON` takes next.
+     */
+    protected getJsonPathJsonbExpr(escapedColumn: string, jsonPathStr: string): string;
+    /**
+     * A value being *compared* against a JSON path, which reads back as the text `JSON_VALUE` yields:
+     * `'true'` for a boolean, `'12'` for a number. So only a boolean needs re-spelling; a number or a
+     * string already binds as the text it will be compared with.
+     *
+     * There is no "parse this text as JSON" cast to bind through the way `CAST(? AS JSON)` and
+     * `json(?)` serve the other families - `JSON_QUERY` marks text as JSON but answers NULL for a
+     * scalar - which is why reading and writing need the two different binders here.
+     */
+    protected jsonScalarParam(ctx: QueryContext, value: unknown): string;
+    /**
+     * A value being *written* to a JSON path, which takes the type the driver sent: a `BIT` becomes a
+     * JSON boolean, a number a JSON number, a string a JSON string. `normalizeValue` has already
+     * flattened a boolean to 1/0 for this engine's columns, so the cast is what restores it.
+     */
+    protected jsonWriteParam(ctx: QueryContext, value: unknown): string;
+    /** An exploded element compares as text here, so `$elemMatch` always expands per field. */
+    protected readonly jsonContainmentIsPartial = false;
+    protected jsonElemFrom(jsonField: string, _fields: readonly string[], alias: string): string;
+    /** `JSON_VALUE`'s 4000-character bound applies to an element's field, unlike a whole column. */
+    protected jsonElemRef(alias: string, field?: string): string;
+    protected jsonAll(ctx: QueryContext, jsonField: string, value: unknown): string;
+    protected jsonSize(ctx: QueryContext, jsonField: string, value: number | QuerySizeComparisonOps): string;
+    /** `JSON_MODIFY` takes one path per call, so several keys chain into one expression. */
+    protected jsonSet(ctx: QueryContext, expr: string, set: Record<string, unknown>, _field?: FieldOptions): string;
+    /** `'append '` prefixing the path extends the array there, creating it where there is none. */
+    protected jsonPush(ctx: QueryContext, expr: string, push: Record<string, unknown>): string;
+    /** Assigning NULL to a path deletes it in lax mode, which is the default. */
+    protected jsonUnset(_ctx: QueryContext, expr: string, unset: readonly string[]): string;
+    /**
+     * The surviving elements are re-aggregated into an array and written back whole - there is no
+     * remove-by-value. `JSON_QUERY` is what marks the rebuilt text as JSON rather than a string.
+     */
+    protected jsonPullKey(ctx: QueryContext, expr: string, escapedCol: string, key: string, value: unknown): string;
+}