orchid-orm 1.17.14 → 1.17.16

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import * as pqb from 'pqb';
-import { Query, QueryWithTable, SetQueryTableAlias, WhereArg, UpdateData, CreateData, Db, IsolationLevel, TransactionOptions, Adapter, FromArgs, FromResult, AdapterOptions, QueryLogOptions, NoPrimaryKeyOption, RelationConfigBase, RelationQuery, SetQueryReturnsOne, SetQueryReturnsOneOptional, SetQueryReturnsAll, RelationQueryBase, ColumnsShape, DefaultColumnTypes, QueryData, QueryBase, QueryBeforeHook, QueryAfterHook, AfterHook, WhereResult, MergeQuery, SetQueryReturns, QueryReturnType } from 'pqb';
+import { Query, QueryWithTable, SetQueryTableAlias, WhereArg, UpdateData, CreateData, Db, IsolationLevel, TransactionOptions, Adapter, FromArgs, FromResult, AdapterOptions, QueryLogOptions, NoPrimaryKeyOption, RelationConfigBase, RelationQuery, SetQueryReturnsOne, SetQueryReturnsOneOptional, SetQueryReturnsAll, RelationQueryBase, ComputedColumnsBase, QueryDefaultReturnData, ColumnsShape, DefaultColumnTypes, QueryData, QueryBase, QueryBeforeHook, QueryAfterHook, AfterHook, WhereResult, MergeQuery, SetQueryReturns, QueryReturnType } from 'pqb';
 export { OrchidOrmError, OrchidOrmInternalError, columnTypes, raw, testTransaction } from 'pqb';
 import * as orchid_core from 'orchid-core';
 import { EmptyObject, MaybeArray, StringKey, ColumnTypesBase, ColumnShapeQueryType, ColumnShapeOutput, ColumnShapeInput, ColumnsShapeBase } from 'orchid-core';
