noormme 1.0.0

package/dist/cjs/query-builder/insert-result.d.ts

@@ -0,0 +1,46 @@
+/**
+ * The result of an insert query.
+ *
+ * If the table has an auto incrementing primary key {@link insertId} will hold
+ * the generated id on dialects that support it. For example PostgreSQL doesn't
+ * return the id by default and {@link insertId} is undefined. On PostgreSQL you
+ * need to use {@link ReturningInterface.returning} or {@link ReturningInterface.returningAll}
+ * to get out the inserted id.
+ *
+ * {@link numInsertedOrUpdatedRows} holds the number of (actually) inserted rows.
+ * On MySQL, updated rows are counted twice when using `on duplicate key update`.
+ *
+ * ### Examples
+ *
+ * ```ts
+ * import type { NewPerson } from 'type-editor' // imaginary module
+ *
+ * async function insertPerson(person: NewPerson) {
+ *   const result = await db
+ *     .insertInto('person')
+ *     .values(person)
+ *     .executeTakeFirstOrThrow()
+ *
+ *   console.log(result.insertId) // relevant on MySQL
+ *   console.log(result.numInsertedOrUpdatedRows) // always relevant
+ * }
+ * ```
+ */
+export declare class InsertResult {
+    /**
+     * The auto incrementing primary key of the inserted row.
+     *
+     * This property can be undefined when the query contains an `on conflict`
+     * clause that makes the query succeed even when nothing gets inserted.
+     *
+     * This property is always undefined on dialects like PostgreSQL that
+     * don't return the inserted id by default. On those dialects you need
+     * to use the {@link ReturningInterface.returning | returning} method.
+     */
+    readonly insertId: bigint | undefined;
+    /**
+     * Affected rows count.
+     */
+    readonly numInsertedOrUpdatedRows: bigint | undefined;
+    constructor(insertId: bigint | undefined, numInsertedOrUpdatedRows: bigint | undefined);
+}

package/dist/cjs/query-builder/insert-result.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InsertResult = void 0;
+/**
+ * The result of an insert query.
+ *
+ * If the table has an auto incrementing primary key {@link insertId} will hold
+ * the generated id on dialects that support it. For example PostgreSQL doesn't
+ * return the id by default and {@link insertId} is undefined. On PostgreSQL you
+ * need to use {@link ReturningInterface.returning} or {@link ReturningInterface.returningAll}
+ * to get out the inserted id.
+ *
+ * {@link numInsertedOrUpdatedRows} holds the number of (actually) inserted rows.
+ * On MySQL, updated rows are counted twice when using `on duplicate key update`.
+ *
+ * ### Examples
+ *
+ * ```ts
+ * import type { NewPerson } from 'type-editor' // imaginary module
+ *
+ * async function insertPerson(person: NewPerson) {
+ *   const result = await db
+ *     .insertInto('person')
+ *     .values(person)
+ *     .executeTakeFirstOrThrow()
+ *
+ *   console.log(result.insertId) // relevant on MySQL
+ *   console.log(result.numInsertedOrUpdatedRows) // always relevant
+ * }
+ * ```
+ */
+class InsertResult {
+    /**
+     * The auto incrementing primary key of the inserted row.
+     *
+     * This property can be undefined when the query contains an `on conflict`
+     * clause that makes the query succeed even when nothing gets inserted.
+     *
+     * This property is always undefined on dialects like PostgreSQL that
+     * don't return the inserted id by default. On those dialects you need
+     * to use the {@link ReturningInterface.returning | returning} method.
+     */
+    insertId;
+    /**
+     * Affected rows count.
+     */
+    numInsertedOrUpdatedRows;
+    constructor(insertId, numInsertedOrUpdatedRows) {
+        this.insertId = insertId;
+        this.numInsertedOrUpdatedRows = numInsertedOrUpdatedRows;
+    }
+}
+exports.InsertResult = InsertResult;

package/dist/cjs/query-builder/join-builder.d.ts

