@simtlix/simfinity-postgres 3.15.0 → 3.16.0

package/README.md

@@ -31,7 +31,7 @@ import { postgresPlugin } from '@simtlix/simfinity-postgres';
 const simfinity = createSQL({ plugin: postgresPlugin({ pool, schema: 'library' }) });
 ```
 
-Install `@simtlix/simfinity-sql@3.15.0` as a direct dependency when importing its factory. PostgreSQL 15 or later is the only supported SQL plugin. The [SQL package guide](https://github.com/simtlix/simfinity.js/tree/master/packages/sql) documents relational planning and the versioned plugin contract.
+Install `@simtlix/simfinity-sql@3.16.0` as a direct dependency when importing its factory. PostgreSQL 15 or later is the only supported SQL plugin. The [SQL package guide](https://github.com/simtlix/simfinity.js/tree/master/packages/sql) documents relational planning and the versioned plugin contract.
 
 Both factories permanently bind one pool and schema, and five optional settings: `multiRowInserts: false` keeps one `INSERT` per owned row instead of multi-row statements; `explicitNullsOrder: true` keeps the `NULLS` clause on sorts of `id` and required fields, as 3.5.9 did, instead of letting indexes serve them; `batchedCollections: true` reads the generated collection fields of the parents that share their arguments with one statement per 100 parents, in a transaction that turns JIT off for that transaction only, instead of one statement per field as 3.6.0 did and as the default still does, and can return unsorted and tied rows in another order; the opt-in `refreshTriggers: 'perRoot'` refreshes each changed root's owned shape and unique keys once per transaction, while its guard trigger stays deferred, instead of once per changed row; and the opt-in `ownerIndexes: 'minimal'` leaves out the `(__owner_id)` indexes that the primary key or a unique index covers on new owned and guard tables. An unknown `refreshTriggers` or `ownerIndexes` value throws `INVALID_DATABASE_SCHEMA` (400). Read the [upgrade notes](https://simtlix.github.io/simfinity.js/resources/compatibility.html#upgrade-to-3-6-0) before enabling the opt-ins: versions up to 3.5.9 cannot validate databases created with them. The returned runtime supports registration, generated queries and mutations, middleware and scopes, controllers and validators, custom queries and mutations, named views, state machines, nested relationship writes, embedded reconstruction, and native PostgreSQL model handles. Native handles expose `findById`, `find`, `create`, `update`, and `delete`; they are not Mongoose models. `find(args, { session })` accepts the generated GraphQL list query arguments. Existing `pg.Pool` configuration and `pg.PoolClient` query interfaces remain compatible across both factories. A custom pool or client wrapper should pass `pg`'s `command` through in query results: the plugin reads it from the `COMMIT` result to detect a transaction that PostgreSQL rolled back because one of its statements failed, and without it such a transaction reports success with nothing stored.
 
@@ -55,6 +55,8 @@ await initializeDatabase({ mode: 'validate' });
 
 Called without arguments after `createSchema()`, the module's `describeDatabase()` and `compileDatabaseSchema()` describe and compile this default instance in its configured schema.
 
+Since 3.16.0, the module and every instance also expose `updateObject`, `deleteObject` and `transitionObject` next to `saveObject`, which run the update, delete and state action lifecycle in an owned transaction or in a session from `withTransaction`, and `createSchema(…, { transaction })` can add a mutation that runs several generated mutations in one PostgreSQL transaction.
+
 Transactions use one borrowed `pg` client and repeatable-read isolation. Reads without a session of types without owned embedded tables run as a single statement on a pooled connection instead. With `batchedCollections: true`, the runtime reads the generated collection fields of up to 100 parents that share their arguments in one batch, with one statement, a `UNION ALL` of each parent's own statement with its parent ID as a parameter of its own, so PostgreSQL plans each parent's rows as it plans that parent's own statement; more parents run as several batches, each in its own transaction. Each batch runs in one repeatable-read transaction: `BEGIN`, `SET LOCAL jit = off`, the statement, the owned-row reads, then `COMMIT`. Only a direct `findChildrenBatch` call on the SQL adapter with more than 100 IDs repeats `SET LOCAL` and the statement for each further 100 within its transaction. The batch's plan can cost more than `jit_above_cost` when no parent's own plan does, and JIT compilation of its branches can take longer than the statement itself; `SET LOCAL` ends with the transaction, so pooled connections keep the server's setting. A batch takes these 4 round trips, or more with owned rows, one after another on one connection and runs its parents one after another, where per-parent statements take one round trip each, concurrently on the pool's free connections. It pays off when the pool is saturated or much smaller than the number of parents per level, as with many parents with small child lists; with free connections it can be slower, even on a remote database, so measure before enabling it. Transaction-mode PgBouncer keeps each batch on one server connection, while Amazon RDS Proxy pins the pooled connections that run batches, for their `SET LOCAL` and their statements over 16 KB. See [batched collection reads](https://simtlix.github.io/simfinity.js/guide/relationships.html#batched-collection-reads). A supplied Simfinity PostgreSQL session joins the active transaction. Serialization failures and deadlocks are retried up to five times, each after a short random delay that starts once the client is released; mutation input is reset for each attempt. Unknown commit outcomes are not replayed. The caller owns the pool lifecycle.
 
 The module and every `createPostgres` instance expose the shared `auth`, `validators`, `scalars`, and `plugins` helpers. These are the same helper objects exported by the MongoDB package, so rules, scalar identities, and errors can be shared safely between backends.
@@ -62,7 +64,7 @@ The module and every `createPostgres` instance expose the shared `auth`, `valida
 MCP integration is an independent opt-in and does not add MCP dependencies to PostgreSQL applications:
 
 ```sh
-npm install @simtlix/simfinity-mcp@3.15.0 @modelcontextprotocol/sdk@^1.31.0
+npm install @simtlix/simfinity-mcp@3.16.0 @modelcontextprotocol/sdk@^1.31.0
 ```
 
 ```javascript
@@ -77,7 +79,7 @@ Entity identities and references use UUIDs. Scalars use native PostgreSQL types,
 
 Queries support nested scalar/reference paths, logical filter groups, scopes, sort, pagination, count, and grouped `SUM`, `COUNT`, `AVG`, `MIN`, and `MAX` facts. The PostgreSQL implementation preserves root multiplicity when joining collection paths.
 
-The text operators take literal values as bound parameters. `LIKE`, `STARTS_WITH` and `ENDS_WITH` compare code points, and `STARTS_WITH` can use a column's btree index. `ILIKE`, `ISTARTS_WITH`, `IENDS_WITH` and `IEQ` fold both sides with the Unicode simple case foldings that MongoDB's case-insensitive matching applies, through one expression, `translate(lower((x) COLLATE "pg_catalog"."und-x-icu"), from, to)`, where `translate()` maps the 22 lowercase variants that ICU `lower()` keeps, such as `ſ`, `µ` and the final sigma `ς`, to their usual letters; so each returns every row that its case-sensitive form returns, and `ISTARTS_WITH "ΚΑΣ"` finds `ΚΑΣΤΡΟ`. The first three match a `LIKE` pattern whose `%`, `_` and `\` are escaped. The two backends still differ on `İ`, which ICU lowers to `i` followed by U+0307, and on letters newer than one side's Unicode tables. The fold needs a `UTF8` database on a server built with ICU: on another, such as one in `LATIN1`, these four operators fail with `UNSUPPORTED_QUERY` (400), and every other operation works. Indexes serve them only on exactly the compiled expression, which the exported `caseFoldExpression(sqlExpression)` returns, such as `caseFoldExpression('"name"')`: a btree with `text_pattern_ops` on it serves `IEQ` and `ISTARTS_WITH`, and a `pg_trgm` GIN index with `gin_trgm_ops` serves `ILIKE`, `ISTARTS_WITH` and `IENDS_WITH`. The [queries guide](https://simtlix.github.io/simfinity.js/guide/queries.html#case-folding) gives the details and the index statements.
+The text operators take literal values as bound parameters. `LIKE`, `STARTS_WITH` and `ENDS_WITH` compare code points, and `STARTS_WITH` can use a column's btree index. `ILIKE`, `ISTARTS_WITH`, `IENDS_WITH` and `IEQ` fold both sides with the Unicode simple case foldings that MongoDB's case-insensitive matching applies, through one expression, `translate(lower((x) COLLATE "pg_catalog"."und-x-icu"), from, to)`, where `translate()` maps the 22 lowercase variants that ICU `lower()` keeps, such as `ſ`, `µ` and the final sigma `ς`, to their usual letters; so each returns every row that its case-sensitive form returns, and `ISTARTS_WITH "ΚΑΣ"` finds `ΚΑΣΤΡΟ`. The first three match a `LIKE` pattern whose `%`, `_` and `\` are escaped. The two backends still differ on `İ`, which ICU lowers to `i` followed by U+0307, and on letters newer than one side's Unicode tables. `IIN`, `IN` ignoring case, folds both sides the same way, as `fold("column") = ANY (ARRAY(SELECT fold(w.value) FROM unnest($1::text[]) w(value)))` with its values bound as one array, and compiles `IIN []` to `FALSE`. The fold needs a `UTF8` database on a server built with ICU: on another, such as one in `LATIN1`, these four operators and `IIN` fail with `UNSUPPORTED_QUERY` (400), and every other operation works. Indexes serve them only on exactly the compiled expression, which the exported `caseFoldExpression(sqlExpression)` returns, such as `caseFoldExpression('"name"')`: a btree with `text_pattern_ops` on it serves `IEQ`, `IIN` and `ISTARTS_WITH`, and a `pg_trgm` GIN index with `gin_trgm_ops` serves `ILIKE`, `ISTARTS_WITH` and `IENDS_WITH`. [`CONTAINS_ALL`](https://simtlix.github.io/simfinity.js/guide/queries.html#filters-on-lists) compiles to `"column" @> $1::type[]` on a list of the root record, which a GIN index of your own on the column serves, and initialization keeps such an index in both modes; lists inside embedded values are scanned. The [queries guide](https://simtlix.github.io/simfinity.js/guide/queries.html#case-folding) gives the details and the index statements.
 
 `IS_EMPTY` and `IS_NOT_EMPTY` take no value and test the queried record's own fields: a missing, null or `""` String, a missing or null value of any other scalar, a missing, null or `[]` list, and an embedded object that is missing, null or has every stored member empty. They compile from where the path is stored and bind no parameters: `(c IS NULL OR c = '')` for a String column, so that a btree serves it through a `BitmapOr`, `c IS NULL` for any other column, including the uuid identity of a record whose `id` is declared `String`, and `COALESCE(cardinality(c), 0) = 0` for a native array, also on owned rows; a jsonb member is read as text with `->>` and never cast, a jsonb list through a `jsonb_typeof` guard, and a jsonb object as SQL `NULL`, JSON `null` or all of its members empty; an owned single object is empty when its state is not `present` or no owned row has a member that is not empty, and an owned list when its state is not `present` or it has no row, null items included, with a subquery alias of its own at each level of owned storage. `IS_NOT_EMPTY` is the positive form of a leaf and the `NOT` of an object or owned form, so every record matches exactly one of the two. An emptiness path that continues inside an embedded list, such as `lines.qty`, fails with `INVALID_FILTER_PATH` (400), since emptiness of an item inside that list is not defined. Through a collection, use an explicit frame and test the element's own field (for example `ANY seasons` with `year IS_EMPTY`); the flattened `seasons.year IS_EMPTY` shorthand is excluded. The [queries guide](https://simtlix.github.io/simfinity.js/guide/queries.html) describes the rules.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@simtlix/simfinity-postgres",
-  "version": "3.15.0",
+  "version": "3.16.0",
   "description": "PostgreSQL GraphQL runtime and schema generation with foreign keys for Simfinity",
   "type": "module",
   "main": "./src/index.js",
@@ -27,8 +27,8 @@
     "directory": "packages/postgres"
   },
   "dependencies": {
-    "@simtlix/simfinity-core": "3.15.0",
-    "@simtlix/simfinity-sql": "3.15.0",
+    "@simtlix/simfinity-core": "3.16.0",
+    "@simtlix/simfinity-sql": "3.16.0",
     "pg": "^8.16.3"
   },
   "peerDependencies": {

package/src/codecs.js

@@ -77,7 +77,7 @@ export const isPostgresError = (error) => typeof error?.code === 'string' && /^[
 
 // A statement that folds case on a database that cannot evaluate the fold (see isCaseFoldUnsupported): the request
 // uses an operator that this database cannot run, while every other operation keeps working.
-const CASE_FOLD_UNSUPPORTED = ['ILIKE, ISTARTS_WITH, IENDS_WITH and IEQ need a UTF8 database with the ICU collation und-x-icu', 'UNSUPPORTED_QUERY', 400];
+const CASE_FOLD_UNSUPPORTED = ['ILIKE, ISTARTS_WITH, IENDS_WITH, IEQ and IIN need a UTF8 database with the ICU collation und-x-icu', 'UNSUPPORTED_QUERY', 400];
 
 /** Maps PostgreSQL errors (and exhausted retries) without SQL details; returns every other value unchanged. */
 export const normalizeDatabaseError = (error) => {

package/src/index.js

@@ -22,7 +22,7 @@ export {
 /** Each instance permanently binds one pool/schema; getModel exposes PostgreSQL native helpers. */
 export const createPostgres = (options) => createSQL({ plugin: postgresPlugin(options) });
 const defaultInstance = createPostgres();
-export const { configureQueryLimits, configureMutationLimits, configureAfterCommit, configure, connect, addNoEndpointType, createSchema, getModel, getType, getInputType, getRegistrations, use, registerMutation, registerCustomQuery, registerView, saveObject, preventCreatingCollection, withTransaction } = defaultInstance;
+export const { configureQueryLimits, configureMutationLimits, configureAfterCommit, configure, connect, addNoEndpointType, createSchema, getModel, getType, getInputType, getRegistrations, use, registerMutation, registerCustomQuery, registerView, saveObject, updateObject, deleteObject, transitionObject, preventCreatingCollection, withTransaction } = defaultInstance;
 
 /** Preserve the foundation low-level API while allowing initialization of the configured default instance. */
 export const initializeDatabase = (poolOrOptions, description, options) => description

package/src/plugin.js

@@ -24,7 +24,7 @@ export const postgresPlugin = (options) => ({
   // declaration names the compileQuery it describes, so a copy of this plugin with another compileQuery compiles the
   // operators of 3.7.0, without reference emptiness or quantifiers, until it declares its own.
   queryFeatures: {
-    operators: ['EQ', 'NE', 'LT', 'LTE', 'GT', 'GTE', 'BTW', 'IN', 'NIN', 'LIKE', 'ILIKE', 'STARTS_WITH', 'ISTARTS_WITH', 'ENDS_WITH', 'IENDS_WITH', 'IEQ', 'IS_EMPTY', 'IS_NOT_EMPTY'],
+    operators: ['EQ', 'NE', 'LT', 'LTE', 'GT', 'GTE', 'BTW', 'IN', 'NIN', 'LIKE', 'ILIKE', 'STARTS_WITH', 'ISTARTS_WITH', 'ENDS_WITH', 'IENDS_WITH', 'IEQ', 'IS_EMPTY', 'IS_NOT_EMPTY', 'CONTAINS_ALL', 'IIN'],
     referenceEmptiness: true,
     quantifiers: true,
     compileQuery,

package/src/query/case-fold.js

@@ -1,4 +1,4 @@
-// The case fold of the case-insensitive text operators (ILIKE, ISTARTS_WITH, IENDS_WITH and IEQ), the shared
+// The case fold of the case-insensitive operators (ILIKE, ISTARTS_WITH, IENDS_WITH, IEQ and IIN), the shared
 // contract of #108 section 3.1: the Unicode simple case foldings that MongoDB's case-insensitive regular expressions
 // apply. lower() under ICU's root collation applies them to every script the same way on every server, whatever the
 // database's default collation (text paths are `C` columns, under which lower() folds ASCII only), except for the
@@ -47,9 +47,9 @@ const FROM = `'${CASE_FOLD_MAPPINGS.map(([from]) => from).join('')}'`;
 const TO = `'${CASE_FOLD_MAPPINGS.map(([, to]) => to).join('')}'`;
 
 /**
- * The SQL text that folds `sqlExpression` for the case-insensitive text operators, exactly as the compiler writes it on
- * both sides of each comparison: `translate(lower((<expression>) COLLATE "pg_catalog"."und-x-icu"), '<22 characters>',
- * '<their simple case foldings>')`. Applications build their expression indexes with it, such as
+ * The SQL text that folds `sqlExpression` for the case-insensitive text operators and IIN, exactly as the compiler
+ * writes it on both sides of each comparison: `translate(lower((<expression>) COLLATE "pg_catalog"."und-x-icu"),
+ * '<22 characters>', '<their simple case foldings>')`. Applications build their expression indexes with it, such as
  * `CREATE INDEX ... (${caseFoldExpression('"name"')} text_pattern_ops)`. The expression is trusted SQL, inserted as
  * given: quote identifiers yourself and never pass request input. It goes in parentheses, because COLLATE binds more
  * tightly than `->>` and every other binary operator: without them, `"details" ->> 'label'` would collate only

package/src/query/compiler.js

@@ -1,6 +1,7 @@
 import { QLQuantifier, resolveModelPath, SimfinityError } from '@simtlix/simfinity-core';
 import {
-  crossingKeys, describeEmptiness, describeModelEmptiness, emptinessScopePaths, isEmptinessOperator, textQueryOperator, validateQuantifiedGroups, validateTextFilterValue,
+  assertContainsAllPath, crossingKeys, describeEmptiness, describeModelEmptiness, emptinessScopePaths, isEmptinessOperator, textQueryOperator,
+  validateContainsAllValue, validateQuantifiedGroups, validateTextFilterValue, validateTextListFilterValue,
 } from '@simtlix/simfinity-core/internal/query-operators';
 import { identifier as q, literal, qualified } from '../schema/sql.js';
 import { encodeScalar, storageTypes, invalidValue } from '../codecs.js';
@@ -347,6 +348,22 @@ const compileSelect = (models, database, plan, extra, configuration, batched) =>
       return operator === 'IN' ? expressionSQL : `NOT ${expressionSQL}`;
     }
     if (operator === 'BTW') return `(${predicate(expression, 'GTE', value[0], negated)} AND ${predicate(expression, 'LTE', value[1], negated)})`;
+    if (operator === 'CONTAINS_ALL') {
+      validateContainsAllValue(value);
+      // One array parameter of the path's element type, cast like IN elements: set containment, as MongoDB's $all. NULL
+      // elements of the stored list are ignored, and a NULL list gives NULL, which only the negated form turns into false.
+      const contains = `${sql} @> ${bind(value.map(encodeValue), `${type}[]`)}`;
+      return negated ? `COALESCE(${contains}, FALSE)` : contains;
+    }
+    if (operator === 'IIN') {
+      validateTextListFilterValue(operator, value, field.scalar);
+      if (!value.length) return 'FALSE';
+      // The values are folded by the server, once per statement, so that application indexes on the folded column serve it.
+      const members = `ANY (ARRAY(SELECT ${fold('w.value')} FROM unnest(${bind(value, 'text[]')}) w(value)))`;
+      if (list) return `EXISTS (SELECT 1 FROM unnest(${sql}) v(value) WHERE ${fold('v.value')} = ${members})`;
+      const compare = `${fold(expression.uncollated)} = ${members}`;
+      return negated ? `COALESCE(${compare}, FALSE)` : compare;
+    }
     if (value == null || Array.isArray(value)) invalidValue(`${operator} requires a non-null scalar value`);
     const text = textQueryOperator(operator);
     if (text) return textPredicate(expression, operator, text, value, negated);
@@ -598,6 +615,9 @@ const compileSelect = (models, database, plan, extra, configuration, batched) =>
     if (!node) return 'TRUE';
     if (node.kind === 'quantified') return quantified(node, frame);
     if (node.kind === 'predicate' && isEmptinessOperator(node.operator)) return `(${emptiness(node, frame)})`;
+    // CONTAINS_ALL's path and leaf rules (#108 part 4), with core's codes, before any join or alias, so that a plan built
+    // by hand never compiles to the legacy collection join or the multiplying vector join, or raises 42883.
+    if (node.kind === 'predicate' && node.operator === 'CONTAINS_ALL') assertContainsAllPath(resolveModelPath(models, frame.entity, node.path));
     if (node.kind === 'predicate') {
       // Check ordinary paths and values before the new client metadata, without creating joins or aliases.
       if (Object.hasOwn(node, 'joins')) validateQuantifiedGroups({ AND: [{ conditions: [{ field: node.path.join('.'), operator: node.operator, value: node.value }] }] }, { models, entity: frame.entity, referenceEmptiness: true, quantifiers: true });
@@ -609,7 +629,9 @@ const compileSelect = (models, database, plan, extra, configuration, batched) =>
         const leaf = steps.at(-1);
         const identity = ['id', '_id'].includes(leaf.name) && (steps.length === 1 ? !frame.table.ownership : steps.at(-2).kind !== 'embedded');
         const field = operandField(leaf, identity);
-        predicate({ field, type: storageTypes[field.scalar], list: field.list, sql: '', uncollated: '' }, node.operator, node.value, negated);
+        // The placeholders are never emitted: detached() follows. They must be non-empty, because textPredicate and the IIN
+        // branch fold `uncollated` with caseFoldExpression, which rejects an empty expression (case-fold.js:60).
+        predicate({ field, type: storageTypes[field.scalar], list: field.list, sql: 'NULL', uncollated: 'NULL' }, node.operator, node.value, negated);
         detached(checked.reason);
       }
       const sql = predicate(path(node.path, 'filter', frame, checked.joins), node.operator, node.value, negated);

package/types/index.d.ts

@@ -246,9 +246,10 @@ export interface PostgresRuntime extends Runtime<PostgresModel, PostgresSession>
 }
 /**
  * PostgreSQL 15+ plugin for createSQL; omitted options allow later runtime.configure. Its `queryFeatures` lists every
- * `QLOperator` value. The case-insensitive text operators fold case with {@link caseFoldExpression}, which needs a UTF8
- * database with the ICU collation `und-x-icu`: on another database, such as one in LATIN1 or on a server built without
- * ICU, they fail with UNSUPPORTED_QUERY (400), and every other operation works.
+ * `QLOperator` value. The case-insensitive text operators and `IIN` fold case with {@link caseFoldExpression}, which
+ * needs a UTF8 database with the ICU collation `und-x-icu`: on another database, such as one in LATIN1 or on a server
+ * built without ICU, they fail with UNSUPPORTED_QUERY (400), except `IIN []`, which compiles to `FALSE` without a fold,
+ * and every other operation works.
  *
  * `IS_EMPTY` and `IS_NOT_EMPTY` compile from where a path is stored, binding no parameters: `(c IS NULL OR c = '')`
  * for a String column and `c IS NULL` for any other, the uuid identity included; `COALESCE(cardinality(c), 0) = 0`
@@ -293,7 +294,7 @@ export function postgresPlugin(options?: PostgresConfiguration): SQLPlugin<
 >;
 export function createPostgres(options?: PostgresConfiguration): PostgresRuntime;
 /**
- * The SQL text with which ILIKE, ISTARTS_WITH, IENDS_WITH and IEQ fold both sides of their comparison, for an SQL
+ * The SQL text with which ILIKE, ISTARTS_WITH, IENDS_WITH, IEQ and IIN fold both sides of their comparison, for an SQL
  * expression such as a quoted column name or a jsonb member: `translate(lower((<expression>) COLLATE
  * "pg_catalog"."und-x-icu"), '<22 characters>', '<their simple case foldings>')`, the Unicode simple case foldings that
  * MongoDB's case-insensitive matching applies. Indexes serve these operators only on exactly this expression, so build
@@ -317,6 +318,9 @@ export const registerMutation: PostgresRuntime['registerMutation'];
 export const registerCustomQuery: PostgresRuntime['registerCustomQuery'];
 export const registerView: PostgresRuntime['registerView'];
 export const saveObject: PostgresRuntime['saveObject'];
+export const updateObject: PostgresRuntime['updateObject'];
+export const deleteObject: PostgresRuntime['deleteObject'];
+export const transitionObject: PostgresRuntime['transitionObject'];
 export const preventCreatingCollection: PostgresRuntime['preventCreatingCollection'];
 export const withTransaction: PostgresRuntime['withTransaction'];
 /** Initializes the default module instance, after configure/connect/createSchema. */
@@ -325,6 +329,6 @@ export function initializeDatabase(options?: InitializationOptions): Promise<Ini
 export const configureQueryLimits: Runtime['configureQueryLimits'];
 /**
  * The same process-wide setter as every runtime's configureMutationLimits. Unknown or misspelled
- * options throw INVALID_MUTATION_LIMITS (400) and keep the current limit.
+ * options throw INVALID_MUTATION_LIMITS (400) and keep the current limits.
  */
 export const configureMutationLimits: Runtime['configureMutationLimits'];