@decocms/mesh 1.0.0-alpha.1

package/dist/server/node_modules/kysely/dist/esm/raw-builder/sql.d.ts

@@ -0,0 +1,366 @@
+import { type RawBuilder } from './raw-builder.js';
+export interface Sql {
+    /**
+     * Template tag for creating raw SQL snippets and queries.
+     *
+     * ```ts
+     * import { sql } from 'kysely'
+     * import type { Person } from 'type-editor' // imaginary module
+     *
+     * const id = 123
+     * const snippet = sql<Person[]>`select * from person where id = ${id}`
+     * ```
+     *
+     * Substitutions (the things inside `${}`) are automatically passed to the database
+     * as parameters and are never interpolated to the SQL string. There's no need to worry
+     * about SQL injection vulnerabilities. Substitutions can be values, other `sql`
+     * expressions, queries and almost anything else Kysely can produce and they get
+     * handled correctly. See the examples below.
+     *
+     * If you need your substitutions to be interpreted as identifiers, value literals or
+     * lists of things, see the {@link Sql.ref}, {@link Sql.table}, {@link Sql.id},
+     * {@link Sql.lit}, {@link Sql.raw} and {@link Sql.join} functions.
+     *
+     * You can pass sql snippets returned by the `sql` tag pretty much anywhere. Whenever
+     * something can't be done using the Kysely API, you should be able to drop down to
+     * raw SQL using the `sql` tag. Here's an example query that uses raw sql in a bunch
+     * of methods:
+     *
+     * ```ts
+     * import { sql } from 'kysely'
+     *
+     * const nicknames = ['johnny', 'john', 'jon']
+     * const date1 = new Date('2000-01-01')
+     * const date2 = new Date('2001-01-01')
+     *
+     * const persons = await db
+     *   .selectFrom('person')
+     *   .select(
+     *     // If you use `sql` in a select statement, remember to call the `as`
+     *     // method to give it an alias.
+     *     sql<string>`concat(first_name, ' ', last_name)`.as('full_name')
+     *   )
+     *   .where(sql<boolean>`birthdate between ${date1} and ${date2}`)
+     *   // Here we assume we have list of nicknames for the person
+     *   // (a list of strings) and we use the PostgreSQL `@>` operator
+     *   // to test if all of them are valid nicknames for the user.
+     *   .where('nicknames', '@>', sql<string[]>`ARRAY[${sql.join(nicknames)}]`)
+     *   .orderBy(sql<string>`concat(first_name, ' ', last_name)`)
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select concat(first_name, ' ', last_name) as "full_name"
+     * from "person"
+     * where birthdate between $1 and $2
+     * and "nicknames" @> ARRAY[$3, $4, $5, $6, $7, $8, $9, $10]
+     * order by concat(first_name, ' ', last_name)
+     * ```
+     *
+     * SQL snippets can be executed by calling the `execute` method and passing a `Kysely`
+     * instance as the only argument:
+     *
+     * ```ts
+     * import { sql } from 'kysely'
+     * import type { Person } from 'type-editor'
+     *
+     * const { rows: results } = await sql<Person[]>`select * from person`.execute(db)
+     * ```
+     *
+     * You can merge other `sql` expressions and queries using substitutions:
+     *
+     * ```ts
+     * import { sql } from 'kysely'
+     *
+     * const petName = db.selectFrom('pet').select('name').limit(1)
+     * const fullName = sql<string>`concat(first_name, ' ', last_name)`
+     *
+     * sql<{ full_name: string; pet_name: string }[]>`
+     *   select ${fullName} as full_name, ${petName} as pet_name
+     *   from person
+     * `.execute(db)
+     * ```
+     *
+     * Substitutions also handle {@link ExpressionBuilder.ref},
+     * {@link DynamicModule.ref} and pretty much anything else you
+     * throw at it. Here's an example of calling a function in a
+     * type-safe way:
+     *
+     * ```ts
+     * db.selectFrom('person')
+     *   .select([
+     *     'first_name',
+     *     'last_name',
+     *     (eb) => {
+     *       // The `eb.ref` method is type-safe and only accepts
+     *       // column references that are possible.
+     *       const firstName = eb.ref('first_name')
+     *       const lastName = eb.ref('last_name')
+     *
+     *       const fullName = sql<string>`concat(${firstName}, ' ', ${lastName})`
+     *       return fullName.as('full_name')
+     *     }
+     *   ])
+     * ```
+     *
+     * don't know if that amount of ceremony is worth the small increase in
+     * type-safety though... But it's possible.
+     */
+    <T = unknown>(sqlFragments: TemplateStringsArray, ...parameters: unknown[]): RawBuilder<T>;
+    /**
+     * `sql.val(value)` is a shortcut for:
+     *
+     * ```ts
+     * import { sql } from 'kysely'
+     *
+     * const value = 123
+     * type ValueType = typeof value
+     *
+     * sql<ValueType>`${value}`
+     * ```
+     */
+    val<V>(value: V): RawBuilder<V>;
+    /**
+     * @deprecated Use {@link Sql.val} instead.
+     */
+    value<V>(value: V): RawBuilder<V>;
+    /**
+     * This can be used to add runtime column references to SQL snippets.
+     *
+     * By default `${}` substitutions in {@link sql} template strings get
+     * transformed into parameters. You can use this function to tell
+     * Kysely to interpret them as column references instead.
+     *
+     * WARNING! Using this with unchecked inputs WILL lead to SQL injection
+     * vulnerabilities. The input is not checked or escaped by Kysely in any way.
+     *
+     * ```ts
+     * const columnRef = 'first_name'
+     *
+     * sql`select ${sql.ref(columnRef)} from person`
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select "first_name" from person
+     * ```
+     *
+     * The references can also include a table name:
+     *
+     * ```ts
+     * const columnRef = 'person.first_name'
+     *
+     * sql`select ${sql.ref(columnRef)}} from person`
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select "person"."first_name" from person
+     * ```
+     *
+     * The references can also include a schema on supported databases:
+     *
+     * ```ts
+     * const columnRef = 'public.person.first_name'
+     *
+     * sql`select ${sql.ref(columnRef)}} from person`
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select "public"."person"."first_name" from person
+     * ```
+     */
+    ref<R = unknown>(columnReference: string): RawBuilder<R>;
+    /**
+     * This can be used to add runtime table references to SQL snippets.
+     *
+     * By default `${}` substitutions in {@link sql} template strings get
+     * transformed into parameters. You can use this function to tell
+     * Kysely to interpret them as table references instead.
+     *
+     * WARNING! Using this with unchecked inputs WILL lead to SQL injection
+     * vulnerabilities. The input is not checked or escaped by Kysely in any way.
+     *
+     * ```ts
+     * const table = 'person'
+     *
+     * sql`select first_name from ${sql.table(table)}`
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select first_name from "person"
+     * ```
+     *
+     * The references can also include a schema on supported databases:
+     *
+     * ```ts
+     * const table = 'public.person'
+     *
+     * sql`select first_name from ${sql.table(table)}`
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select first_name from "public"."person"
+     * ```
+     */
+    table<T = unknown>(tableReference: string): RawBuilder<T>;
+    /**
+     * This can be used to add arbitrary identifiers to SQL snippets.
+     *
+     * Does the same thing as {@link Sql.ref | ref} and {@link Sql.table | table}
+     * but can also be used for any other identifiers like index names.
+     *
+     * You should use {@link Sql.ref | ref} and {@link Sql.table | table}
+     * instead of this whenever possible as they produce a more semantic
+     * operation node tree.
+     *
+     * WARNING! Using this with unchecked inputs WILL lead to SQL injection
+     * vulnerabilities. The input is not checked or escaped by Kysely in any way.
+     *
+     * ```ts
+     * const indexName = 'person_first_name_index'
+     *
+     * sql`create index ${indexName} on person`
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * create index "person_first_name_index" on person
+     * ```
+     *
+     * Multiple identifiers get separated by dots:
+     *
+     * ```ts
+     * const schema = 'public'
+     * const columnName = 'first_name'
+     * const table = 'person'
+     *
+     * sql`select ${sql.id(schema, table, columnName)} from ${sql.id(schema, table)}`
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select "public"."person"."first_name" from "public"."person"
+     * ```
+     */
+    id<T = unknown>(...ids: readonly string[]): RawBuilder<T>;
+    /**
+     * This can be used to add literal values to SQL snippets.
+     *
+     * WARNING! Using this with unchecked inputs WILL lead to SQL injection
+     * vulnerabilities. The input is not checked or escaped by Kysely in any way.
+     * You almost always want to use normal substitutions that get sent to the
+     * db as parameters.
+     *
+     * ```ts
+     * const firstName = 'first_name'
+     *
+     * sql`select * from person where first_name = ${sql.lit(firstName)}`
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select * from person where first_name = 'first_name'
+     * ```
+     *
+     * As you can see from the example above, the value was added directly to
+     * the SQL string instead of as a parameter. Only use this function when
+     * something can't be sent as a parameter.
+     */
+    lit<V>(value: V): RawBuilder<V>;
+    /**
+     * @deprecated Use {@link lit} instead.
+     */
+    literal<V>(value: V): RawBuilder<V>;
+    /**
+     * This can be used to add arbitrary runtime SQL to SQL snippets.
+     *
+     * WARNING! Using this with unchecked inputs WILL lead to SQL injection
+     * vulnerabilities. The input is not checked or escaped by Kysely in any way.
+     *
+     * ```ts
+     * const firstName = "'first_name'"
+     *
+     * sql`select * from person where first_name = ${sql.raw(firstName)}`
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select * from person where first_name = 'first_name'
+     * ```
+     *
+     * Note that the difference to `sql.lit` is that this function
+     * doesn't assume the inputs are values. The input to this function
+     * can be any sql and it's simply glued to the parent string as-is.
+     */
+    raw<R = unknown>(anySql: string): RawBuilder<R>;
+    /**
+     * This can be used to add lists of things to SQL snippets.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * import type { Person } from 'type-editor' // imaginary module
+     *
+     * function findByNicknames(nicknames: string[]): Promise<Person[]> {
+     *   return db
+     *     .selectFrom('person')
+     *     .selectAll()
+     *     .where('nicknames', '@>', sql<string[]>`ARRAY[${sql.join(nicknames)}]`)
+     *     .execute()
+     * }
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select * from "person"
+     * where "nicknames" @> ARRAY[$1, $2, $3, $4, $5, $6, $7, $8]
+     * ```
+     *
+     * The second argument is the joining SQL expression that defaults
+     * to
+     *
+     * ```ts
+     * sql`, `
+     * ```
+     *
+     * In addition to values, items in the list can be also {@link sql}
+     * expressions, queries or anything else the normal substitutions
+     * support:
+     *
+     * ```ts
+     * const things = [
+     *   123,
+     *   sql`(1 == 1)`,
+     *   db.selectFrom('person').selectAll(),
+     *   sql.lit(false),
+     *   sql.id('first_name')
+     * ]
+     *
+     * sql`BEFORE ${sql.join(things, sql`::varchar, `)} AFTER`
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * BEFORE $1::varchar, (1 == 1)::varchar, (select * from "person")::varchar, false::varchar, "first_name" AFTER
+     * ```
+     */
+    join<T = unknown>(array: readonly unknown[], separator?: RawBuilder<any>): RawBuilder<T>;
+}
+export declare const sql: Sql;

