uql-orm 0.55.0 → 0.56.0

package/dist/querier/abstractSqlQuerier.js

@@ -1,7 +1,7 @@
 import { COUNT_ALIAS, TOTAL_ALIAS } from '../dialect/aliases.js';
 import { decodeColumn } from '../dialect/hydrateColumn.js';
 import { getMeta, idOf, namesKey } from '../entity/index.js';
-import { buildUpdateResult, cascadesOnDelete, clone, getInsertFieldKeys, insertShapeOf, getRelationRequestSummary, hasKeys, idOnlyQuery, isAutoIncrement, isPagedQuery, obtainAttrsPaths, throwNoPendingTransaction, throwPendingTransaction, unflatObject, unflatObjects, whereIds, withoutSoftDeleteFilter, } from '../util/index.js';
+import { buildUpdateResult, cascadesOnDelete, clone, getInsertFieldKeys, insertShapeOf, getRelationRequestSummary, idOnlyQuery, isAutoIncrement, isPagedQuery, obtainAttrsPaths, throwNoPendingTransaction, throwPendingTransaction, unflatObject, unflatObjects, whereIds, withoutSoftDeleteFilter, } from '../util/index.js';
 import { AbstractQuerier } from './abstractQuerier.js';
 import { enrichError } from './queryError.js';
 /**
@@ -223,8 +223,11 @@ export class AbstractSqlQuerier extends AbstractQuerier {
         return this.all(ctx.sql, ctx.values);
     }
     async hydrateRows(entity, q, rows) {
-        const founds = unflatObjects(rows).map((row) => this.hydrateFields(entity, row));
-        await this.fillToManyRelations(entity, founds, q.$populate);
+        const founds = unflatObjects(rows);
+        this.hydrateAll(entity, founds);
+        if (q.$populate) {
+            await this.fillToManyRelations(entity, founds, q.$populate);
+        }
         return founds;
     }
     async *internalFindManyStream(entity, q, opts) {
@@ -245,11 +248,14 @@ export class AbstractSqlQuerier extends AbstractQuerier {
         // context holds was normalized as it was bound.
         const ctx = this.dialect.createContext();
         this.dialect.find(ctx, entity, q, opts);
+        const fields = this.dialect.hydratableFields(entity);
         let attrsPaths;
         try {
             for await (const row of this.internalStream(ctx.sql, ctx.values)) {
                 attrsPaths ??= obtainAttrsPaths(row);
-                yield this.hydrateFields(entity, unflatObject(row, attrsPaths));
+                const found = unflatObject(row, attrsPaths);
+                this.hydrateFields(meta, fields, found);
+                yield found;
             }
         }
         catch (err) {
@@ -265,33 +271,35 @@ export class AbstractSqlQuerier extends AbstractQuerier {
         yield* await this.internalAll(query, values);
     }
     /**
-     * Turn what a driver returned back into the types the entity declares, for the row and everything
-     * populated under it. Which columns, and as what, is `hydratableFields`; the per-cell decode is
-     * `decodeColumn`. Both live with the dialect, because a `sparsevec` is only sparse on Postgres.
-     *
-     * `visited` guards a populated graph that points back at itself, and makes a node two paths reach
-     * decode once. Only a relation can lead the walk back somewhere it has been, so an entity that
-     * declares none skips the guard rather than allocating a set per row to hold a single object -
-     * which cost more than the decoding it guards, on a flat read.
+     * Turn what a driver returned back into the types the entity declares, for every row and everything
+     * populated under them. Which columns, and as what, is `hydratableFields`, resolved once for all the
+     * rows; the per-cell decode is `decodeColumn`. Both live with the dialect, because a `sparsevec` is
+     * only sparse on Postgres.
+     */
+    hydrateAll(entity, dtos, visited) {
+        const meta = getMeta(entity);
+        const fields = this.dialect.hydratableFields(entity);
+        for (const dto of dtos) {
+            this.hydrateFields(meta, fields, dto, visited);
+        }
+    }
+    /**
+     * One row of {@link hydrateAll}. `visited` guards a populated graph that points back at itself, and
+     * makes a node two paths reach decode once. Only a populated relation can lead the walk back, so the
+     * guard is created at the first one a row carries: rows that populated nothing never allocate one.
      */