@@ -0,0 +1,38 @@
+import { JoinNode } from '../operation-node/join-node.js';
+import { OperationNodeSource } from '../operation-node/operation-node-source.js';
+import { ComparisonOperatorExpression, OperandValueExpressionOrList } from '../parser/binary-operation-parser.js';
+import { ExpressionOrFactory } from '../parser/expression-parser.js';
+import { ReferenceExpression } from '../parser/reference-parser.js';
+import { SqlBool } from '../util/type-utils.js';
+export declare class JoinBuilder<DB, TB extends keyof DB> implements OperationNodeSource {
+    #private;
+    constructor(props: JoinBuilderProps);
+    /**
+     * Just like {@link WhereInterface.where} but adds an item to the join's
+     * `on` clause instead.
+     *
+     * See {@link WhereInterface.where} for documentation and examples.
+     */
+    on<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): JoinBuilder<DB, TB>;
+    on(expression: ExpressionOrFactory<DB, TB, SqlBool>): JoinBuilder<DB, TB>;
+    /**
+     * Just like {@link WhereInterface.whereRef} but adds an item to the join's
+     * `on` clause instead.
+     *
+     * See {@link WhereInterface.whereRef} for documentation and examples.
+     */
+    onRef(lhs: ReferenceExpression<DB, TB>, op: ComparisonOperatorExpression, rhs: ReferenceExpression<DB, TB>): JoinBuilder<DB, TB>;
+    /**
+     * Adds `on true`.
+     */
+    onTrue(): JoinBuilder<DB, TB>;
+    /**
+     * 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(): JoinNode;
+}
+export interface JoinBuilderProps {
+    readonly joinNode: JoinNode;
+}

package/dist/cjs/query-builder/join-builder.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JoinBuilder = void 0;
+const join_node_js_1 = require("../operation-node/join-node.js");
+const raw_node_js_1 = require("../operation-node/raw-node.js");
+const binary_operation_parser_js_1 = require("../parser/binary-operation-parser.js");
+const object_utils_js_1 = require("../util/object-utils.js");
+class JoinBuilder {
+    #props;
+    constructor(props) {
+        this.#props = (0, object_utils_js_1.freeze)(props);
+    }
+    on(...args) {
+        return new JoinBuilder({
+            ...this.#props,
+            joinNode: join_node_js_1.JoinNode.cloneWithOn(this.#props.joinNode, (0, binary_operation_parser_js_1.parseValueBinaryOperationOrExpression)(args)),
+        });
+    }
+    /**
+     * Just like {@link WhereInterface.whereRef} but adds an item to the join's
+     * `on` clause instead.
+     *
+     * See {@link WhereInterface.whereRef} for documentation and examples.
+     */
+    onRef(lhs, op, rhs) {
+        return new JoinBuilder({
+            ...this.#props,
+            joinNode: join_node_js_1.JoinNode.cloneWithOn(this.#props.joinNode, (0, binary_operation_parser_js_1.parseReferentialBinaryOperation)(lhs, op, rhs)),
+        });
+    }
+    /**
+     * Adds `on true`.
+     */
+    onTrue() {
+        return new JoinBuilder({
+            ...this.#props,
+            joinNode: join_node_js_1.JoinNode.cloneWithOn(this.#props.joinNode, raw_node_js_1.RawNode.createWithSql('true')),
+        });
+    }
+    /**
+     * 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.joinNode;
+    }
+}
+exports.JoinBuilder = JoinBuilder;

package/dist/cjs/query-builder/json-path-builder.d.ts

@@ -0,0 +1,294 @@
+import { AliasableExpression, AliasedExpression, Expression } from '../expression/expression.js';
+import { AliasNode } from '../operation-node/alias-node.js';
+import { JSONPathNode } from '../operation-node/json-path-node.js';
+import { JSONReferenceNode } from '../operation-node/json-reference-node.js';
+import { OperationNode } from '../operation-node/operation-node.js';
+export declare class JSONPathBuilder<S, O = S> {
+    #private;
+    constructor(node: JSONReferenceNode | JSONPathNode);
+    /**
+     * Access an element of a JSON array in a specific location.
+     *
+     * Since there's no guarantee an element exists in the given array location, the
+     * resulting type is always nullable. If you're sure the element exists, you
+     * should use {@link SelectQueryBuilder.$assertType} to narrow the type safely.
+     *
+     * See also {@link key} to access properties of JSON objects.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * await db.selectFrom('person')
+     *   .select(eb =>
+     *     eb.ref('nicknames', '->').at(0).as('primary_nickname')
+     *   )
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select "nicknames"->0 as "primary_nickname" from "person"
+     *```
+     *
+     * Combined with {@link key}:
+     *
+     * ```ts
+     * db.selectFrom('person').select(eb =>
+     *   eb.ref('experience', '->').at(0).key('role').as('first_role')
+     * )
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select "experience"->0->'role' as "first_role" from "person"
+     * ```
+     *
+     * You can use `'last'` to access the last element of the array in MySQL:
+     *
+     * ```ts
+     * db.selectFrom('person').select(eb =>
+     *   eb.ref('nicknames', '->$').at('last').as('last_nickname')
+     * )
+     * ```
+     *
+     * The generated SQL (MySQL):
+     *
+     * ```sql
+     * select `nicknames`->'$[last]' as `last_nickname` from `person`
+     * ```
+     *
+     * Or `'#-1'` in SQLite:
+     *
+     * ```ts
+     * db.selectFrom('person').select(eb =>
+     *   eb.ref('nicknames', '->>$').at('#-1').as('last_nickname')
+     * )
+     * ```
+     *
+     * The generated SQL (SQLite):
+     *
+     * ```sql
+     * select "nicknames"->>'$[#-1]' as `last_nickname` from `person`
+     * ```
+     */
+    at<I extends any[] extends O ? number | 'last' | `#-${number}` : never, O2 = null | NonNullable<NonNullable<O>[keyof NonNullable<O> & number]>>(index: `${I}` extends `${any}.${any}` | `#--${any}` ? never : I): TraversedJSONPathBuilder<S, O2>;
+    /**
+     * Access a property of a JSON object.
+     *
+     * If a field is optional, the resulting type will be nullable.
+     *
+     * See also {@link at} to access elements of JSON arrays.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.selectFrom('person').select(eb =>
+     *   eb.ref('address', '->').key('city').as('city')
+     * )
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select "address"->'city' as "city" from "person"
+     * ```
+     *
+     * Going deeper:
+     *
+     * ```ts
+     * db.selectFrom('person').select(eb =>
+     *   eb.ref('profile', '->$').key('website').key('url').as('website_url')
+     * )
+     * ```
+     *
+     * The generated SQL (MySQL):
+     *
+     * ```sql
+     * select `profile`->'$.website.url' as `website_url` from `person`
+     * ```
+     *
+     * Combined with {@link at}:
+     *
+     * ```ts
+     * db.selectFrom('person').select(eb =>
+     *   eb.ref('profile', '->').key('addresses').at(0).key('city').as('city')
+     * )
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select "profile"->'addresses'->0->'city' as "city" from "person"
+     * ```
+     */
+    key<K extends any[] extends O ? never : O extends object ? keyof NonNullable<O> & string : never, O2 = undefined extends O ? null | NonNullable<NonNullable<O>[K]> : null extends O ? null | NonNullable<NonNullable<O>[K]> : string extends keyof NonNullable<O> ? null | NonNullable<NonNullable<O>[K]> : NonNullable<O>[K]>(key: K): TraversedJSONPathBuilder<S, O2>;
+}
+export declare class TraversedJSONPathBuilder<S, O> extends JSONPathBuilder<S, O> implements AliasableExpression<O> {
+    #private;
+    constructor(node: JSONReferenceNode | JSONPathNode);
+    /** @private */
+    /**
+     * All expressions need to have this getter for complicated type-related reasons.
+     * Simply add this getter for your expression and always return `undefined` from it:
+     *
+     * ### Examples
+     *
+     * ```ts
+     * import { type Expression, type OperationNode, sql } from 'kysely'
+     *
+     * class SomeExpression<T> implements Expression<T> {
+     *   get expressionType(): T | undefined {
+     *     return undefined
+     *   }
+     *
+     *   toOperationNode(): OperationNode {
+     *     return sql`some sql here`.toOperationNode()
+     *   }
+     * }
+     * ```
+     *
+     * The getter is needed to make the expression assignable to another expression only
+     * if the types `T` are assignable. Without this property (or some other property
+     * that references `T`), you could assing `Expression<string>` to `Expression<number>`.
+     */
+    get expressionType(): O | undefined;
+    /**
+     * Returns an aliased version of the expression.
+     *
+     * In addition to slapping `as "the_alias"` to the end of the SQL,
+     * this method also provides strict typing:
+     *
+     * ```ts
+     * const result = await db
+     *   .selectFrom('person')
+     *   .select(eb =>
+     *     eb('first_name', '=', 'Jennifer').as('is_jennifer')
+     *   )
+     *   .executeTakeFirstOrThrow()
+     *
+     * // `is_jennifer: SqlBool` field exists in the result type.
+     * console.log(result.is_jennifer)
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select "first_name" = $1 as "is_jennifer"
+     * from "person"
+     * ```
+     */
+    as<A extends string>(alias: A): AliasedExpression<O, A>;
+    /**
+     * Returns an aliased version of the expression.
+     *
+     * ### Examples
+     *
+     * In addition to slapping `as "the_alias"` at the end of the expression,
+     * this method also provides strict typing:
+     *
+     * ```ts
+     * const result = await db
+     *   .selectFrom('person')
+     *   .select((eb) =>
+     *     // `eb.fn<string>` returns an AliasableExpression<string>
+     *     eb.fn<string>('concat', ['first_name', eb.val(' '), 'last_name']).as('full_name')
+     *   )
+     *   .executeTakeFirstOrThrow()
+     *
+     * // `full_name: string` field exists in the result type.
+     * console.log(result.full_name)
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select
+     *   concat("first_name", $1, "last_name") as "full_name"
+     * from
+     *   "person"
+     * ```
+     *
+     * You can also pass in a raw SQL snippet (or any expression) but in that case you must
+     * provide the alias as the only type argument:
+     *
+     * ```ts
+     * import { sql } from 'kysely'
+     *
+     * const values = sql<{ a: number, b: string }>`(values (1, 'foo'))`
+     *
+     * // The alias is `t(a, b)` which specifies the column names
+     * // in addition to the table name. We must tell kysely that
+     * // columns of the table can be referenced through `t`
+     * // by providing an explicit type argument.
+     * const aliasedValues = values.as<'t'>(sql`t(a, b)`)
+     *
+     * await db
+     *   .insertInto('person')
+     *   .columns(['first_name', 'last_name'])
+     *   .expression(
+     *     db.selectFrom(aliasedValues).select(['t.a', 't.b'])
+     *   )
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * insert into "person" ("first_name", "last_name")
+     * from (values (1, 'foo')) as t(a, b)
+     * select "t"."a", "t"."b"
+     * ```
+     */
+    as<A extends string>(alias: Expression<unknown>): AliasedExpression<O, A>;
+    /**
+     * Change the output type of the json path.
+     *
+     * This method call doesn't change the SQL in any way. This methods simply
+     * returns a copy of this `JSONPathBuilder` with a new output type.
+     */
+    $castTo<O2>(): TraversedJSONPathBuilder<S, O2>;
+    $notNull(): TraversedJSONPathBuilder<S, Exclude<O, null>>;
+    /**
+     * Creates the OperationNode that describes how to compile this expression into SQL.
+     *
+     * ### Examples
+     *
+     * If you are creating a custom expression, it's often easiest to use the {@link sql}
+     * template tag to build the node:
+     *
+     * ```ts
+     * import { type Expression, type OperationNode, sql } from 'kysely'
+     *
+     * class SomeExpression<T> implements Expression<T> {
+     *   get expressionType(): T | undefined {
+     *     return undefined
+     *   }
+     *
+     *   toOperationNode(): OperationNode {
+     *     return sql`some sql here`.toOperationNode()
+     *   }
+     * }
+     * ```
+     */
+    toOperationNode(): OperationNode;
+}
+export declare class AliasedJSONPathBuilder<O, A extends string> implements AliasedExpression<O, A> {
+    #private;
+    constructor(jsonPath: TraversedJSONPathBuilder<any, O>, alias: A | Expression<unknown>);
+    /** @private */
+    /**
+     * Returns the aliased expression.
+     */
+    get expression(): Expression<O>;
+    /** @private */
+    /**
+     * Returns the alias.
+     */
+    get alias(): A | Expression<unknown>;
+    /**
+     * Creates the OperationNode that describes how to compile this expression into SQL.
+     */
+    toOperationNode(): AliasNode;
+}

package/dist/cjs/query-builder/json-path-builder.js

@@ -0,0 +1,200 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AliasedJSONPathBuilder = exports.TraversedJSONPathBuilder = exports.JSONPathBuilder = void 0;
+const alias_node_js_1 = require("../operation-node/alias-node.js");
+const identifier_node_js_1 = require("../operation-node/identifier-node.js");
+const json_operator_chain_node_js_1 = require("../operation-node/json-operator-chain-node.js");
+const json_path_leg_node_js_1 = require("../operation-node/json-path-leg-node.js");
+const json_path_node_js_1 = require("../operation-node/json-path-node.js");
+const json_reference_node_js_1 = require("../operation-node/json-reference-node.js");
+const operation_node_source_js_1 = require("../operation-node/operation-node-source.js");
+const value_node_js_1 = require("../operation-node/value-node.js");
+class JSONPathBuilder {
+    #node;
+    constructor(node) {
+        this.#node = node;
+    }
+    /**
+     * Access an element of a JSON array in a specific location.
+     *
+     * Since there's no guarantee an element exists in the given array location, the
+     * resulting type is always nullable. If you're sure the element exists, you
+     * should use {@link SelectQueryBuilder.$assertType} to narrow the type safely.
+     *
+     * See also {@link key} to access properties of JSON objects.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * await db.selectFrom('person')
+     *   .select(eb =>
+     *     eb.ref('nicknames', '->').at(0).as('primary_nickname')
+     *   )
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select "nicknames"->0 as "primary_nickname" from "person"
+     *```
+     *
+     * Combined with {@link key}:
+     *
+     * ```ts
+     * db.selectFrom('person').select(eb =>
+     *   eb.ref('experience', '->').at(0).key('role').as('first_role')
+     * )
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select "experience"->0->'role' as "first_role" from "person"
+     * ```
+     *
+     * You can use `'last'` to access the last element of the array in MySQL:
+     *
+     * ```ts
+     * db.selectFrom('person').select(eb =>
+     *   eb.ref('nicknames', '->$').at('last').as('last_nickname')
+     * )
+     * ```
+     *
+     * The generated SQL (MySQL):
+     *
+     * ```sql
+     * select `nicknames`->'$[last]' as `last_nickname` from `person`
+     * ```
+     *
+     * Or `'#-1'` in SQLite:
+     *
+     * ```ts
+     * db.selectFrom('person').select(eb =>
+     *   eb.ref('nicknames', '->>$').at('#-1').as('last_nickname')
+     * )
+     * ```
+     *
+     * The generated SQL (SQLite):
+     *
+     * ```sql
+     * select "nicknames"->>'$[#-1]' as `last_nickname` from `person`
+     * ```
+     */
+    at(index) {
+        return this.#createBuilderWithPathLeg('ArrayLocation', index);
+    }
+    /**
+     * Access a property of a JSON object.
+     *
+     * If a field is optional, the resulting type will be nullable.
+     *
+     * See also {@link at} to access elements of JSON arrays.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.selectFrom('person').select(eb =>
+     *   eb.ref('address', '->').key('city').as('city')
+     * )
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select "address"->'city' as "city" from "person"
+     * ```
+     *
+     * Going deeper:
+     *
+     * ```ts
+     * db.selectFrom('person').select(eb =>
+     *   eb.ref('profile', '->$').key('website').key('url').as('website_url')
+     * )
+     * ```
+     *
+     * The generated SQL (MySQL):
+     *
+     * ```sql
+     * select `profile`->'$.website.url' as `website_url` from `person`
+     * ```
+     *
+     * Combined with {@link at}:
+     *
+     * ```ts
+     * db.selectFrom('person').select(eb =>
+     *   eb.ref('profile', '->').key('addresses').at(0).key('city').as('city')
+     * )
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select "profile"->'addresses'->0->'city' as "city" from "person"
+     * ```
+     */
+    key(key) {
+        return this.#createBuilderWithPathLeg('Member', key);
+    }
+    #createBuilderWithPathLeg(legType, value) {
+        if (json_reference_node_js_1.JSONReferenceNode.is(this.#node)) {
+            return new TraversedJSONPathBuilder(json_reference_node_js_1.JSONReferenceNode.cloneWithTraversal(this.#node, json_path_node_js_1.JSONPathNode.is(this.#node.traversal)
+                ? json_path_node_js_1.JSONPathNode.cloneWithLeg(this.#node.traversal, json_path_leg_node_js_1.JSONPathLegNode.create(legType, value))
+                : json_operator_chain_node_js_1.JSONOperatorChainNode.cloneWithValue(this.#node.traversal, value_node_js_1.ValueNode.createImmediate(value))));
+        }
+        return new TraversedJSONPathBuilder(json_path_node_js_1.JSONPathNode.cloneWithLeg(this.#node, json_path_leg_node_js_1.JSONPathLegNode.create(legType, value)));
+    }
+}
+exports.JSONPathBuilder = JSONPathBuilder;
+class TraversedJSONPathBuilder extends JSONPathBuilder {
+    #node;
+    constructor(node) {
+        super(node);
+        this.#node = node;
+    }
+    /** @private */
+    get expressionType() {
+        return undefined;
+    }
+    as(alias) {
+        return new AliasedJSONPathBuilder(this, alias);
+    }
+    /**
+     * Change the output type of the json path.
+     *
+     * This method call doesn't change the SQL in any way. This methods simply
+     * returns a copy of this `JSONPathBuilder` with a new output type.
+     */
+    $castTo() {
+        return new TraversedJSONPathBuilder(this.#node);
+    }
+    $notNull() {
+        return new TraversedJSONPathBuilder(this.#node);
+    }
+    toOperationNode() {
+        return this.#node;
+    }
+}
+exports.TraversedJSONPathBuilder = TraversedJSONPathBuilder;
+class AliasedJSONPathBuilder {
+    #jsonPath;
+    #alias;
+    constructor(jsonPath, alias) {
+        this.#jsonPath = jsonPath;
+        this.#alias = alias;
+    }
+    /** @private */
+    get expression() {
+        return this.#jsonPath;
+    }
+    /** @private */
+    get alias() {
+        return this.#alias;
+    }
+    toOperationNode() {
+        return alias_node_js_1.AliasNode.create(this.#jsonPath.toOperationNode(), (0, operation_node_source_js_1.isOperationNodeSource)(this.#alias)
+            ? this.#alias.toOperationNode()
+            : identifier_node_js_1.IdentifierNode.create(this.#alias));
+    }
+}
+exports.AliasedJSONPathBuilder = AliasedJSONPathBuilder;