kysely 0.21.6 → 0.23.0

package/dist/cjs/schema/create-table-builder.js

@@ -216,7 +216,7 @@ class CreateTableBuilder {
      * ```ts
      * db.schema.createTable('person')
      *   .modifyFront(sql`global temporary`)
-     *   .addColumn('id', 'integer', col => col => primaryKey())
+     *   .addColumn('id', 'integer', col => col.primaryKey())
      *   .addColumn('first_name', 'varchar(64)', col => col.notNull())
      *   .addColumn('last_name', 'varchar(64), col => col.notNull())
      *   .execute()
@@ -270,6 +270,41 @@ class CreateTableBuilder {
             createTableNode: create_table_node_js_1.CreateTableNode.cloneWithEndModifier(this.#props.createTableNode, modifier.toOperationNode()),
         });
     }
+    /**
+     * Calls the given function passing `this` as the only argument.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.schema
+     *   .createTable('test')
+     *   .call((builder) => builder.addColumn('id', 'integer'))
+     *   .execute()
+     * ```
+     *
+     * ```ts
+     * const addDefaultColumns = <T extends string, C extends string = never>(
+     *   builder: CreateTableBuilder<T, C>
+     * ) => {
+     *   return builder
+     *     .addColumn('id', 'integer', (col) => col.notNull())
+     *     .addColumn('created_at', 'date', (col) =>
+     *       col.notNull().defaultTo(sql`now()`)
+     *     )
+     *     .addColumn('updated_at', 'date', (col) =>
+     *       col.notNull().defaultTo(sql`now()`)
+     *     )
+     * }
+     *
+     * db.schema
+     *   .createTable('test')
+     *   .call(addDefaultColumns)
+     *   .execute()
+     * ```
+     */
+    call(func) {
+        return func(this);
+    }
     toOperationNode() {
         return this.#props.executor.transformQuery(this.#props.createTableNode, this.#props.queryId);
     }

package/dist/cjs/schema/create-view-builder.d.ts

@@ -4,7 +4,8 @@ import { Compilable } from '../util/compilable.js';
 import { QueryExecutor } from '../query-executor/query-executor.js';
 import { QueryId } from '../util/query-id.js';
 import { CreateViewNode } from '../operation-node/create-view-node.js';
-import { AnyRawBuilder, AnySelectQueryBuilder } from '../util/type-utils.js';
+import { AnySelectQueryBuilder } from '../util/type-utils.js';
+import { RawBuilder } from '../raw-builder/raw-builder.js';
 export declare class CreateViewBuilder implements OperationNodeSource, Compilable {
     #private;
     constructor(props: CreateViewBuilderProps);
@@ -30,7 +31,7 @@ export declare class CreateViewBuilder implements OperationNodeSource, Compilabl
      * string opening an SQL injection vulnerability. DO NOT pass unchecked user input
      * into the query or raw expression passed to this method!
      */
-    as(query: AnySelectQueryBuilder | AnyRawBuilder): CreateViewBuilder;
+    as(query: AnySelectQueryBuilder | RawBuilder<any>): CreateViewBuilder;
     toOperationNode(): CreateViewNode;
     compile(): CompiledQuery;
     execute(): Promise<void>;

package/dist/cjs/schema/schema.d.ts

@@ -186,7 +186,7 @@ export declare class SchemaModule {
      *   .execute()
      * ```
      */
-    createType(viewName: string): CreateTypeBuilder;
+    createType(typeName: string): CreateTypeBuilder;
     /**
      * Drop a type.
      *
@@ -201,7 +201,7 @@ export declare class SchemaModule {
      *   .execute()
      * ```
      */
-    dropType(viewName: string): DropTypeBuilder;
+    dropType(typeName: string): DropTypeBuilder;
     /**
      * Returns a copy of this schema module with the given plugin installed.
      */

package/dist/cjs/schema/schema.js

@@ -26,6 +26,7 @@ const create_type_builder_js_1 = require("./create-type-builder.js");
 const drop_type_builder_js_1 = require("./drop-type-builder.js");
 const create_type_node_js_1 = require("../operation-node/create-type-node.js");
 const drop_type_node_js_1 = require("../operation-node/drop-type-node.js");
+const identifier_parser_js_1 = require("../parser/identifier-parser.js");
 /**
  * Provides methods for building database schema.
  */
@@ -201,7 +202,7 @@ class SchemaModule {
         return new alter_table_builder_js_1.AlterTableBuilder({
             queryId: (0, query_id_js_1.createQueryId)(),
             executor: this.#executor,
-            alterTableNode: alter_table_node_js_1.AlterTableNode.create(table),
+            node: alter_table_node_js_1.AlterTableNode.create(table),
         });
     }
     /**
@@ -257,11 +258,11 @@ class SchemaModule {
      *   .execute()
      * ```
      */
-    createType(viewName) {
+    createType(typeName) {
         return new create_type_builder_js_1.CreateTypeBuilder({
             queryId: (0, query_id_js_1.createQueryId)(),
             executor: this.#executor,
-            createTypeNode: create_type_node_js_1.CreateTypeNode.create(viewName),
+            createTypeNode: create_type_node_js_1.CreateTypeNode.create((0, identifier_parser_js_1.parseSchemableIdentifier)(typeName)),
         });
     }
     /**
@@ -278,11 +279,11 @@ class SchemaModule {
      *   .execute()
      * ```
      */
-    dropType(viewName) {
+    dropType(typeName) {
         return new drop_type_builder_js_1.DropTypeBuilder({
             queryId: (0, query_id_js_1.createQueryId)(),
             executor: this.#executor,
-            dropTypeNode: drop_type_node_js_1.DropTypeNode.create(viewName),
+            dropTypeNode: drop_type_node_js_1.DropTypeNode.create((0, identifier_parser_js_1.parseSchemableIdentifier)(typeName)),
         });
     }
     /**

package/dist/cjs/util/compilable.d.ts

@@ -1,4 +1,4 @@
 import { CompiledQuery } from '../query-compiler/compiled-query.js';
-export interface Compilable {
-    compile(): CompiledQuery;
+export interface Compilable<O = unknown> {
+    compile(): CompiledQuery<O>;
 }

package/dist/cjs/util/explainable.d.ts

@@ -1,5 +1,5 @@
-import { AnyRawBuilder } from './type-utils.js';
+import { Expression } from '../expression/expression.js';
 export declare type ExplainFormat = 'text' | 'xml' | 'json' | 'yaml' | 'traditional' | 'tree';
 export interface Explainable {
-    explain<O extends Record<string, any> = Record<string, any>>(format?: ExplainFormat, options?: AnyRawBuilder): Promise<O[]>;
+    explain<O extends Record<string, any> = Record<string, any>>(format?: ExplainFormat, options?: Expression<any>): Promise<O[]>;
 }

package/dist/cjs/util/infer-result.d.ts

@@ -0,0 +1,46 @@
+import { DeleteResult } from '../query-builder/delete-result.js';
+import { InsertResult } from '../query-builder/insert-result.js';
+import { UpdateResult } from '../query-builder/update-result.js';
+import { CompiledQuery } from '../query-compiler/compiled-query.js';
+import { Compilable } from './compilable.js';
+/**
+ * A helper type that allows inferring a select/insert/update/delete query's result
+ * type from a query builder or compiled query.
+ *
+ * ### Examples
+ *
+ * Infer a query builder's result type:
+ *
+ * ```ts
+ * import { InferResult } from 'kysely'
+ *
+ * const query = db
+ *   .selectFrom('person')
+ *   .innerJoin('pet', 'pet.owner_id', 'person.id')
+ *   .select(['person.first_name', 'pet.name'])
+ *
+ * type QueryResult = InferResult<typeof query> // { first_name: string; name: string; }[]
+ * ```
+ *
+ * Infer a compiled query's result type:
+ *
+ * ```ts
+ * import { InferResult } from 'kysely'
+ *
+ * const compiledQuery = db
+ *   .insertInto('person')
+ *   .values({
+ *     first_name: 'Foo',
+ *     last_name: 'Barson',
+ *     gender: 'other',
+ *     age: 15,
+ *   })
+ *   .returningAll()
+ *   .compile()
+ *
+ * type QueryResult = InferResult<typeof compiledQuery> // Selectable<Person>[]
+ * ```
+ */
+export declare type InferResult<C extends Compilable<any> | CompiledQuery<any>> = C extends Compilable<infer O> ? ResolveResult<O> : C extends CompiledQuery<infer O> ? ResolveResult<O> : never;
+declare type ResolveResult<O> = O extends InsertResult | UpdateResult | DeleteResult ? O : O[];
+export {};

package/dist/cjs/util/infer-result.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/util/log-once.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Use for system-level logging, such as deprecation messages.
+ * Logs a message and ensures it won't be logged again.
+ */
+export declare function logOnce(message: string): void;

package/dist/cjs/util/log-once.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logOnce = void 0;
+const LOGGED_MESSAGES = new Set();
+/**
+ * Use for system-level logging, such as deprecation messages.
+ * Logs a message and ensures it won't be logged again.
+ */
+function logOnce(message) {
+    if (LOGGED_MESSAGES.has(message)) {
+        return;
+    }
+    LOGGED_MESSAGES.add(message);
+    console.log(message);
+}
+exports.logOnce = logOnce;

package/dist/cjs/util/object-utils.d.ts

@@ -11,6 +11,7 @@ export declare function isBuffer(obj: unknown): obj is {
 };
 export declare function isFunction(obj: unknown): obj is Function;
 export declare function isObject(obj: unknown): obj is Record<string, unknown>;
+export declare function isArrayBufferOrView(obj: unknown): obj is ArrayBuffer | ArrayBufferView;
 export declare function getLast<T>(arr: ArrayLike<T>): T | undefined;
 export declare function freeze<T>(obj: T): Readonly<T>;
 export declare function asArray<T>(arg: T | T[]): T[];

package/dist/cjs/util/object-utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.compare = exports.noop = exports.isReadonlyArray = exports.asReadonlyArray = exports.asArray = exports.freeze = exports.getLast = exports.isObject = exports.isFunction = exports.isBuffer = exports.isBigInt = exports.isDate = exports.isNull = exports.isBoolean = exports.isNumber = exports.isString = exports.isUndefined = exports.isEmpty = void 0;
+exports.compare = exports.noop = exports.isReadonlyArray = exports.asReadonlyArray = exports.asArray = exports.freeze = exports.getLast = exports.isArrayBufferOrView = exports.isObject = exports.isFunction = exports.isBuffer = exports.isBigInt = exports.isDate = exports.isNull = exports.isBoolean = exports.isNumber = exports.isString = exports.isUndefined = exports.isEmpty = void 0;
 function isEmpty(obj) {
     if (Array.isArray(obj) || isString(obj) || isBuffer(obj)) {
         return obj.length === 0;
@@ -53,6 +53,10 @@ function isObject(obj) {
     return typeof obj === 'object' && obj !== null;
 }
 exports.isObject = isObject;
+function isArrayBufferOrView(obj) {
+    return obj instanceof ArrayBuffer || ArrayBuffer.isView(obj);
+}
+exports.isArrayBufferOrView = isArrayBufferOrView;
 function getLast(arr) {
     return arr[arr.length - 1];
 }

package/dist/cjs/util/type-utils.d.ts

@@ -1,6 +1,4 @@
-import { AliasedRawBuilder, RawBuilder } from '../raw-builder/raw-builder.js';
-import { AliasedQueryBuilder, SelectQueryBuilder } from '../query-builder/select-query-builder.js';
-import { ExpressionBuilder } from '../query-builder/expression-builder.js';
+import { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
 import { InsertResult } from '../query-builder/insert-result.js';
 import { DeleteResult } from '../query-builder/delete-result.js';
 import { UpdateResult } from '../query-builder/update-result.js';
@@ -99,21 +97,11 @@ export declare type AnyAliasedColumnWithTable<DB, TB extends keyof DB> = {
  */
 export declare type ArrayItemType<T> = T extends ReadonlyArray<infer I> ? I : never;
 export declare type AnySelectQueryBuilder = SelectQueryBuilder<any, any, any>;
-export declare type AnyAliasedQueryBuilder = AliasedQueryBuilder<any, any, any, any>;
-export declare type AnyRawBuilder = RawBuilder<any>;
-export declare type AnyAliasedRawBuilder = AliasedRawBuilder<any, any>;
-export declare type SelectQueryBuilderFactory<DB, TB extends keyof DB> = (qb: ExpressionBuilder<DB, TB>) => AnySelectQueryBuilder;
-export declare type AliasedQueryBuilderFactory<DB, TB extends keyof DB> = (qb: ExpressionBuilder<DB, TB>) => AnyAliasedQueryBuilder;
-export declare type RawBuilderFactory<DB, TB extends keyof DB, O = any> = (qb: ExpressionBuilder<DB, TB>) => RawBuilder<O>;
-export declare type AliasedRawBuilderFactory<DB, TB extends keyof DB> = (qb: ExpressionBuilder<DB, TB>) => AnyAliasedRawBuilder;
 export declare type SingleResultType<O> = O extends InsertResult ? O : O extends DeleteResult ? O : O extends UpdateResult ? O : O | undefined;
 export declare type UnknownRow = Record<string, unknown>;
 export declare type Nullable<T> = {
     [P in keyof T]: T[P] | null;
 };
-export declare type NullableValues<T> = {
-    [P in keyof T]: Nullable<T[P]>;
-};
 /**
  * Takes all properties from T1 and merges all properties from T2
  * that don't exist in T1 as optional properties.
@@ -135,3 +123,5 @@ export declare type NullableValues<T> = {
  * // { name: string, age: number, species?: 'cat' | 'dog' }
  */
 export declare type MergePartial<T1, T2> = T1 & Partial<Omit<T2, keyof T1>>;
+export declare type IsNever<T> = [T] extends [never] ? true : false;
+export declare type Equals<T, U> = (<G>() => G extends T ? 1 : 2) extends <G>() => G extends U ? 1 : 2 ? true : false;

package/dist/esm/dialect/database-introspector.d.ts

@@ -49,6 +49,10 @@ export interface ColumnMetadata {
      *       on PostgreSQL, `INTEGER` on SQLite and `int` on MySQL.
      */
     readonly dataType: string;
+    /**
+     * The schema this column's data type was created in.
+     */
+    readonly dataTypeSchema?: string;
     readonly isAutoIncrementing: boolean;
     readonly isNullable: boolean;
     readonly hasDefaultValue: boolean;

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

@@ -84,15 +84,18 @@ class MysqlConnection {
             const result = await this.#executeQuery(compiledQuery);
             if (isOkPacket(result)) {
                 const { insertId, affectedRows } = result;
+                const numAffectedRows = affectedRows !== undefined && affectedRows !== null
+                    ? BigInt(affectedRows)
+                    : undefined;
                 return {
                     insertId: insertId !== undefined &&
                         insertId !== null &&
                         insertId.toString() !== '0'
                         ? BigInt(insertId)
                         : undefined,
-                    numUpdatedOrDeletedRows: affectedRows !== undefined && insertId !== null
-                        ? BigInt(affectedRows)
-                        : undefined,
+                    // TODO: remove.
+                    numUpdatedOrDeletedRows: numAffectedRows,
+                    numAffectedRows,
                     rows: [],
                 };
             }

package/dist/esm/dialect/postgres/postgres-adapter.js

@@ -2,7 +2,7 @@
 import { sql } from '../../raw-builder/sql.js';
 import { DialectAdapterBase } from '../dialect-adapter-base.js';
 // Random id for our transaction lock.
-const LOCK_ID = 3853314791062309107n;
+const LOCK_ID = BigInt('3853314791062309107');
 export class PostgresAdapter extends DialectAdapterBase {
     get supportsTransactionalDdl() {
         return true;

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

@@ -69,9 +69,14 @@ class PostgresConnection {
             const result = await this.#client.query(compiledQuery.sql, [
                 ...compiledQuery.parameters,
             ]);
-            if (result.command === 'UPDATE' || result.command === 'DELETE') {
+            if (result.command === 'INSERT' ||
+                result.command === 'UPDATE' ||
+                result.command === 'DELETE') {
+                const numAffectedRows = BigInt(result.rowCount);
                 return {
-                    numUpdatedOrDeletedRows: BigInt(result.rowCount),
+                    // TODO: remove.
+                    numUpdatedOrDeletedRows: numAffectedRows,
+                    numAffectedRows,
                     rows: result.rows ?? [],
                 };
             }

package/dist/esm/dialect/postgres/postgres-introspector.js

@@ -17,10 +17,16 @@ export class PostgresIntrospector {
     }
     async getTables(options = { withInternalKyselyTables: false }) {
         let query = this.#db
+            // column
             .selectFrom('pg_catalog.pg_attribute as a')
+            // table
             .innerJoin('pg_catalog.pg_class as c', 'a.attrelid', 'c.oid')
+            // table schema
             .innerJoin('pg_catalog.pg_namespace as ns', 'c.relnamespace', 'ns.oid')
+            // column data type
             .innerJoin('pg_catalog.pg_type as typ', 'a.atttypid', 'typ.oid')
+            // column data type schema
+            .innerJoin('pg_catalog.pg_namespace as dtns', 'typ.typnamespace', 'dtns.oid')
             .select([
             'a.attname as column',
             'a.attnotnull as not_null',
@@ -28,6 +34,7 @@ export class PostgresIntrospector {
             'c.relname as table',
             'ns.nspname as schema',
             'typ.typname as type',
+            'dtns.nspname as type_schema',
             // Detect if the column is auto incrementing by finding the sequence
             // that is created for `serial` and `bigserial` columns.
             this.#db
@@ -77,6 +84,7 @@ export class PostgresIntrospector {
             table.columns.push(freeze({
                 name: it.column,
                 dataType: it.type,
+                dataTypeSchema: it.type_schema,
                 isNullable: !it.not_null,
                 isAutoIncrementing: !!it.auto_incrementing,
                 hasDefaultValue: it.has_default,

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

@@ -55,10 +55,11 @@ class SqliteConnection {
         }
         else {
             const { changes, lastInsertRowid } = stmt.run(parameters);
+            const numAffectedRows = changes !== undefined && changes !== null ? BigInt(changes) : undefined;
             return Promise.resolve({
-                numUpdatedOrDeletedRows: changes !== undefined && changes !== null
-                    ? BigInt(changes)
-                    : undefined,
+                // TODO: remove.
+                numUpdatedOrDeletedRows: numAffectedRows,
+                numAffectedRows,
                 insertId: lastInsertRowid !== undefined && lastInsertRowid !== null
                     ? BigInt(lastInsertRowid)
                     : undefined,

package/dist/esm/dialect/sqlite/sqlite-introspector.js

@@ -44,6 +44,7 @@ export class SqliteIntrospector {
         const autoIncrementCol = createSql[0]?.sql
             ?.split(/[\(\),]/)
             ?.find((it) => it.toLowerCase().includes('autoincrement'))
+            ?.trimStart()
             ?.split(/\s+/)?.[0]
             ?.replace(/["`]/g, '');
         const columns = await db

package/dist/esm/driver/database-connection.d.ts

@@ -10,10 +10,14 @@ export interface DatabaseConnection {
 }
 export interface QueryResult<O> {
     /**
-     * This is defined for update and delete queries and contains
-     * the number of rows the query updated/deleted.
+     * @deprecated use {@link QueryResult.numAffectedRows} instead.
      */
     readonly numUpdatedOrDeletedRows?: bigint;
+    /**
+     * This is defined for insert, update and delete queries and contains
+     * the number of rows the query inserted/updated/deleted.
+     */
+    readonly numAffectedRows?: bigint;
     /**
      * This is defined for insert queries on dialects that return
      * the auto incrementing primary key from an insert.

package/dist/esm/dynamic/dynamic-reference-builder.d.ts

@@ -1,6 +1,5 @@
-import { ColumnNode } from '../operation-node/column-node.js';
 import { OperationNodeSource } from '../operation-node/operation-node-source.js';
-import { ReferenceNode } from '../operation-node/reference-node.js';
+import { SimpleReferenceExpressionNode } from '../operation-node/simple-reference-expression-node.js';
 export declare class DynamicReferenceBuilder<R extends string = never> implements OperationNodeSource {
     #private;
     get dynamicReference(): string;
@@ -14,6 +13,6 @@ export declare class DynamicReferenceBuilder<R extends string = never> implement
      */
     protected get refType(): R;
     constructor(reference: string);
-    toOperationNode(): ReferenceNode | ColumnNode;
+    toOperationNode(): SimpleReferenceExpressionNode;
 }
 export declare function isDynamicReferenceBuilder(obj: unknown): obj is DynamicReferenceBuilder<any>;

package/dist/esm/dynamic/dynamic-reference-builder.js

@@ -1,6 +1,6 @@
 /// <reference types="./dynamic-reference-builder.d.ts" />
 import { isOperationNodeSource, } from '../operation-node/operation-node-source.js';
-import { parseStringReference } from '../parser/reference-parser.js';
+import { parseSimpleReferenceExpression } from '../parser/reference-parser.js';
 import { isObject, isString } from '../util/object-utils.js';
 export class DynamicReferenceBuilder {
     #dynamicReference;
@@ -22,7 +22,7 @@ export class DynamicReferenceBuilder {
         this.#dynamicReference = reference;
     }
     toOperationNode() {
-        return parseStringReference(this.#dynamicReference);
+        return parseSimpleReferenceExpression(this.#dynamicReference);
     }
 }
 export function isDynamicReferenceBuilder(obj) {

package/dist/esm/expression/expression.d.ts

@@ -0,0 +1,100 @@
+import { AliasNode } from '../operation-node/alias-node.js';
+import { OperationNodeSource } from '../operation-node/operation-node-source.js';
+import { OperationNode } from '../operation-node/operation-node.js';
+/**
+ * `Expression` represents an arbitrary SQL expression with a type.
+ *
+ * Most Kysely methods accept instances of `Expression` and most classes like `SelectQueryBuilder`
+ * and the return value of the {@link sql} template tag implement it.
+ *
+ * ```ts
+ * const exp1: Expression<string> = sql<string>`CONCAT('hello', ' ', 'world')`
+ * const exp2: Expression<{ first_name: string }> = db.selectFrom('person').select('first_name')
+ * ```
+ *
+ * You can implement the `Expression` interface to create your own type-safe utilities for Kysely.
+ */
+export interface Expression<T> extends OperationNodeSource {
+    /**
+     * 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:
+     *
+     * ```ts
+     * class SomeExpression<T> implements Expression<T> {
+     *   get expressionType(): T | undefined {
+     *     return undefined
+     *   }
+     * }
+     * ```
+     *
+     * 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(): T | undefined;
+    /**
+     * Creates the OperationNode that describes how to compile this expression into SQL.
+     *
+     * If you are creating a custom expression, it's often easiest to use the {@link sql}
+     * template tag to build the node:
+     *
+     * ```ts
+     * class SomeExpression<T> implements Expression<T> {
+     *   toOperationNode(): OperationNode {
+     *     return sql`some sql here`.toOperationNode()
+     *   }
+     * }
+     * ```
+     */
+    toOperationNode(): OperationNode;
+}
+/**
+ * Just like `Expression<T>` but also holds an alias type `A`.
+ *
+ * `AliasedExpression<T, A>` can be used in places where, in addition to the value type `T`, you
+ * also need a name `A` for that value. For example anything you can pass into the `select` method
+ * needs to implement an `AliasedExpression<T, A>`. `A` becomes the name of the selected expression
+ * in the result and `T` becomes its type.
+ *
+ * @example
+ *
+ * ```ts
+ * class SomeAliasedExpression<T, A extends string> implements AliasedExpression<T, A> {
+ *   #expression: Expression<T>
+ *   #alias: A
+ *
+ *   constructor(expression: Expression<T>, alias: A) {
+ *     this.#expression = expression
+ *     this.#alias = alias
+ *   }
+ *
+ *   get expression(): Expression<T> {
+ *     return this.#expression
+ *   }
+ *
+ *   get alias(): A {
+ *     return this.#alias
+ *   }
+ *
+ *   toOperationNode(): AliasNode {
+ *     return AliasNode.create(this.#expression.toOperationNode(), IdentifierNode.create(this.#alias))
+ *   }
+ * }
+ * ```
+ */
+export interface AliasedExpression<T, A extends string> extends OperationNodeSource {
+    /**
+     * Returns the aliased expression.
+     */
+    get expression(): Expression<T>;
+    /**
+     * Returns the alias.
+     */
+    get alias(): A;
+    /**
+     * Creates the OperationNode that describes how to compile this expression into SQL.
+     */
+    toOperationNode(): AliasNode;
+}
+export declare function isExpression(obj: unknown): obj is Expression<any>;
+export declare function isAliasedExpression(obj: unknown): obj is AliasedExpression<any, any>;

package/dist/esm/expression/expression.js

@@ -0,0 +1,12 @@
+/// <reference types="./expression.d.ts" />
+import { isOperationNodeSource, } from '../operation-node/operation-node-source.js';
+import { isObject, isString } from '../util/object-utils.js';
+export function isExpression(obj) {
+    return isObject(obj) && 'expressionType' in obj && isOperationNodeSource(obj);
+}
+export function isAliasedExpression(obj) {
+    return (isObject(obj) &&
+        'expression' in obj &&
+        isString(obj.alias) &&
+        isOperationNodeSource(obj));
+}