-    hydrateFields(entity, dto, visited) {
+    hydrateFields(meta, fields, dto, visited) {
         if (!dto || typeof dto !== 'object' || visited?.has(dto)) {
-            return dto;
+            return;
         }
-        const meta = getMeta(entity);
+        visited?.add(dto);
         const row = dto;
-        for (const [key, kind] of this.dialect.hydratableFields(entity)) {
+        for (const [key, kind] of fields) {
             const value = row[key];
             if (value != null) {
                 row[key] = decodeColumn(value, kind);
             }
         }
-        // Allocated only where the walk can continue: an entity declaring no relation cannot lead back
-        // to a node already decoded, and the loop below is a no-op for it anyway.
-        if (hasKeys(meta.relations)) {
-            visited ??= new WeakSet();
-        }
-        visited?.add(dto);
         // The value is read before the relation's target is resolved: a query that populated nothing
         // still walks every relation the entity declares, and `rel.entity()` is a call per row per
         // relation that only the populated ones need.
@@ -302,16 +310,14 @@ export class AbstractSqlQuerier extends AbstractQuerier {
             const rel = meta.relations[key];
             if (!rel)
                 continue;
+            visited ??= new WeakSet([dto]);
             const relEntity = rel.entity();
             if (Array.isArray(value)) {
-                for (const it of value) {
-                    this.hydrateFields(relEntity, it, visited);
-                }
+                this.hydrateAll(relEntity, value, visited);
                 continue;
             }
-            this.hydrateFields(relEntity, value, visited);
+            this.hydrateFields(getMeta(relEntity), this.dialect.hydratableFields(relEntity), value, visited);
         }
-        return dto;
     }
     /**
      * Runs a statement whose one row carries a {@link COUNT_ALIAS} column. `Number` because `COUNT(*)` is BIGINT and

package/dist/schema/canonicalType.js

@@ -492,7 +492,5 @@ export function canonicalToColumnType(type) {
             return 'halfvec';
         case 'sparsevec':
             return 'sparsevec';
-        default:
-            return 'varchar';
     }
 }

package/dist/schema/dependencyGraph.js

@@ -38,11 +38,9 @@ export function findCycles(nodes, dependenciesOf) {
     const visited = new Set();
     const onPath = new Set();
     const visit = (node, path) => {
+        // A node on the walk was handed down in `path` too, so the cycle closes where it first appears.
         if (onPath.has(node)) {
-            const start = path.indexOf(node);
-            if (start !== -1) {
-                cycles.push(path.slice(start));
-            }
+            cycles.push(path.slice(path.indexOf(node)));
             return;
         }
         if (visited.has(node)) {

package/dist/schema/indexDifferences.js

@@ -64,8 +64,8 @@ export function describeIndexDifferences(source, target, facets) {
             differences.push(`columns: (${targetColumns}) → (${sourceColumns})`);
         }
     }
-    if ((source.unique ?? false) !== (target.unique ?? false)) {
-        differences.push(`unique: ${target.unique ?? false} → ${source.unique ?? false}`);
+    if (source.unique !== target.unique) {
+        differences.push(`unique: ${target.unique} → ${source.unique}`);
     }
     if (facets.has('accessMethod') && (source.type ?? 'btree') !== (target.type ?? 'btree')) {
         differences.push(`type: ${target.type ?? 'btree'} → ${source.type ?? 'btree'}`);

package/dist/schema/schemaASTBuilder.js

@@ -10,6 +10,7 @@ import { ddlText } from '../util/ddlExpression.util.js';
 import { isInlinedExpression } from '../util/field.util.js';
 import { isSoleIdField } from '../util/field.util.js';
 import { isAutoIncrement } from '../util/field.util.js';
+import { definedEntries } from '../util/object.util.js';
 import { derivedForeignKeyName, derivedIndexName, qualifyName } from '../util/sql.util.js';
 import { fieldOptionsToCanonical } from './canonicalType.js';
 import { createTableNode, SchemaAST } from './schemaAST.js';
@@ -79,11 +80,7 @@ function addTableFromEntity(ctx, meta) {
     const { columns, primaryKey } = table;
     table.checks?.push(...(meta.checks ?? []));
     // Add columns from fields
-    const fields = meta.fields;
-    for (const key of Object.keys(fields)) {
-        const field = fields[key];
-        if (!field)
-            continue;
+    for (const [key, field] of definedEntries(meta.fields)) {
         // An inlined expression has no column; a stored one is a column like any other.
         if (isInlinedExpression(field))
             continue;
@@ -126,11 +123,7 @@ function addRelationshipsFromEntity(ctx, meta) {
     const table = tableOf(ctx, meta);
     if (!table)
         return;
-    const relations = meta.relations;
-    for (const key of Object.keys(relations)) {
-        const relation = relations[key];
-        if (!relation)
-            continue;
+    for (const [key, relation] of definedEntries(meta.relations)) {
         const relatedMeta = getMeta(relation.entity());
         const relatedTable = tableOf(ctx, relatedMeta);
         if (!relatedTable)

package/dist/schema/schemaASTDiffer.d.ts

@@ -10,7 +10,7 @@
 import { type IndexFacet } from './indexDifferences.js';
 import type { SchemaAST } from './schemaAST.js';
 import type { CanonicalType } from './types.js';
-import type { RelationshipDiff, RelationshipNode, SchemaDiffResult, TableDiff, TableNode } from './types.js';
+import type { ColumnDiff, ForeignKeyAction, IndexDiff, RelationshipDiff, RelationshipNode, SchemaDiffResult, TableDiff, TableNode } from './types.js';
 /**
  * Options for schema diffing.
  */
@@ -59,7 +59,10 @@ export declare function diffSchemas(source: SchemaAST, target: SchemaAST, option
  * against the one the database reported, then projects the result into a `SchemaDiff`. One
  * comparison serves both, so drift and migrations can no longer disagree about what has changed.
  */
-export declare function diffTable(source: TableNode, target: TableNode, options?: DiffOptions): TableDiff | undefined;
+export declare function diffTable(source: TableNode, target: TableNode, options?: DiffOptions): (TableDiff & {
+    readonly columnDiffs: ColumnDiff[];
+    readonly indexDiffs: IndexDiff[];
+}) | undefined;
 /**
  * Compare two lists of relationships.
  *
@@ -70,3 +73,8 @@ export declare function diffTable(source: TableNode, target: TableNode, options?
  * pairing on names would report every hand-named one as a drop and an add.
  */
 export declare function diffRelationshipNodes(source: readonly RelationshipNode[], target: readonly RelationshipNode[], opts?: DiffOptions): RelationshipDiff[];
+/** A relationship's `ON DELETE` and `ON UPDATE`, an unstated one read as the action the database applies. */
+export declare function referentialActions(rel: RelationshipNode): {
+    readonly onDelete: ForeignKeyAction;
+    readonly onUpdate: ForeignKeyAction;
+};

package/dist/schema/schemaASTDiffer.js

@@ -61,8 +61,8 @@ export function diffSchemas(source, target, options = {}) {
     const tablesToAlter = matched
         .map(([sourceTable, targetTable]) => diffTable(sourceTable, targetTable, opts))
         .filter((tableDiff) => tableDiff !== undefined);
-    const columnDiffs = tablesToAlter.flatMap((tableDiff) => tableDiff.columnDiffs ?? []);
-    const indexDiffs = tablesToAlter.flatMap((tableDiff) => tableDiff.indexDiffs ?? []);
+    const columnDiffs = tablesToAlter.flatMap((tableDiff) => tableDiff.columnDiffs);
+    const indexDiffs = tablesToAlter.flatMap((tableDiff) => tableDiff.indexDiffs);
     const primaryKeyDiffs = tablesToAlter.flatMap((tableDiff) => tableDiff.primaryKeyDiff ?? []);
     // Relationships span tables, so they are compared over the whole schema rather than per table.
     const relationshipDiffs = opts.compareRelationships
@@ -265,16 +265,17 @@ export function diffRelationshipNodes(source, target, opts = {}) {
             .filter((diff) => diff !== undefined),
     ];
 }
-/**
- * Compare two relationships.
- */
+/** A relationship's `ON DELETE` and `ON UPDATE`, an unstated one read as the action the database applies. */
+export function referentialActions(rel) {
+    return {
+        onDelete: rel.onDelete ?? DEFAULT_FOREIGN_KEY_ACTION,
+        onUpdate: rel.onUpdate ?? DEFAULT_FOREIGN_KEY_ACTION,
+    };
+}
+/** Two relationships over the same columns differ only in what they do when the row they point at goes. */
 function diffRelationship(source, target) {
-    // Compare on delete/update actions (normalizing defaults)
-    const sDelete = source.onDelete ?? DEFAULT_FOREIGN_KEY_ACTION;
-    const tDelete = target.onDelete ?? DEFAULT_FOREIGN_KEY_ACTION;
-    const sUpdate = source.onUpdate ?? DEFAULT_FOREIGN_KEY_ACTION;
-    const tUpdate = target.onUpdate ?? DEFAULT_FOREIGN_KEY_ACTION;
-    if (sDelete !== tDelete || sUpdate !== tUpdate) {
+    const [expected, actual] = [referentialActions(source), referentialActions(target)];
+    if (expected.onDelete !== actual.onDelete || expected.onUpdate !== actual.onUpdate) {
         return { ...relationEnds(source), type: 'alter', expected: source, actual: target };
     }
     return undefined;

package/dist/schema/types.d.ts

@@ -342,7 +342,7 @@ export type DriftSeverity = 'critical' | 'warning' | 'info';
 /**
  * Type of schema drift.
  */
-export type DriftType = 'missing_table' | 'unexpected_table' | 'missing_column' | 'unexpected_column' | 'type_mismatch' | 'constraint_mismatch' | 'missing_index' | 'unexpected_index' | 'index_mismatch' | 'missing_relationship' | 'unexpected_relationship';
+export type DriftType = 'missing_table' | 'unexpected_table' | 'missing_column' | 'unexpected_column' | 'type_mismatch' | 'constraint_mismatch' | 'missing_index' | 'unexpected_index' | 'index_mismatch' | 'missing_relationship' | 'unexpected_relationship' | 'relationship_mismatch';
 /**
  * A single schema drift issue.
  */

package/dist/sqlite/sqliteDialect.js

@@ -1,6 +1,7 @@
 import { AbstractSqlDialect } from '../dialect/abstractSqlDialect.js';
 import { JSON_ELEM_ALIAS_PREFIX, JSON_PULL_ALIAS } from '../dialect/aliases.js';
 import { jsonAssignCall, jsonElemExists, jsonPath, jsonRemoveCall, jsonSetTarget } from '../dialect/jsonSql.js';
+import { textSearchFields } from '../util/dialect.util.js';
 export class SqliteDialect extends AbstractSqlDialect {
     /** Default {@link DialectFeatures} for SQLite and SQLite-derived dialects. */
     featureDefaults = {
@@ -86,7 +87,7 @@ export class SqliteDialect extends AbstractSqlDialect {
      * FTS5 virtual table (UQL does not create those; declare it outside your entities).
      */
     appendTextSearch(ctx, entity, meta, search) {
-        const columns = search.$fields.map((key) => this.escapeId(this.resolveColumnName(key, meta.fields[key])));
+        const columns = textSearchFields(meta, search).map((key) => this.escapeId(this.resolveColumnName(key, meta.fields[key])));
         ctx.append(`${this.escapedTableName(meta)} MATCH {${columns.join(' ')}} : `);
         ctx.addValue(search.$value);
     }

package/dist/util/dialect.util.d.ts

@@ -1,4 +1,4 @@
-import { type CascadeType, type EntityData, type EntityId, type EntityIndexMeta, type EntityMeta, type FieldKey, type FieldOptions, type JsonUpdateOp, type OnFieldCallback, type Query, type QueryAggMap, type QueryAggregateOp, type QueryExclude, type QueryGroupMap, type QueryOptions, QueryRaw, type QuerySearch, type QuerySelect, type QuerySelectValue, type QuerySizeComparisonOps, type QuerySortMap, type QueryVectorSearch, type QueryWhere, type RelationKey, type UpdatePayload } from '../type/index.js';
+import { type CascadeType, type EntityData, type EntityId, type EntityIndexMeta, type EntityMeta, type FieldKey, type FieldOptions, type JsonUpdateOp, type OnFieldCallback, type Query, type QueryAggMap, type QueryAggregateOp, type QueryExclude, type QueryGroupMap, type QueryOptions, QueryRaw, type QuerySearch, type QuerySelect, type QuerySelectValue, type QuerySizeComparisonOps, type QuerySortMap, type QueryTextSearchOptions, type QueryVectorSearch, type QueryWhere, type RelationKey, type UpdatePayload } from '../type/index.js';
 export type CallbackKey = keyof Pick<FieldOptions, 'onInsert' | 'onUpdate'>;
 export declare function filterFieldKeys<E>(meta: EntityMeta<E>, payload: EntityData<E>, callbackKey: CallbackKey): FieldKey<E>[];
 /** Appends `record`'s not-yet-`seen` insertable keys (real, caller-written, defined value) to `keys`. */
@@ -171,3 +171,9 @@ export declare function assertNonNegativeInteger(value: number, clause: string):
 export declare function throwUnknownAggregateColumn(key: string, clause: string): never;
 /** {@link throwUnknownAggregateColumn} over every key of a clause, for backends that check up front. */
 export declare function assertAggregateColumns(clauseMap: object, emitted: ReadonlySet<string>, clause: string): void;
+/**
+ * The fields a `$text` searches: those it names, or else the columns of the entity's fulltext index,
+ * the declaration MySQL's `MATCH` has to name exactly and a MongoDB text index already is. Refused
+ * where neither says, rather than guessed: every engine answers a guess with an error of its own.
+ */
+export declare function textSearchFields<E>(meta: EntityMeta<E>, search: QueryTextSearchOptions<E>): readonly string[];

package/dist/util/dialect.util.js

@@ -424,3 +424,22 @@ export function assertAggregateColumns(clauseMap, emitted, clause) {
         }
     }
 }
+/**
+ * The fields a `$text` searches: those it names, or else the columns of the entity's fulltext index,
+ * the declaration MySQL's `MATCH` has to name exactly and a MongoDB text index already is. Refused
+ * where neither says, rather than guessed: every engine answers a guess with an error of its own.
+ */
+export function textSearchFields(meta, search) {
+    if (search.$fields?.length) {
+        return search.$fields;
+    }
+    const fulltext = (meta.indexes ?? []).filter((index) => index.type === 'fulltext');
+    if (fulltext.length === 1) {
+        return fulltext[0].columns.map((entry) => entry.column);
+    }
+    const name = entityName(meta);
+    const declared = fulltext.length
+        ? `${fulltext.length} fulltext indexes to choose from`
+        : 'no fulltext index to search';
+    throw new TypeError(`$text on '${name}' names no $fields, and '${name}' declares ${declared}. Name them with $fields.`);
+}

package/dist/util/logger.d.ts

@@ -34,7 +34,7 @@ export declare class LoggerWrapper implements Logger {
     private readonly loggerFunction?;
     private readonly logValues;
     private readonly slowQuery?;
-    constructor(options: LoggingOptions, config?: LoggerWrapperConfig);
+    constructor(options?: LoggingOptions, config?: LoggerWrapperConfig);
     /** Whether `logQuery` would ever actually surface bound values, given the configured levels/slowQuery/logValues. */
     willLogValues(): boolean;
     logQuery(query: string, values?: unknown[], duration?: number): void;
@@ -46,6 +46,15 @@ export declare class LoggerWrapper implements Logger {
     logSkippedMigration(message: string): void;
     private log;
 }
+/**
+ * The wrapper a querier logs through, one per options object and read once: a pool builds a querier
+ * for every statement, and all of them log by the same options.
+ */
+export declare function queryLoggerFor(extra?: {
+    readonly logger?: LoggingOptions;
+    readonly logValues?: boolean;
+    readonly slowQuery?: number;
+}): LoggerWrapper;
 /**
  * Structural type for any EventEmitter-like connection pool that emits an
  * `'error'` event on a dropped connection (node-postgres, `mariadb`, etc.).

package/dist/util/logger.js

@@ -136,6 +136,24 @@ export class LoggerWrapper {
         }
     }
 }
+const wrappersByOptions = new WeakMap();
+let unconfigured;
+/**
+ * The wrapper a querier logs through, one per options object and read once: a pool builds a querier
+ * for every statement, and all of them log by the same options.
+ */
+export function queryLoggerFor(extra) {
+    if (!extra) {
+        unconfigured ??= new LoggerWrapper();
+        return unconfigured;
+    }
+    let wrapper = wrappersByOptions.get(extra);
+    if (!wrapper) {
+        wrapper = new LoggerWrapper(extra.logger, { logValues: extra.logValues, slowQuery: extra.slowQuery });
+        wrappersByOptions.set(extra, wrapper);
+    }
+    return wrapper;
+}
 /**
  * Attaches an error listener to a connection pool so a dropped connection is logged instead of left
  * unhandled - which crashes the process for drivers that don't guard against it themselves

package/dist/util/object.util.d.ts

@@ -20,6 +20,8 @@ export declare function isOperatorObject(value: unknown): value is Record<string
 /** Whether every key of the non-empty object `value` is an operator (no plain field names mixed in). */
 export declare function isOperatorOnlyObject(value: unknown): value is Record<string, unknown>;
 export declare function getKeys<T extends object>(obj: T): (keyof T & string)[];
+/** The entries of `record` holding a value: a key declared but left `undefined` is no entry at all. */
+export declare function definedEntries<K extends string, V>(record: Partial<Record<K, V>>): [K, V][];
 /**
  * The entity's own name, declared or its class's. `meta.name` holds only what the author wrote, so
  * the fallback is what an entity that named no table is called - which is why the sites spelling this

package/dist/util/object.util.js

@@ -52,6 +52,10 @@ export function isOperatorOnlyObject(value) {
 export function getKeys(obj) {
     return obj ? Object.keys(obj) : [];
 }
+/** The entries of `record` holding a value: a key declared but left `undefined` is no entry at all. */
+export function definedEntries(record) {
+    return Object.entries(record).filter((entry) => entry[1] !== undefined);
+}
 /**
  * The entity's own name, declared or its class's. `meta.name` holds only what the author wrote, so
  * the fallback is what an entity that named no table is called - which is why the sites spelling this

package/dist/util/relationQuery.util.d.ts

@@ -1,8 +1,8 @@
 import type { EntityMeta, FieldMeta, Except, Query, QueryPopulate, RelationKey, RelationMeta } from '../type/index.js';
 export type RelationRequestSummary<E> = {
-    readonly requestedKeys: RelationKey<E>[];
-    readonly joinableKeys: RelationKey<E>[];
-    readonly toManyKeys: RelationKey<E>[];
+    readonly requestedKeys: readonly RelationKey<E>[];
+    readonly joinableKeys: readonly RelationKey<E>[];
+    readonly toManyKeys: readonly RelationKey<E>[];
 };
 /**
  * Whether a relation holds many rows per parent, so it cannot be joined into the parent's row. Takes

package/dist/util/relationQuery.util.js

@@ -1,5 +1,11 @@
 import { QUERY_BOOLEAN_CLAUSES, QUERY_NUMBER_CLAUSES, QUERY_OBJECT_CLAUSES, QUERY_ROOT_NUMBER_CLAUSES, } from '../type/query.js';
 import { getKeys, someKey } from './object.util.js';
+/** What a query populating nothing requests, shared: most reads populate nothing, and ask on every one. */
+const NOTHING_REQUESTED = Object.freeze({
+    requestedKeys: Object.freeze([]),
+    joinableKeys: Object.freeze([]),
+    toManyKeys: Object.freeze([]),
+});
 /**
  * Whether a relation holds many rows per parent, so it cannot be joined into the parent's row. Takes
  * the one field it reads, so it answers for a relation being declared as well as for a resolved one.
@@ -142,11 +148,11 @@ function assertJoinableRelationQuery(relKey, value) {
     }
 }
 export function getRelationRequestSummary(meta, populate) {
+    if (!populate)
+        return NOTHING_REQUESTED;
     const requestedKeys = [];
     const joinableKeys = [];
     const toManyKeys = [];
-    if (!populate)
-        return { requestedKeys, joinableKeys, toManyKeys };
     for (const key of getKeys(populate)) {
         if (!populate[key])
             continue;

package/package.json

@@ -3,7 +3,7 @@
   "homepage": "https://uql-orm.dev",
   "description": "The JSON-native TypeScript ORM for Bun, Browsers, Edge, Deno, Node, Workers. Supports PostgreSQL, PGlite, MySQL, MariaDB, SQLite, CockroachDB, SQL Server, Turso, Neon, Cloudflare D1 and MongoDB. Queries are plain JSON, typed to the leaf.",
   "license": "MIT",
-  "version": "0.55.0",
+  "version": "0.56.0",
   "type": "module",
   "engines": {
     "node": ">=24"