orchid-orm 1.17.36 → 1.17.37

package/dist/index.d.ts

@@ -337,7 +337,10 @@ type MapRelations<T extends Table> = T extends {
     [K in keyof T['relations']]: MapRelation<T, T['relations'], K>;
 } : EmptyObject;
 
-type TableClass<T extends Table = Table> = new () => T;
+type TableClass<T extends Table = Table> = {
+    new (): T;
+    instance(): T;
+};
 type TableClasses = Record<string, TableClass>;
 type TableToDb<T extends Table, RelationQueries extends Record<string, RelationQueryBase>> = Db<T['table'], T['columns'], RelationQueries, T['types'], T['computed'] extends ComputedColumnsBase<never> ? T['columns'] & {
     [K in keyof T['computed']]: ReturnType<T['computed'][K]>['_type'];
@@ -370,151 +373,153 @@ type BeforeHookMethod = <T extends Table>(cb: QueryBeforeHook) => T;
 type AfterHookMethod = <T extends Table>(cb: QueryAfterHook) => T;
 type AfterSelectableHookMethod = <T extends Table, S extends (keyof T['columns'])[]>(this: T, select: S, cb: AfterHook<S, T['columns']>) => T;
 type SchemaProviderBase = any;
+interface BaseTableInstance<ColumnTypes> {
+    table: string;
+    columns: ColumnsShapeBase;
+    schema?: string;
+    noPrimaryKey?: boolean;
+    snakeCase?: boolean;
+    types: ColumnTypes;
+    q: QueryData;
+    language?: string;
+    filePath: string;
+    result: ColumnsShapeBase;
+    clone<T extends QueryBase>(this: T): T;
+    getFilePath(): string;
+    setColumns<T extends ColumnsShapeBase>(fn: (t: ColumnTypes) => T): T;
+    /**
+     * 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 extends string, Shape extends ColumnsShapeBase, Computed extends ComputedColumnsBase<Db<Table, Shape, EmptyObject, ColumnTypes>>>(computed: Computed): Computed;
+    belongsTo<Self extends Table, Related extends TableClass, Scope extends Query, Options extends BelongsToOptions<Self, Related, Scope>>(this: Self, fn: () => Related, options: Options): {
+        type: 'belongsTo';
+        fn: () => Related;
+        options: Options;
+    };
+    hasOne<Self extends Table, Related extends TableClass, Scope extends Query, Through extends string, Source extends string, Options extends HasOneOptions<Self, Related, Scope, Through, Source>>(this: Self, fn: () => Related, options: Options): {
+        type: 'hasOne';
+        fn: () => Related;
+        options: Options;
+    };
+    hasMany<Self extends Table, Related extends TableClass, Scope extends Query, Through extends string, Source extends string, Options extends HasManyOptions<Self, Related, Scope, Through, Source>>(this: Self, fn: () => Related, options: Options): {
+        type: 'hasMany';
+        fn: () => Related;
+        options: Options;
+    };
+    hasAndBelongsToMany<Self extends Table, Related extends TableClass, Scope extends Query, Options extends HasAndBelongsToManyOptions<Self, Related, Scope>>(this: Self, fn: () => Related, options: Options): {
+        type: 'hasAndBelongsToMany';
+        fn: () => Related;
+        options: Options;
+    };
+    beforeQuery: BeforeHookMethod;
+    afterQuery: AfterHookMethod;
+    beforeCreate: BeforeHookMethod;
+    afterCreate: AfterSelectableHookMethod;
+    afterCreateCommit: AfterSelectableHookMethod;
+    beforeUpdate: BeforeHookMethod;
+    afterUpdate: AfterSelectableHookMethod;
+    afterUpdateCommit: AfterSelectableHookMethod;
+    beforeSave: BeforeHookMethod;
+    afterSave: AfterSelectableHookMethod;
+    afterSaveCommit: AfterSelectableHookMethod;
+    beforeDelete: BeforeHookMethod;
+    afterDelete: AfterSelectableHookMethod;
+    afterDeleteCommit: AfterSelectableHookMethod;
+}
 interface BaseTableClass<ColumnTypes, SchemaProvider extends SchemaProviderBase> {
     nowSQL: string | undefined;
     exportAs: string;
     schema: SchemaProvider;
     getFilePath(): string;
-    new (): {
-        table: string;
-        columns: ColumnsShapeBase;
-        schema?: string;
-        noPrimaryKey?: boolean;
-        snakeCase?: boolean;
-        types: ColumnTypes;
-        q: QueryData;
-        language?: string;
-        filePath: string;
-        result: ColumnsShapeBase;
-        clone<T extends QueryBase>(this: T): T;
-        getFilePath(): string;
-        setColumns<T extends ColumnsShapeBase>(fn: (t: ColumnTypes) => T): T;
-        /**
-         * 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 extends string, Shape extends ColumnsShapeBase, Computed extends ComputedColumnsBase<Db<Table, Shape, EmptyObject, ColumnTypes>>>(computed: Computed): Computed;
-        belongsTo<Self extends Table, Related extends TableClass, Scope extends Query, Options extends BelongsToOptions<Self, Related, Scope>>(this: Self, fn: () => Related, options: Options): {
-            type: 'belongsTo';
-            fn: () => Related;
-            options: Options;
-        };
-        hasOne<Self extends Table, Related extends TableClass, Scope extends Query, Through extends string, Source extends string, Options extends HasOneOptions<Self, Related, Scope, Through, Source>>(this: Self, fn: () => Related, options: Options): {
-            type: 'hasOne';
-            fn: () => Related;
-            options: Options;
-        };
-        hasMany<Self extends Table, Related extends TableClass, Scope extends Query, Through extends string, Source extends string, Options extends HasManyOptions<Self, Related, Scope, Through, Source>>(this: Self, fn: () => Related, options: Options): {
-            type: 'hasMany';
-            fn: () => Related;
-            options: Options;
-        };
-        hasAndBelongsToMany<Self extends Table, Related extends TableClass, Scope extends Query, Options extends HasAndBelongsToManyOptions<Self, Related, Scope>>(this: Self, fn: () => Related, options: Options): {
-            type: 'hasAndBelongsToMany';
-            fn: () => Related;
-            options: Options;
-        };
-        beforeQuery: BeforeHookMethod;
-        afterQuery: AfterHookMethod;
-        beforeCreate: BeforeHookMethod;
-        afterCreate: AfterSelectableHookMethod;
-        afterCreateCommit: AfterSelectableHookMethod;
-        beforeUpdate: BeforeHookMethod;
-        afterUpdate: AfterSelectableHookMethod;
-        afterUpdateCommit: AfterSelectableHookMethod;
-        beforeSave: BeforeHookMethod;
-        afterSave: AfterSelectableHookMethod;
-        afterSaveCommit: AfterSelectableHookMethod;
-        beforeDelete: BeforeHookMethod;
-        afterDelete: AfterSelectableHookMethod;
-        afterDeleteCommit: AfterSelectableHookMethod;
-    };
+    new (): BaseTableInstance<ColumnTypes>;
+    instance(): BaseTableInstance<ColumnTypes>;
 }
 declare function createBaseTable<SchemaProvider extends SchemaProviderBase, ColumnTypes = DefaultColumnTypes>({ columnTypes: columnTypesArg, snakeCase, filePath: filePathArg, nowSQL, exportAs, language, schemaProvider: schemaProviderArg, }?: {
     columnTypes?: ColumnTypes | ((t: DefaultColumnTypes) => ColumnTypes);
@@ -545,4 +550,4 @@ type Repo<T extends Query, Methods extends MethodsBase<T>, Mapped = MapMethods<T
 }>(q: Q) => Q & Mapped) & T & Mapped;
 declare const createRepo: <T extends Query, Methods extends MethodsBase<T>>(table: T, methods: Methods) => Repo<T, Methods, MapMethods<T, Methods>>;
 
-export { BaseTableClass, DbTable, Insertable, MapMethods, MapQueryMethods, MethodsBase, OrchidORM, QueryMethods, Queryable, Repo, ScopeFn, Selectable, Table, TableClass, TableClasses, TableToDb, Updateable, createBaseTable, createRepo, orchidORM };
+export { BaseTableClass, BaseTableInstance, DbTable, Insertable, MapMethods, MapQueryMethods, MethodsBase, OrchidORM, QueryMethods, Queryable, Repo, ScopeFn, Selectable, Table, TableClass, TableClasses, TableToDb, Updateable, createBaseTable, createRepo, orchidORM };

package/dist/index.js

@@ -44,6 +44,10 @@ function createBaseTable({
         `Failed to determine file path of a base table. Please set the \`filePath\` option of \`createBaseTable\` manually.`
       );
     }
+    static instance() {
+      var _a2;
+      return (_a2 = this._instance) != null ? _a2 : this._instance = new this();
+    }
     clone() {
       return this;
     }
@@ -73,7 +77,7 @@ function createBaseTable({
           }
         }
       }
-      return this.constructor.prototype.columns = shape;
+      return shape;
     }
     setComputed(computed) {
       return computed;
@@ -1696,7 +1700,7 @@ const orchidORM = (_a, tables) => {
     if (key[0] === "$") {
       throw new Error(`Table class name must not start with $`);
     }
-    const table = new tables[key]();
+    const table = tables[key].instance();
     tableInstances[key] = table;
     const options2 = __spreadProps(__spreadValues$1({}, commonOptions), {
       schema: table.schema,