package/dist/server/node_modules/kysely/dist/esm/raw-builder/sql.js

@@ -0,0 +1,82 @@
+/// <reference types="./sql.d.ts" />
+import { IdentifierNode } from '../operation-node/identifier-node.js';
+import { isOperationNodeSource } from '../operation-node/operation-node-source.js';
+import { RawNode } from '../operation-node/raw-node.js';
+import { ValueNode } from '../operation-node/value-node.js';
+import { parseStringReference } from '../parser/reference-parser.js';
+import { parseTable } from '../parser/table-parser.js';
+import { parseValueExpression } from '../parser/value-parser.js';
+import { createQueryId } from '../util/query-id.js';
+import { createRawBuilder } from './raw-builder.js';
+export const sql = Object.assign((sqlFragments, ...parameters) => {
+    return createRawBuilder({
+        queryId: createQueryId(),
+        rawNode: RawNode.create(sqlFragments, parameters?.map(parseParameter) ?? []),
+    });
+}, {
+    ref(columnReference) {
+        return createRawBuilder({
+            queryId: createQueryId(),
+            rawNode: RawNode.createWithChild(parseStringReference(columnReference)),
+        });
+    },
+    val(value) {
+        return createRawBuilder({
+            queryId: createQueryId(),
+            rawNode: RawNode.createWithChild(parseValueExpression(value)),
+        });
+    },
+    value(value) {
+        return this.val(value);
+    },
+    table(tableReference) {
+        return createRawBuilder({
+            queryId: createQueryId(),
+            rawNode: RawNode.createWithChild(parseTable(tableReference)),
+        });
+    },
+    id(...ids) {
+        const fragments = new Array(ids.length + 1).fill('.');
+        fragments[0] = '';
+        fragments[fragments.length - 1] = '';
+        return createRawBuilder({
+            queryId: createQueryId(),
+            rawNode: RawNode.create(fragments, ids.map(IdentifierNode.create)),
+        });
+    },
+    lit(value) {
+        return createRawBuilder({
+            queryId: createQueryId(),
+            rawNode: RawNode.createWithChild(ValueNode.createImmediate(value)),
+        });
+    },
+    literal(value) {
+        return this.lit(value);
+    },
+    raw(sql) {
+        return createRawBuilder({
+            queryId: createQueryId(),
+            rawNode: RawNode.createWithSql(sql),
+        });
+    },
+    join(array, separator = sql `, `) {
+        const nodes = new Array(Math.max(2 * array.length - 1, 0));
+        const sep = separator.toOperationNode();
+        for (let i = 0; i < array.length; ++i) {
+            nodes[2 * i] = parseParameter(array[i]);
+            if (i !== array.length - 1) {
+                nodes[2 * i + 1] = sep;
+            }
+        }
+        return createRawBuilder({
+            queryId: createQueryId(),
+            rawNode: RawNode.createWithChildren(nodes),
+        });
+    },
+});
+function parseParameter(param) {
+    if (isOperationNodeSource(param)) {
+        return param.toOperationNode();
+    }
+    return parseValueExpression(param);
+}