@@ -349,7 +349,9 @@ type MapRelations<T extends Table> = T extends {
 
 type TableClass<T extends Table = Table> = new () => T;
 type TableClasses = Record<string, TableClass>;
-type TableToDb<T extends Table, RelationQueries extends Record<string, RelationQueryBase>> = Db<T['table'], T['columns'], RelationQueries, T['columnTypes']> & {
+type TableToDb<T extends Table, RelationQueries extends Record<string, RelationQueryBase>> = Db<T['table'], T['computed'] extends ComputedColumnsBase<never> ? T['columns'] & {
+    [K in keyof T['computed']]: ReturnType<T['computed'][K]>['_type'];
+} : T['columns'], RelationQueries, T['types'], QueryDefaultReturnData<T['columns']>> & {
     definedAs: string;
     db: OrchidORM;
     getFilePath(): string;
@@ -361,10 +363,14 @@ type Table = {
     table: string;
     columns: ColumnsShape;
     schema?: string;
-    columnTypes: ColumnTypesBase;
+    types: ColumnTypesBase;
     noPrimaryKey?: boolean;
     filePath: string;
     language?: string;
+    /**
+     * collect computed columns returned by {@link BaseTable.setColumns}
+     */
+    computed?: ComputedColumnsBase<never>;
 };
 type Queryable<T extends Table> = Partial<ColumnShapeQueryType<T['columns']>>;
 type Selectable<T extends Table> = ColumnShapeOutput<T['columns']>;
@@ -388,7 +394,7 @@ declare const createBaseTable: <ColumnTypes extends Record<string, orchid_core.A
         schema?: string | undefined;
         noPrimaryKey?: boolean | undefined;
         snakeCase: boolean | undefined;
-        columnTypes: Record<string, orchid_core.AnyColumnTypeCreator> extends ColumnTypes ? {
+        types: Record<string, orchid_core.AnyColumnTypeCreator> extends ColumnTypes ? {
             timestamps<T extends orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>>(this: {
                 name(name: string): {
                     timestamp(): T;
@@ -662,6 +668,230 @@ declare const createBaseTable: <ColumnTypes extends Record<string, orchid_core.A
             }) | undefined): {};
             check(check: orchid_core.RawSQLBase<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>, {}>): {};
         } : ColumnTypes) => T_15): T_15;
+        /**
+         * You can add a generated column in the migration (see [generated](/guide/migration-column-methods.html#generated-column)),
+         * such column will persist in the database, it can be indexed.
+         *
+         * Or you can add a computed column on the ORM level, without adding it to the database, in such a way:
+         *
+         * ```ts
+         * import { BaseTable } from './baseTable';
+         *
+         * export class UserTable extends BaseTable {
+         *   readonly table = 'user';
+         *   columns = this.setColumns((t) => ({
+         *     id: t.identity().primaryKey(),
+         *     firstName: t.string(),
+         *     lastName: t.string(),
+         *   }));
+         *
+         *   computed = this.setComputed({
+         *     fullName: (q) =>
+         *       q.sql`${q.column('firstName')} || ' ' || ${q.column('lastName')}`.type(
+         *         (t) => t.string(),
+         *       ),
+         *   });
+         * }
+         * ```
+         *
+         * `setComputed` takes an object where keys are computed column names, and values are functions returning raw SQL.
+         *
+         * Use `q.column` as shown above to reference a table column, it will be prefixed with a correct table name even if the table is joined under a different name.
+         *
+         * Computed columns are not selected by default, only on demand:
+         *
+         * ```ts
+         * const a = await db.user.take();
+         * a.fullName; // not selected
+         *
+         * const b = await db.user.select('*', 'fullName');
+         * b.fullName; // selected
+         *
+         * // Table post belongs to user as an author.
+         * // it's possible to select joined computed column:
+         * const posts = await db.post
+         *   .join('author')
+         *   .select('post.title', 'author.fullName');
+         * ```
+         *
+         * SQL query can be generated dynamically based on the current request context.
+         *
+         * Imagine we are using [AsyncLocalStorage](https://nodejs.org/api/async_context.html#asynchronous-context-tracking)
+         * to keep track of current user's language.
+         *
+         * And we have articles translated to different languages, each article has `title_en`, `title_uk`, `title_be` and so on.
+         *
+         * We can define a computed `title` by passing a function into `sql` method:
+         *
+         * ```ts
+         * type Locale = 'en' | 'uk' | 'be';
+         * const asyncLanguageStorage = new AsyncLocalStorage<Locale>();
+         * const defaultLocale: Locale = 'en';
+         *
+         * export class ArticleTable extends BaseTable {
+         *   readonly table = 'article';
+         *   columns = this.setColumns((t) => ({
+         *     id: t.identity().primaryKey(),
+         *     title_en: t.text(),
+         *     title_uk: t.text().nullable(),
+         *     title_be: t.text().nullable(),
+         *   }));
+         *
+         *   computed = this.setComputed({
+         *     title: (q) =>
+         *       q
+         *         // .sql can take a function that accepts `sql` argument and must return SQL
+         *         .sql((sql) => {
+         *           // get locale dynamically based on current storage value
+         *           const locale = asyncLanguageStorage.getStore() || defaultLocale;
+         *
+         *           // use COALESCE in case when localized title is NULL, use title_en
+         *           return sql`COALESCE(
+         *             ${q.column(`title_${locale}`)},
+         *             ${q.column(`title_${defaultLocale}`)}
+         *           )`;
+         *         })
+         *         .type((t) => t.text()),
+         *   });
+         * }
+         * ```
+         *
+         * @param computed - object where keys are column names and values are functions returning raw SQL
+         */
+        setComputed<Table_3 extends string, Shape_1 extends ColumnsShape, Computed extends ComputedColumnsBase<Db<Table_3, Shape_1, {}, Record<string, orchid_core.AnyColumnTypeCreator> extends ColumnTypes ? {
+            timestamps<T extends orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>>(this: {
+                name(name: string): {
+                    timestamp(): T;
+                };
+                timestamp(): T;
+                timestampsSnakeCase(): {
+                    createdAt: orchid_core.ColumnWithDefault<T, orchid_core.RawSQLBase<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>, {}>>;
+                    updatedAt: orchid_core.ColumnWithDefault<T, orchid_core.RawSQLBase<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>, {}>>;
+                };
+            }): {
+                createdAt: orchid_core.ColumnWithDefault<T, orchid_core.RawSQLBase<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>, {}>>;
+                updatedAt: orchid_core.ColumnWithDefault<T, orchid_core.RawSQLBase<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>, {}>>;
+            };
+            timestampsSnakeCase<T_1 extends orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>>(this: {
+                name(name: string): {
+                    timestamp(): T_1;
+                };
+                timestamp(): T_1;
+            }): {
+                createdAt: orchid_core.ColumnWithDefault<T_1, orchid_core.RawSQLBase<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>, {}>>;
+                updatedAt: orchid_core.ColumnWithDefault<T_1, orchid_core.RawSQLBase<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>, {}>>;
+            };
+            timestampsNoTZ<T_2 extends orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>>(this: {
+                name(name: string): {
+                    timestampNoTZ(): T_2;
+                };
+                timestampNoTZ(): T_2;
+                timestampsNoTZSnakeCase(): {
+                    createdAt: orchid_core.ColumnWithDefault<T_2, orchid_core.RawSQLBase<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>, {}>>;
+                    updatedAt: orchid_core.ColumnWithDefault<T_2, orchid_core.RawSQLBase<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>, {}>>;
+                };
+            }): {
+                createdAt: orchid_core.ColumnWithDefault<T_2, orchid_core.RawSQLBase<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>, {}>>;
+                updatedAt: orchid_core.ColumnWithDefault<T_2, orchid_core.RawSQLBase<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>, {}>>;
+            };
+            timestampsNoTZSnakeCase<T_3 extends orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>>(this: {
+                name(name: string): {
+                    timestampNoTZ(): T_3;
+                };
+                timestampNoTZ(): T_3;
+            }): {
+                createdAt: orchid_core.ColumnWithDefault<T_3, orchid_core.RawSQLBase<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>, {}>>;
+                updatedAt: orchid_core.ColumnWithDefault<T_3, orchid_core.RawSQLBase<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>, {}>>;
+            };
+            name: typeof orchid_core.name;
+            sql: {
+                (sql: TemplateStringsArray, ...values: unknown[]): orchid_core.RawSQLBase<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>, {}>;
+                (sql: string): orchid_core.RawSQLBase<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>, {}>;
+                (values: Record<string, unknown>, sql: string): orchid_core.RawSQLBase<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>, {}>;
+                (values: Record<string, unknown>): (strings: TemplateStringsArray, ...values: unknown[]) => orchid_core.RawSQLBase<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>, {}>;
+            };
+            smallint(): pqb.SmallIntColumn;
+            integer(): pqb.IntegerColumn;
+            bigint(): pqb.BigIntColumn;
+            numeric<Precision extends number | undefined = undefined, Scale extends number | undefined = undefined>(precision?: Precision | undefined, scale?: Scale | undefined): pqb.DecimalColumn<Precision, Scale>;
+            decimal<Precision_1 extends number | undefined = undefined, Scale_1 extends number | undefined = undefined>(precision?: Precision_1 | undefined, scale?: Scale_1 | undefined): pqb.DecimalColumn<Precision_1, Scale_1>;
+            real(): pqb.RealColumn;
+            doublePrecision(): pqb.DoublePrecisionColumn;
+            identity(options?: pqb.TableData.Identity | undefined): orchid_core.ColumnWithDefault<pqb.IntegerColumn, orchid_core.Expression<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>>>;
+            smallSerial(): pqb.SmallSerialColumn;
+            serial(): pqb.SerialColumn;
+            bigSerial(): pqb.BigSerialColumn;
+            money(): pqb.MoneyColumn;
+            varchar<Limit extends number | undefined = undefined>(limit?: Limit | undefined): pqb.VarCharColumn<Limit>;
+            char<Limit_1 extends number | undefined = undefined>(limit?: Limit_1 | undefined): pqb.CharColumn<Limit_1>;
+            text(min: number, max: number): pqb.TextColumn;
+            string<Limit_2 extends number = 255>(limit?: Limit_2): pqb.VarCharColumn<Limit_2>;
+            citext(min: number, max: number): pqb.CitextColumn;
+            bytea(): pqb.ByteaColumn;
+            date(): pqb.DateColumn;
+            timestampNoTZ<Precision_2 extends number>(precision?: Precision_2 | undefined): pqb.TimestampColumn<Precision_2>;
+            timestamp<Precision_3 extends number | undefined = undefined>(precision?: Precision_3 | undefined): pqb.TimestampTZColumn<number>;
+            time<Precision_4 extends number | undefined = undefined>(precision?: Precision_4 | undefined): pqb.TimeColumn<Precision_4>;
+            interval<Fields extends string | undefined = undefined, Precision_5 extends number | undefined = undefined>(fields?: Fields | undefined, precision?: Precision_5 | undefined): pqb.IntervalColumn<Fields, Precision_5>;
+            boolean(): pqb.BooleanColumn;
+            enum<U extends string, T_4 extends [U, ...U[]]>(dataType: string, type: T_4): pqb.EnumColumn<U, T_4>;
+            point(): pqb.PointColumn;
+            line(): pqb.LineColumn;
+            lseg(): pqb.LsegColumn;
+            box(): pqb.BoxColumn;
+            path(): pqb.PathColumn;
+            polygon(): pqb.PolygonColumn;
+            circle(): pqb.CircleColumn;
+            cidr(): pqb.CidrColumn;
+            inet(): pqb.InetColumn;
+            macaddr(): pqb.MacAddrColumn;
+            macaddr8(): pqb.MacAddr8Column;
+            bit<Length extends number>(length: Length): pqb.BitColumn<Length>;
+            bitVarying<Length_1 extends number | undefined = undefined>(length?: Length_1 | undefined): pqb.BitVaryingColumn<Length_1>;
+            tsvector(): pqb.TsVectorColumn;
+            tsquery(): pqb.TsQueryColumn;
+            uuid(): pqb.UUIDColumn;
+            xml(): pqb.XMLColumn;
+            json<Type extends orchid_core.JSONType<unknown, {}> = orchid_core.JSONUnknown>(schemaOrFn?: Type | ((j: {
+                unknown: () => orchid_core.JSONUnknown;
+                boolean: () => orchid_core.JSONBoolean;
+                null: () => orchid_core.JSONNull;
+                number: <T_5 extends number = number>() => orchid_core.JSONNumber<T_5>;
+                string: <T_6 extends string = string>() => orchid_core.JSONString<T_6>;
+                array: <T_7 extends orchid_core.JSONType<unknown, {}>>(item: T_7) => orchid_core.JSONArray<T_7, "many">;
+                object: <Shape extends orchid_core.JSONObjectShape>(shape: Shape) => orchid_core.JSONObject<Shape, "strip", orchid_core.JSONType<unknown, {}>>;
+                literal: <T_8 extends orchid_core.JSONPrimitive>(value: T_8) => orchid_core.JSONLiteral<T_8>;
+                discriminatedUnion: <Discriminator extends string, Types extends orchid_core.JSONDiscriminatedUnionArg<Discriminator>>(discriminator: Discriminator, types: Types) => orchid_core.JSONDiscriminatedUnion<Discriminator, Types>;
+                enum: <U_1 extends string, T_9 extends [U_1, ...U_1[]]>(options: T_9) => orchid_core.JSONEnum<string, T_9>;
+                intersection: <Left extends orchid_core.JSONType<unknown, {}>, Right extends orchid_core.JSONType<unknown, {}>>(left: Left, right: Right) => orchid_core.JSONIntersection<Left, Right>;
+                lazy: <T_10 extends orchid_core.JSONType<unknown, {}>>(fn: () => T_10) => orchid_core.JSONLazy<T_10>;
+                nativeEnum: <T_11 extends orchid_core.EnumLike>(type: T_11) => orchid_core.JSONNativeEnum<T_11>;
+                record: <Key extends orchid_core.JSONString<string> | orchid_core.JSONNumber<number>, Value extends orchid_core.JSONType<unknown, {}>>(...args: [value: Value] | [key: Key, value: Value]) => orchid_core.JSONRecord<Key, Value>;
+                tuple: <T_12 extends orchid_core.JSONTupleItems, Rest extends orchid_core.JSONType<unknown, {}> | undefined = undefined>(items: T_12, rest?: Rest | undefined) => orchid_core.JSONTuple<T_12, Rest>;
+                union: <T_13 extends orchid_core.JSONUnionArgs>(...types: T_13) => orchid_core.JSONUnion<T_13>;
+            }) => Type) | undefined): pqb.JSONColumn<Type>;
+            jsonText(): pqb.JSONTextColumn;
+            array<Item extends pqb.ColumnType<unknown, pqb.BaseOperators, unknown, unknown, unknown>>(item: Item): pqb.ArrayColumn<Item>;
+            type(dataType: string): pqb.CustomTypeColumn;
+            domain(dataType: string): pqb.DomainColumn;
+            primaryKey(columns: string[], options?: {
+                name?: string | undefined;
+            } | undefined): {};
+            index(columns: orchid_core.MaybeArray<string | pqb.IndexColumnOptions>, options?: pqb.IndexOptions): {};
+            unique(columns: orchid_core.MaybeArray<string | pqb.IndexColumnOptions>, options?: pqb.IndexOptions | undefined): {};
+            searchIndex(columns: orchid_core.MaybeArray<string | pqb.IndexColumnOptions>, options?: pqb.IndexOptions | undefined): {};
+            constraint<Table_1 extends string | (() => orchid_core.ForeignKeyTable), Columns extends Table_1 extends () => orchid_core.ForeignKeyTable ? [orchid_core.ColumnNameOfTable<ReturnType<Table_1>>, ...orchid_core.ColumnNameOfTable<ReturnType<Table_1>>[]] : [string, ...string[]]>({ name, references, check, dropMode, }: {
+                name?: string | undefined;
+                references?: [columns: string[], fnOrTable: Table_1, foreignColumns: Columns, options?: pqb.ForeignKeyOptions | undefined] | undefined;
+                check?: orchid_core.RawSQLBase<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>, {}> | undefined;
+                dropMode?: pqb.DropMode | undefined;
+            }): {};
+            foreignKey<Table_2 extends string | (() => orchid_core.ForeignKeyTable), Columns_1 extends Table_2 extends () => orchid_core.ForeignKeyTable ? [orchid_core.ColumnNameOfTable<ReturnType<Table_2>>, ...orchid_core.ColumnNameOfTable<ReturnType<Table_2>>[]] : [string, ...string[]]>(columns: string[], fnOrTable: Table_2, foreignColumns: Columns_1, options?: (pqb.ForeignKeyOptions & {
+                name?: string | undefined;
+                dropMode?: pqb.DropMode | undefined;
+            }) | undefined): {};
+            check(check: orchid_core.RawSQLBase<orchid_core.ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>, {}>): {};
+        } : ColumnTypes, QueryDefaultReturnData<Shape_1>>>>(computed: Computed): Computed;
         belongsTo<Self extends any, Related extends TableClass<Table>, Scope extends Query, Options extends BelongsToOptions<Self, Related, Scope>>(this: Self, fn: () => Related, options: Options): {
             type: "belongsTo";
             fn: () => Related;

package/dist/index.js

@@ -25,7 +25,7 @@ const createBaseTable = ({
   const base = (_a = class {
     constructor() {
       this.snakeCase = snakeCase;
-      this.columnTypes = columnTypes;
+      this.types = columnTypes;
       this.q = {};
       this.language = language;
     }
@@ -73,6 +73,99 @@ const createBaseTable = ({
       }
       return this.constructor.prototype.columns = shape;
     }
+    /**
+     * You can add a generated column in the migration (see [generated](/guide/migration-column-methods.html#generated-column)),
+     * such column will persist in the database, it can be indexed.
+     *
+     * Or you can add a computed column on the ORM level, without adding it to the database, in such a way:
+     *
+     * ```ts
+     * import { BaseTable } from './baseTable';
+     *
+     * export class UserTable extends BaseTable {
+     *   readonly table = 'user';
+     *   columns = this.setColumns((t) => ({
+     *     id: t.identity().primaryKey(),
+     *     firstName: t.string(),
+     *     lastName: t.string(),
+     *   }));
+     *
+     *   computed = this.setComputed({
+     *     fullName: (q) =>
+     *       q.sql`${q.column('firstName')} || ' ' || ${q.column('lastName')}`.type(
+     *         (t) => t.string(),
+     *       ),
+     *   });
+     * }
+     * ```
+     *
+     * `setComputed` takes an object where keys are computed column names, and values are functions returning raw SQL.
+     *
+     * Use `q.column` as shown above to reference a table column, it will be prefixed with a correct table name even if the table is joined under a different name.
+     *
+     * Computed columns are not selected by default, only on demand:
+     *
+     * ```ts
+     * const a = await db.user.take();
+     * a.fullName; // not selected
+     *
+     * const b = await db.user.select('*', 'fullName');
+     * b.fullName; // selected
+     *
+     * // Table post belongs to user as an author.
+     * // it's possible to select joined computed column:
+     * const posts = await db.post
+     *   .join('author')
+     *   .select('post.title', 'author.fullName');
+     * ```
+     *
+     * SQL query can be generated dynamically based on the current request context.
+     *
+     * Imagine we are using [AsyncLocalStorage](https://nodejs.org/api/async_context.html#asynchronous-context-tracking)
+     * to keep track of current user's language.
+     *
+     * And we have articles translated to different languages, each article has `title_en`, `title_uk`, `title_be` and so on.
+     *
+     * We can define a computed `title` by passing a function into `sql` method:
+     *
+     * ```ts
+     * type Locale = 'en' | 'uk' | 'be';
+     * const asyncLanguageStorage = new AsyncLocalStorage<Locale>();
+     * const defaultLocale: Locale = 'en';
+     *
+     * export class ArticleTable extends BaseTable {
+     *   readonly table = 'article';
+     *   columns = this.setColumns((t) => ({
+     *     id: t.identity().primaryKey(),
+     *     title_en: t.text(),
+     *     title_uk: t.text().nullable(),
+     *     title_be: t.text().nullable(),
+     *   }));
+     *
+     *   computed = this.setComputed({
+     *     title: (q) =>
+     *       q
+     *         // .sql can take a function that accepts `sql` argument and must return SQL
+     *         .sql((sql) => {
+     *           // get locale dynamically based on current storage value
+     *           const locale = asyncLanguageStorage.getStore() || defaultLocale;
+     *
+     *           // use COALESCE in case when localized title is NULL, use title_en
+     *           return sql`COALESCE(
+     *             ${q.column(`title_${locale}`)},
+     *             ${q.column(`title_${defaultLocale}`)}
+     *           )`;
+     *         })
+     *         .type((t) => t.text()),
+     *   });
+     * }
+     * ```
+     *
+     * @param computed - object where keys are column names and values are functions returning raw SQL
+     */
+    setComputed(computed) {
+      return computed;
+    }
     belongsTo(fn, options) {
       return {
         type: "belongsTo",
@@ -103,7 +196,7 @@ const createBaseTable = ({
     }
   }, _a.nowSQL = nowSQL, _a.exportAs = exportAs, _a.schema = schemaProvider, _a);
   orchidCore.applyMixins(base, [pqb.QueryHooks]);
-  base.prototype.columnTypes = columnTypes;
+  base.prototype.types = columnTypes;
   return base;
 };
 
@@ -1705,7 +1798,7 @@ const orchidORM = (_a, tables) => {
       qb,
       table.table,
       table.columns,
-      table.columnTypes,
+      table.types,
       transactionStorage,
       options2
     );
@@ -1713,6 +1806,12 @@ const orchidORM = (_a, tables) => {
     dbTable.db = result;
     dbTable.filePath = table.filePath;
     dbTable.name = table.constructor.name;
+    if (table.computed) {
+      pqb.addComputedColumns(
+        dbTable,
+        table.computed
+      );
+    }
     result[key] = dbTable;
   }
   applyRelations(qb, tableInstances, result);