kysely 0.16.4 → 0.16.8

package/README.md

@@ -3,14 +3,15 @@
 
 # [Kysely](https://koskimas.github.io/kysely/index.html)
 
-A type-safe and autocompletion-friendly typescript SQL query builder for node.js. Inspired by
-[knex](http://knexjs.org/).
+A type-safe and autocompletion-friendly typescript SQL query builder. Inspired by [knex](http://knexjs.org/).
+Mainly developed for [node.js](https://nodejs.org/en/) but also runs on [deno](https://deno.land/) and
+in the browser.
 
 ![](https://github.com/koskimas/kysely/blob/master/assets/demo.gif)
 
-Kysely's typings make sure you only refer to tables and columns that are visible to the part of the query
-you are writing. The result type only has the selected columns with correct types and aliases. This 
-allows tools like vscode autocompletion to make your life so much easier.
+Kysely makes sure you only refer to tables and columns that are visible to the part of the query
+you are writing. The result type only has the selected columns with correct types and aliases. As an
+added bonus you get autocompletion for all that stuff.
 
 As you can see in the gif above, through the pure magic of modern typescript, Kysely is even able to parse
 the alias given to `pet.name` and add the `pet_name` column to the result row type. Kysely is able to infer
@@ -32,7 +33,10 @@ You can find a more thorough introduction [here](https://www.jakso.me/blog/kysel
 - [Installation](#installation)
 - [Minimal example](#minimal-example)
 - [Query examples](#query-examples)
+- [Recipes](https://github.com/koskimas/kysely/tree/master/recipes)
 - [Migrations](#migrations)
+- [Deno](#deno)
+- [Browser](#browser)
 - [API reference](https://koskimas.github.io/kysely/index.html)
 - [Changelog](https://github.com/koskimas/kysely/releases)
 
@@ -341,6 +345,8 @@ async function migrateToLatest() {
     console.error(error)
     process.exit(1)
   }
+
+  await db.destroy()
 }
 
 migrateToLatest()
@@ -350,6 +356,113 @@ The migration methods use a lock on the database level, and parallel calls are e
 This means that you can safely call `migrateToLatest` and other migration methods from multiple
 server instances simultaneously and the migrations are guaranteed to only be executed once.
 
+# Deno
+
+Kysely doesn't include drivers for deno, but you can still use Kysely as a query builder
+or implement your own driver:
+
+```ts
+// We use jsdeliver to get Kysely from npm. We also need to
+// import the `dist/esm/index-nodeless.js` file instead of the
+// root which has node dependencies.
+import {
+  DummyDriver,
+  Generated,
+  Kysely,
+  PostgresAdapter,
+  PostgresIntrospector,
+  PostgresQueryCompiler,
+} from 'https://cdn.jsdelivr.net/npm/kysely/dist/esm/index-nodeless.js'
+
+interface Person {
+  id: Generated<number>
+  first_name: string
+  last_name: string | null
+}
+
+interface Database {
+  person: Person
+}
+
+const db = new Kysely<Database>({
+  dialect: {
+    createAdapter() {
+      return new PostgresAdapter()
+    },
+    createDriver() {
+      // You need a driver to be able to execute queries. In this example
+      // we use the dummy driver that never does anything.
+      return new DummyDriver()
+    },
+    createIntrospector(db: Kysely<unknown>) {
+      return new PostgresIntrospector(db)
+    },
+    createQueryCompiler() {
+      return new PostgresQueryCompiler()
+    },
+  },
+})
+
+const query = db.selectFrom('person').select('id')
+const sql = query.compile()
+
+console.log(sql.sql)
+```
+
+# Browser
+
+Kysely also runs in the browser as long as you import the `dist/esm/index-nodeless.js`
+module instead of the root that has node dependencies. You can also import the
+`dist/cjs/index-nodeless.js` file if you are using commonjs modules instead of ESM.
+
+```ts
+import {
+  Kysely,
+  Generated,
+  DummyDriver,
+  SqliteAdapter,
+  SqliteIntrospector,
+  SqliteQueryCompiler,
+} from 'kysely/dist/esm/index-nodeless.js'
+
+interface Person {
+  id: Generated<number>
+  first_name: string
+  last_name: string | null
+}
+
+interface Database {
+  person: Person
+}
+
+const db = new Kysely<Database>({
+  dialect: {
+    createAdapter() {
+      return new SqliteAdapter()
+    },
+    createDriver() {
+      return new DummyDriver()
+    },
+    createIntrospector(db: Kysely<unknown>) {
+      return new SqliteIntrospector(db)
+    },
+    createQueryCompiler() {
+      return new SqliteQueryCompiler()
+    },
+  },
+})
+
+window.addEventListener('load', () => {
+  const sql = db.selectFrom('person').select('id').compile()
+
+  const result = document.createElement('span')
+  result.id = 'result'
+  result.innerHTML = sql.sql
+
+  document.body.appendChild(result)
+})
+```
+
 # Why not just contribute to knex
 
 Kysely is very similar to knex, but it also attempts to fix things that I personally find not-so-good

package/dist/cjs/dialect/mysql/mysql-dialect.js

@@ -5,6 +5,7 @@ const mysql_driver_js_1 = require("./mysql-driver.js");
 const mysql_query_compiler_js_1 = require("./mysql-query-compiler.js");
 const mysql_introspector_js_1 = require("./mysql-introspector.js");
 const mysql_adapter_js_1 = require("./mysql-adapter.js");
+const object_utils_js_1 = require("../../util/object-utils.js");
 /**
  * MySQL dialect that uses the [mysql2](https://github.com/sidorares/node-mysql2#readme) library.
  *
@@ -15,7 +16,7 @@ const mysql_adapter_js_1 = require("./mysql-adapter.js");
 class MysqlDialect {
     #config;
     constructor(config) {
-        this.#config = config;
+        this.#config = (0, object_utils_js_1.freeze)({ ...config });
     }
     createDriver() {
         return new mysql_driver_js_1.MysqlDriver(this.#config);

package/dist/cjs/dialect/mysql/mysql-driver.js

@@ -9,7 +9,7 @@ class MysqlDriver {
     #connections = new WeakMap();
     #pool;
     constructor(config) {
-        this.#config = config;
+        this.#config = (0, object_utils_js_1.freeze)({ ...config });
     }
     async init() {
         // Import the `mysql2` module here instead at the top of the file

package/dist/cjs/dialect/postgres/postgres-dialect.js

@@ -5,6 +5,7 @@ const postgres_driver_js_1 = require("./postgres-driver.js");
 const postgres_introspector_js_1 = require("./postgres-introspector.js");
 const postgres_query_compiler_js_1 = require("./postgres-query-compiler.js");
 const postgres_adapter_js_1 = require("./postgres-adapter.js");
+const object_utils_js_1 = require("../../util/object-utils.js");
 /**
  * PostgreSQL dialect that uses the [pg](https://node-postgres.com/) library.
  *
@@ -18,7 +19,7 @@ const postgres_adapter_js_1 = require("./postgres-adapter.js");
 class PostgresDialect {
     #config;
     constructor(config) {
-        this.#config = config;
+        this.#config = (0, object_utils_js_1.freeze)({ ...config });
     }
     createDriver() {
         return new postgres_driver_js_1.PostgresDriver(this.#config);

package/dist/cjs/dialect/postgres/postgres-driver.js

@@ -9,7 +9,7 @@ class PostgresDriver {
     #connections = new WeakMap();
     #pool = null;
     constructor(config) {
-        this.#config = config;
+        this.#config = (0, object_utils_js_1.freeze)({ ...config });
     }
     async init() {
         // Import the `pg` module here instead at the top of the file

package/dist/cjs/dialect/sqlite/sqlite-dialect.js

@@ -5,6 +5,7 @@ const sqlite_driver_js_1 = require("./sqlite-driver.js");
 const sqlite_query_compiler_js_1 = require("./sqlite-query-compiler.js");
 const sqlite_introspector_js_1 = require("./sqlite-introspector.js");
 const sqlite_adapter_js_1 = require("./sqlite-adapter.js");
+const object_utils_js_1 = require("../../util/object-utils.js");
 /**
  * SQLite dialect that uses the [better-sqlite3](https://github.com/JoshuaWise/better-sqlite3) library.
  *
@@ -15,7 +16,7 @@ const sqlite_adapter_js_1 = require("./sqlite-adapter.js");
 class SqliteDialect {
     #config;
     constructor(config) {
-        this.#config = config;
+        this.#config = (0, object_utils_js_1.freeze)({ ...config });
     }
     createDriver() {
         return new sqlite_driver_js_1.SqliteDriver(this.#config);

package/dist/cjs/dialect/sqlite/sqlite-driver.js

@@ -9,7 +9,7 @@ class SqliteDriver {
     #db;
     #connection;
     constructor(config) {
-        this.#config = config;
+        this.#config = (0, object_utils_js_1.freeze)({ ...config });
     }
     async init() {
         // Import the `better-sqlite3` module here instead at the top of the file

package/dist/cjs/driver/dummy-driver.d.ts

@@ -0,0 +1,68 @@
+import { DatabaseConnection } from './database-connection.js';
+import { Driver } from './driver.js';
+/**
+ * A driver that does absolutely nothing.
+ *
+ * You can use this to create Kysely instances solely for building queries
+ *
+ * ### Examples
+ *
+ * This example creates a Kysely instance for building postgres queries:
+ *
+ * ```ts
+ * const db = new Kysely<Database>({
+ *   dialect: {
+ *     createAdapter() {
+ *       return new PostgresAdapter()
+ *     },
+ *     createDriver() {
+ *       return new DummyDriver()
+ *     },
+ *     createIntrospector(db: Kysely<any>) {
+ *       return new PostgresIntrospector(db)
+ *     },
+ *     createQueryCompiler() {
+ *       return new PostgresQueryCompiler()
+ *     },
+ *   },
+ * })
+ * ```
+ */
+export declare class DummyDriver implements Driver {
+    /**
+     * Initializes the driver.
+     *
+     * After calling this method the driver should be usable and `acquireConnection` etc.
+     * methods should be callable.
+     *
+     * IMPORTANT: The underlying database engine driver (like [pg](https://node-postgres.com/))
+     * should be imported inside this function, not at the top of the driver file! This is
+     * important so that Kysely is usable without installing all database driver libraries
+     * it supports.
+     */
+    init(): Promise<void>;
+    /**
+     * Acquires a new connection from the pool.
+     */
+    acquireConnection(): Promise<DatabaseConnection>;
+    /**
+     * Begins a transaction.
+     */
+    beginTransaction(): Promise<void>;
+    /**
+     * Commits a transaction.
+     */
+    commitTransaction(): Promise<void>;
+    /**
+     * Rolls back a transaction.
+     */
+    rollbackTransaction(): Promise<void>;
+    /**
+     * Releases a connection back to the pool.
+     */
+    releaseConnection(): Promise<void>;
+    /**
+     * Destroys the driver and releases all resources.
+     */
+    destroy(): Promise<void>;
+}

package/dist/cjs/driver/dummy-driver.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DummyDriver = void 0;
+/**
+ * A driver that does absolutely nothing.
+ *
+ * You can use this to create Kysely instances solely for building queries
+ *
+ * ### Examples
+ *
+ * This example creates a Kysely instance for building postgres queries:
+ *
+ * ```ts
+ * const db = new Kysely<Database>({
+ *   dialect: {
+ *     createAdapter() {
+ *       return new PostgresAdapter()
+ *     },
+ *     createDriver() {
+ *       return new DummyDriver()
+ *     },
+ *     createIntrospector(db: Kysely<any>) {
+ *       return new PostgresIntrospector(db)
+ *     },
+ *     createQueryCompiler() {
+ *       return new PostgresQueryCompiler()
+ *     },
+ *   },
+ * })
+ * ```
+ */
+class DummyDriver {
+    async init() {
+        // Nothing to do here.
+    }
+    async acquireConnection() {
+        return new DummyConnection();
+    }
+    async beginTransaction() {
+        // Nothing to do here.
+    }
+    async commitTransaction() {
+        // Nothing to do here.
+    }
+    async rollbackTransaction() {
+        // Nothing to do here.
+    }
+    async releaseConnection() {
+        // Nothing to do here.
+    }
+    async destroy() {
+        // Nothing to do here.
+    }
+}
+exports.DummyDriver = DummyDriver;
+class DummyConnection {
+    async executeQuery() {
+        return {
+            rows: [],
+        };
+    }
+}

package/dist/cjs/driver/runtime-driver.d.ts

@@ -28,7 +28,7 @@ export declare class RuntimeDriver implements Driver {
     /**
      * Releases a connection back to the pool.
      */
-    releaseConnection(runtimeConnection: DatabaseConnection): Promise<void>;
+    releaseConnection(connection: DatabaseConnection): Promise<void>;
     /**
      * Begins a transaction.
      */

package/dist/cjs/driver/runtime-driver.js

@@ -12,7 +12,7 @@ class RuntimeDriver {
     #log;
     #initPromise;
     #destroyPromise;
-    #connections = new WeakMap();
+    #connections = new WeakSet();
     constructor(driver, log) {
         this.#driver = driver;
         this.#log = log;
@@ -29,17 +29,16 @@ class RuntimeDriver {
     async acquireConnection() {
         await this.init();
         const connection = await this.#driver.acquireConnection();
-        let runtimeConnection = this.#connections.get(connection);
-        if (!runtimeConnection) {
-            runtimeConnection = new RuntimeConnection(connection, this.#log);
-            this.#connections.set(connection, runtimeConnection);
+        if (!this.#connections.has(connection)) {
+            if (this.#needsLogging()) {
+                this.#addLogging(connection);
+            }
+            this.#connections.add(connection);
         }
-        return runtimeConnection;
+        return connection;
     }
-    async releaseConnection(runtimeConnection) {
-        if (runtimeConnection instanceof RuntimeConnection) {
-            await this.#driver.releaseConnection(runtimeConnection.connection);
-        }
+    async releaseConnection(connection) {
+        await this.#driver.releaseConnection(connection);
     }
     beginTransaction(connection, settings) {
         return this.#driver.beginTransaction(connection, settings);
@@ -63,30 +62,27 @@ class RuntimeDriver {
         }
         await this.#destroyPromise;
     }
-}
-exports.RuntimeDriver = RuntimeDriver;
-class RuntimeConnection {
-    #connection;
-    #log;
-    get connection() {
-        return this.#connection;
-    }
-    constructor(connection, log) {
-        this.#connection = connection;
-        this.#log = log;
+    #needsLogging() {
+        return (this.#log.isLevelEnabled('query') || this.#log.isLevelEnabled('error'));
     }
-    async executeQuery(compiledQuery) {
-        const startTime = (0, performance_now_js_1.performanceNow)();
-        try {
-            return await this.#connection.executeQuery(compiledQuery);
-        }
-        catch (error) {
-            this.#logError(error);
-            throw error;
-        }
-        finally {
-            this.#logQuery(compiledQuery, startTime);
-        }
+    // This method monkey patches the database connection's executeQuery method
+    // by adding logging code around it. Monkey patching is not pretty, but it's
+    // the best option in this case.
+    #addLogging(connection) {
+        const executeQuery = connection.executeQuery;
+        connection.executeQuery = async (compiledQuery) => {
+            const startTime = (0, performance_now_js_1.performanceNow)();
+            try {
+                return await executeQuery.call(connection, compiledQuery);
+            }
+            catch (error) {
+                this.#logError(error);
+                throw error;
+            }
+            finally {
+                this.#logQuery(compiledQuery, startTime);
+            }
+        };
     }
     #logError(error) {
         this.#log.error(() => ({
@@ -105,3 +101,4 @@ class RuntimeConnection {
         return (0, performance_now_js_1.performanceNow)() - startTime;
     }
 }
+exports.RuntimeDriver = RuntimeDriver;

package/dist/cjs/index-nodeless.d.ts

@@ -40,6 +40,7 @@ export * from './driver/database-connection.js';
 export * from './driver/connection-provider.js';
 export * from './driver/default-connection-provider.js';
 export * from './driver/single-connection-provider.js';
+export * from './driver/dummy-driver.js';
 export * from './dialect/dialect.js';
 export * from './dialect/dialect-adapter.js';
 export * from './dialect/dialect-adapter-base.js';
@@ -58,6 +59,7 @@ export * from './query-compiler/query-compiler.js';
 export * from './migration/migrator.js';
 export * from './plugin/kysely-plugin.js';
 export * from './plugin/camel-case/camel-case-plugin.js';
+export * from './plugin/deduplicate-joins/deduplicate-joins-plugin.js';
 export * from './operation-node/add-column-node.js';
 export * from './operation-node/add-constraint-node.js';
 export * from './operation-node/alias-node.js';

package/dist/cjs/index-nodeless.js

@@ -52,6 +52,7 @@ __exportStar(require("./driver/database-connection.js"), exports);
 __exportStar(require("./driver/connection-provider.js"), exports);
 __exportStar(require("./driver/default-connection-provider.js"), exports);
 __exportStar(require("./driver/single-connection-provider.js"), exports);
+__exportStar(require("./driver/dummy-driver.js"), exports);
 __exportStar(require("./dialect/dialect.js"), exports);
 __exportStar(require("./dialect/dialect-adapter.js"), exports);
 __exportStar(require("./dialect/dialect-adapter-base.js"), exports);
@@ -70,6 +71,7 @@ __exportStar(require("./query-compiler/query-compiler.js"), exports);
 __exportStar(require("./migration/migrator.js"), exports);
 __exportStar(require("./plugin/kysely-plugin.js"), exports);
 __exportStar(require("./plugin/camel-case/camel-case-plugin.js"), exports);
+__exportStar(require("./plugin/deduplicate-joins/deduplicate-joins-plugin.js"), exports);
 __exportStar(require("./operation-node/add-column-node.js"), exports);
 __exportStar(require("./operation-node/add-constraint-node.js"), exports);
 __exportStar(require("./operation-node/alias-node.js"), exports);

package/dist/cjs/kysely.d.ts

@@ -22,22 +22,24 @@ import { DialectAdapter } from './dialect/dialect-adapter.js';
  * This example assumes your database has tables `person` and `pet`:
  *
  * ```ts
- * interface Person {
- *   id: number
+ * import { Kysely, Generated, PostgresDialect } from 'kysely'
+ *
+ * interface PersonTable {
+ *   id: Generated<number>
  *   first_name: string
  *   last_name: string
  * }
  *
- * interface Pet {
- *   id: number
+ * interface PetTable {
+ *   id: Generated<number>
  *   owner_id: number
  *   name: string
  *   species 'cat' | 'dog'
  * }
  *
  * interface Database {
- *   person: Person,
- *   pet: Pet
+ *   person: PersonTable,
+ *   pet: PetTable
  * }
  *
  * const db = new Kysely<Database>({

package/dist/cjs/kysely.js

@@ -26,22 +26,24 @@ const private_symbols_js_1 = require("./util/private-symbols.js");
  * This example assumes your database has tables `person` and `pet`:
  *
  * ```ts
- * interface Person {
- *   id: number
+ * import { Kysely, Generated, PostgresDialect } from 'kysely'
+ *
+ * interface PersonTable {
+ *   id: Generated<number>
  *   first_name: string
  *   last_name: string
  * }
  *
- * interface Pet {
- *   id: number
+ * interface PetTable {
+ *   id: Generated<number>
  *   owner_id: number
  *   name: string
  *   species 'cat' | 'dog'
  * }
  *
  * interface Database {
- *   person: Person,
- *   pet: Pet
+ *   person: PersonTable,
+ *   pet: PetTable
  * }
  *
  * const db = new Kysely<Database>({

package/dist/cjs/migration/migrator.d.ts

@@ -144,8 +144,8 @@ export interface MigratorProps {
     readonly provider: MigrationProvider;
 }
 /**
- * All migration methods ({@link MigrationModule.migrateTo | migrateTo},
- * {@link MigrationModule.migrateToLatest | migrateToLatest} etc.) never
+ * All migration methods ({@link Migrator.migrateTo | migrateTo},
+ * {@link Migrator.migrateToLatest | migrateToLatest} etc.) never
  * throw but return this object instead.
  */
 export interface MigrationResultSet {

package/dist/cjs/operation-node/primitive-value-list-node.d.ts

@@ -1,4 +1,3 @@
-import { PrimitiveValue } from '../util/object-utils.js';
 import { OperationNode } from './operation-node.js';
 /**
  * This node is basically just a performance optimization over the normal ValueListNode.
@@ -7,12 +6,12 @@ import { OperationNode } from './operation-node.js';
  */
 export interface PrimitiveValueListNode extends OperationNode {
     readonly kind: 'PrimitiveValueListNode';
-    readonly values: ReadonlyArray<PrimitiveValue>;
+    readonly values: ReadonlyArray<unknown>;
 }
 /**
  * @internal
  */
 export declare const PrimitiveValueListNode: Readonly<{
     is(node: OperationNode): node is PrimitiveValueListNode;
-    create(values: ReadonlyArray<PrimitiveValue>): PrimitiveValueListNode;
+    create(values: ReadonlyArray<unknown>): PrimitiveValueListNode;
 }>;

package/dist/cjs/operation-node/value-node.d.ts

@@ -1,8 +1,7 @@
-import { PrimitiveValue } from '../util/object-utils.js';
 import { OperationNode } from './operation-node.js';
 export interface ValueNode extends OperationNode {
     readonly kind: 'ValueNode';
-    readonly value: PrimitiveValue;
+    readonly value: unknown;
     readonly immediate?: boolean;
 }
 /**
@@ -10,6 +9,6 @@ export interface ValueNode extends OperationNode {
  */
 export declare const ValueNode: Readonly<{
     is(node: OperationNode): node is ValueNode;
-    create(value: PrimitiveValue): ValueNode;
-    createImmediate(value: PrimitiveValue): ValueNode;
+    create(value: unknown): ValueNode;
+    createImmediate(value: unknown): ValueNode;
 }>;

package/dist/cjs/parser/complex-expression-parser.d.ts

@@ -7,3 +7,4 @@ export declare type ComplexExpression<DB, TB extends keyof DB> = AnySelectQueryB
 export declare type AliasedComplexExpression<DB, TB extends keyof DB> = AnyAliasedQueryBuilder | AliasedQueryBuilderFactory<DB, TB> | AnyAliasedRawBuilder | AliasedRawBuilderFactory<DB, TB>;
 export declare function parseComplexExpression(ctx: ParseContext, exp: ComplexExpression<any, any>): SelectQueryNode | RawNode;
 export declare function parseAliasedComplexExpression(ctx: ParseContext, exp: AliasedComplexExpression<any, any>): AliasNode;
+export declare function isComplexExpression(obj: unknown): obj is ComplexExpression<any, any>;

package/dist/cjs/parser/complex-expression-parser.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseAliasedComplexExpression = exports.parseComplexExpression = void 0;
+exports.isComplexExpression = exports.parseAliasedComplexExpression = exports.parseComplexExpression = void 0;
 const operation_node_source_js_1 = require("../operation-node/operation-node-source.js");
 const object_utils_js_1 = require("../util/object-utils.js");
 function parseComplexExpression(ctx, exp) {
@@ -23,3 +23,7 @@ function parseAliasedComplexExpression(ctx, exp) {
     throw new Error(`invalid aliased expression: ${JSON.stringify(exp)}`);
 }
 exports.parseAliasedComplexExpression = parseAliasedComplexExpression;
+function isComplexExpression(obj) {
+    return (0, operation_node_source_js_1.isOperationNodeSource)(obj) || (0, object_utils_js_1.isFunction)(obj);
+}
+exports.isComplexExpression = isComplexExpression;

package/dist/cjs/parser/default-value-parser.d.ts

@@ -1,6 +1,5 @@
 import { RawNode } from '../operation-node/raw-node.js';
 import { ValueNode } from '../operation-node/value-node.js';
-import { AnyRawBuilder } from '../util/type-utils.js';
-import { PrimitiveValue } from '../util/object-utils.js';
-export declare type DefaultValueExpression = PrimitiveValue | AnyRawBuilder;
+import { RawBuilder } from '../raw-builder/raw-builder.js';
+export declare type DefaultValueExpression = unknown | RawBuilder;
 export declare function parseDefaultValueExpression(value: DefaultValueExpression): ValueNode | RawNode;

package/dist/cjs/parser/default-value-parser.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseDefaultValueExpression = void 0;
-const operation_node_source_js_1 = require("../operation-node/operation-node-source.js");
 const value_node_js_1 = require("../operation-node/value-node.js");
+const raw_builder_js_1 = require("../raw-builder/raw-builder.js");
 function parseDefaultValueExpression(value) {
-    return (0, operation_node_source_js_1.isOperationNodeSource)(value)
+    return value instanceof raw_builder_js_1.RawBuilder
         ? value.toOperationNode()
         : value_node_js_1.ValueNode.createImmediate(value);
 }