package/dist/server/node_modules/kysely/dist/esm/schema/alter-column-builder.d.ts

@@ -0,0 +1,53 @@
+import { AlterColumnNode } from '../operation-node/alter-column-node.js';
+import type { OperationNodeSource } from '../operation-node/operation-node-source.js';
+import { type DataTypeExpression } from '../parser/data-type-parser.js';
+import { type DefaultValueExpression } from '../parser/default-value-parser.js';
+export declare class AlterColumnBuilder {
+    #private;
+    constructor(column: string);
+    setDataType(dataType: DataTypeExpression): AlteredColumnBuilder;
+    setDefault(value: DefaultValueExpression): AlteredColumnBuilder;
+    dropDefault(): AlteredColumnBuilder;
+    setNotNull(): AlteredColumnBuilder;
+    dropNotNull(): AlteredColumnBuilder;
+    /**
+     * Simply calls the provided function passing `this` as the only argument. `$call` returns
+     * what the provided function returns.
+     */
+    $call<T>(func: (qb: this) => T): T;
+}
+/**
+ * Allows us to force consumers to do exactly one alteration to a column.
+ *
+ * One cannot do no alterations:
+ *
+ * ```ts
+ * await db.schema
+ *   .alterTable('person')
+ * //  .execute() // Property 'execute' does not exist on type 'AlteredColumnBuilder'.
+ * ```
+ *
+ * ```ts
+ * await db.schema
+ *   .alterTable('person')
+ * //  .alterColumn('age', (ac) => ac) // Type 'AlterColumnBuilder' is not assignable to type 'AlteredColumnBuilder'.
+ * //  .execute()
+ * ```
+ *
+ * One cannot do multiple alterations:
+ *
+ * ```ts
+ * await db.schema
+ *   .alterTable('person')
+ * //  .alterColumn('age', (ac) => ac.dropNotNull().setNotNull()) // Property 'setNotNull' does not exist on type 'AlteredColumnBuilder'.
+ * //  .execute()
+ * ```
+ *
+ * Which would now throw a compilation error, instead of a runtime error.
+ */
+export declare class AlteredColumnBuilder implements OperationNodeSource {
+    #private;
+    constructor(alterColumnNode: AlterColumnNode);
+    toOperationNode(): AlterColumnNode;
+}
+export type AlterColumnBuilderCallback = (builder: AlterColumnBuilder) => AlteredColumnBuilder;

package/dist/server/node_modules/kysely/dist/esm/schema/alter-column-builder.js

@@ -0,0 +1,70 @@
+/// <reference types="./alter-column-builder.d.ts" />
+import { AlterColumnNode } from '../operation-node/alter-column-node.js';
+import { parseDataTypeExpression, } from '../parser/data-type-parser.js';
+import { parseDefaultValueExpression, } from '../parser/default-value-parser.js';
+export class AlterColumnBuilder {
+    #column;
+    constructor(column) {
+        this.#column = column;
+    }
+    setDataType(dataType) {
+        return new AlteredColumnBuilder(AlterColumnNode.create(this.#column, 'dataType', parseDataTypeExpression(dataType)));
+    }
+    setDefault(value) {
+        return new AlteredColumnBuilder(AlterColumnNode.create(this.#column, 'setDefault', parseDefaultValueExpression(value)));
+    }
+    dropDefault() {
+        return new AlteredColumnBuilder(AlterColumnNode.create(this.#column, 'dropDefault', true));
+    }
+    setNotNull() {
+        return new AlteredColumnBuilder(AlterColumnNode.create(this.#column, 'setNotNull', true));
+    }
+    dropNotNull() {
+        return new AlteredColumnBuilder(AlterColumnNode.create(this.#column, 'dropNotNull', true));
+    }
+    /**
+     * Simply calls the provided function passing `this` as the only argument. `$call` returns
+     * what the provided function returns.
+     */
+    $call(func) {
+        return func(this);
+    }
+}
+/**
+ * Allows us to force consumers to do exactly one alteration to a column.
+ *
+ * One cannot do no alterations:
+ *
+ * ```ts
+ * await db.schema
+ *   .alterTable('person')
+ * //  .execute() // Property 'execute' does not exist on type 'AlteredColumnBuilder'.
+ * ```
+ *
+ * ```ts
+ * await db.schema
+ *   .alterTable('person')
+ * //  .alterColumn('age', (ac) => ac) // Type 'AlterColumnBuilder' is not assignable to type 'AlteredColumnBuilder'.
+ * //  .execute()
+ * ```
+ *
+ * One cannot do multiple alterations:
+ *
+ * ```ts
+ * await db.schema
+ *   .alterTable('person')
+ * //  .alterColumn('age', (ac) => ac.dropNotNull().setNotNull()) // Property 'setNotNull' does not exist on type 'AlteredColumnBuilder'.
+ * //  .execute()
+ * ```
+ *
+ * Which would now throw a compilation error, instead of a runtime error.
+ */
+export class AlteredColumnBuilder {
+    #alterColumnNode;
+    constructor(alterColumnNode) {
+        this.#alterColumnNode = alterColumnNode;
+    }
+    toOperationNode() {
+        return this.#alterColumnNode;
+    }
+}

package/dist/server/node_modules/kysely/dist/esm/schema/alter-table-add-foreign-key-constraint-builder.d.ts

@@ -0,0 +1,32 @@
+import { AlterTableNode } from '../operation-node/alter-table-node.js';
+import type { OperationNodeSource } from '../operation-node/operation-node-source.js';
+import type { OnModifyForeignAction } from '../operation-node/references-node.js';
+import type { CompiledQuery } from '../query-compiler/compiled-query.js';
+import type { QueryExecutor } from '../query-executor/query-executor.js';
+import type { Compilable } from '../util/compilable.js';
+import type { QueryId } from '../util/query-id.js';
+import type { ForeignKeyConstraintBuilder, ForeignKeyConstraintBuilderInterface } from './foreign-key-constraint-builder.js';
+export declare class AlterTableAddForeignKeyConstraintBuilder implements ForeignKeyConstraintBuilderInterface<AlterTableAddForeignKeyConstraintBuilder>, OperationNodeSource, Compilable {
+    #private;
+    constructor(props: AlterTableAddForeignKeyConstraintBuilderProps);
+    onDelete(onDelete: OnModifyForeignAction): AlterTableAddForeignKeyConstraintBuilder;
+    onUpdate(onUpdate: OnModifyForeignAction): AlterTableAddForeignKeyConstraintBuilder;
+    deferrable(): AlterTableAddForeignKeyConstraintBuilder;
+    notDeferrable(): AlterTableAddForeignKeyConstraintBuilder;
+    initiallyDeferred(): AlterTableAddForeignKeyConstraintBuilder;
+    initiallyImmediate(): AlterTableAddForeignKeyConstraintBuilder;
+    /**
+     * Simply calls the provided function passing `this` as the only argument. `$call` returns
+     * what the provided function returns.
+     */
+    $call<T>(func: (qb: this) => T): T;
+    toOperationNode(): AlterTableNode;
+    compile(): CompiledQuery;
+    execute(): Promise<void>;
+}
+export interface AlterTableAddForeignKeyConstraintBuilderProps {
+    readonly queryId: QueryId;
+    readonly executor: QueryExecutor;
+    readonly node: AlterTableNode;
+    readonly constraintBuilder: ForeignKeyConstraintBuilder;
+}

package/dist/server/node_modules/kysely/dist/esm/schema/alter-table-add-foreign-key-constraint-builder.js

@@ -0,0 +1,64 @@
+/// <reference types="./alter-table-add-foreign-key-constraint-builder.d.ts" />
+import { AddConstraintNode } from '../operation-node/add-constraint-node.js';
+import { AlterTableNode } from '../operation-node/alter-table-node.js';
+import { freeze } from '../util/object-utils.js';
+export class AlterTableAddForeignKeyConstraintBuilder {
+    #props;
+    constructor(props) {
+        this.#props = freeze(props);
+    }
+    onDelete(onDelete) {
+        return new AlterTableAddForeignKeyConstraintBuilder({
+            ...this.#props,
+            constraintBuilder: this.#props.constraintBuilder.onDelete(onDelete),
+        });
+    }
+    onUpdate(onUpdate) {
+        return new AlterTableAddForeignKeyConstraintBuilder({
+            ...this.#props,
+            constraintBuilder: this.#props.constraintBuilder.onUpdate(onUpdate),
+        });
+    }
+    deferrable() {
+        return new AlterTableAddForeignKeyConstraintBuilder({
+            ...this.#props,
+            constraintBuilder: this.#props.constraintBuilder.deferrable(),
+        });
+    }
+    notDeferrable() {
+        return new AlterTableAddForeignKeyConstraintBuilder({
+            ...this.#props,
+            constraintBuilder: this.#props.constraintBuilder.notDeferrable(),
+        });
+    }
+    initiallyDeferred() {
+        return new AlterTableAddForeignKeyConstraintBuilder({
+            ...this.#props,
+            constraintBuilder: this.#props.constraintBuilder.initiallyDeferred(),
+        });
+    }
+    initiallyImmediate() {
+        return new AlterTableAddForeignKeyConstraintBuilder({
+            ...this.#props,
+            constraintBuilder: this.#props.constraintBuilder.initiallyImmediate(),
+        });
+    }
+    /**
+     * Simply calls the provided function passing `this` as the only argument. `$call` returns
+     * what the provided function returns.
+     */
+    $call(func) {
+        return func(this);
+    }
+    toOperationNode() {
+        return this.#props.executor.transformQuery(AlterTableNode.cloneWithTableProps(this.#props.node, {
+            addConstraint: AddConstraintNode.create(this.#props.constraintBuilder.toOperationNode()),
+        }), this.#props.queryId);
+    }
+    compile() {
+        return this.#props.executor.compileQuery(this.toOperationNode(), this.#props.queryId);
+    }
+    async execute() {
+        await this.#props.executor.executeQuery(this.compile());
+    }
+}