orchid-orm 1.18.0 → 1.18.1

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-import { Query, QueryWithTable, SetQueryTableAlias, RelationJoinQuery, WhereArg, UpdateData, CreateData, AddQueryDefaults, Db, IsolationLevel, TransactionOptions, Adapter, FromArgs, FromResult, AdapterOptions, QueryLogOptions, NoPrimaryKeyOption, RelationQuery, RelationConfigBase, RelationQueryBase, ComputedColumnsBase, QueryData, QueryBase, DefaultColumnTypes, QueryBeforeHook, QueryAfterHook, AfterHook, WhereResult, MergeQuery, SetQueryReturns, QueryReturnType } from 'pqb';
+import { Query, QueryWithTable, SetQueryTableAlias, RelationJoinQuery, WhereArg, UpdateData, CreateData, AddQueryDefaults, Db, IsolationLevel, TransactionOptions, Adapter, FromArgs, FromResult, AdapterOptions, QueryLogOptions, NoPrimaryKeyOption, RelationQuery, RelationConfigBase, RelationQueryBase, ComputedColumnsBase, QueryData, QueryBase, DbTableOptionScopes, DefaultColumnTypes, QueryBeforeHook, QueryAfterHook, AfterHook, WhereResult, MergeQuery, SetQueryReturns, QueryReturnType } from 'pqb';
 export * from 'pqb';
-import { EmptyObject, MaybeArray, StringKey, ColumnsShapeBase, ColumnShapeQueryType, ColumnShapeOutput, ColumnShapeInput } from 'orchid-core';
+import { ColumnsShapeBase, EmptyObject, MaybeArray, StringKey, CoreQueryScopes, ColumnShapeQueryType, ColumnShapeOutput, ColumnShapeInput } from 'orchid-core';
 
 type RelationCommonOptions<Related extends TableClass = TableClass, Scope extends Query = Query> = {
     scope?: ScopeFn<Related, Scope>;
@@ -25,7 +25,7 @@ type BelongsTo = RelationThunkBase & {
     type: 'belongsTo';
     options: BelongsToOptions;
 };
-type BelongsToOptions<Self extends Table = Table, Related extends TableClass = TableClass, Scope extends Query = Query> = RelationCommonOptions<Related, Scope> & RelationRefsOrKeysOptions<keyof Self['columns'], keyof InstanceType<Related>['columns'], keyof InstanceType<Related>['columns'], keyof Self['columns']>;
+type BelongsToOptions<Columns extends ColumnsShapeBase = ColumnsShapeBase, Related extends TableClass = TableClass, Scope extends Query = Query> = RelationCommonOptions<Related, Scope> & RelationRefsOrKeysOptions<keyof Columns, keyof InstanceType<Related>['columns'], keyof InstanceType<Related>['columns'], keyof Columns>;
 type BelongsToInfo<T extends Table, Relation extends BelongsTo, K extends string, FK extends string = Relation['options'] extends RelationRefsOptions ? Relation['options']['columns'][number] : Relation['options'] extends RelationKeysOptions ? Relation['options']['foreignKey'] : never, Q extends QueryWithTable = SetQueryTableAlias<DbTable<ReturnType<Relation['fn']>>, K>, DataForCreate = RelationToOneDataForCreate<{
     nestedCreateQuery: Q;
     table: Q;
@@ -76,7 +76,7 @@ type HasMany = RelationThunkBase & {
     type: 'hasMany';
     options: HasManyOptions;
 };
-type HasManyOptions<Self extends Table = Table, Related extends TableClass = TableClass, Scope extends Query = Query, Through extends string = string, Source extends string = string> = HasOneOptions<Self, Related, Scope, Through, Source>;
+type HasManyOptions<Columns extends ColumnsShapeBase = ColumnsShapeBase, Related extends TableClass = TableClass, Scope extends Query = Query, Through extends string = string, Source extends string = string> = HasOneOptions<Columns, Related, Scope, Through, Source>;
 type HasManyInfo<T extends Table, Relations extends RelationThunks, Relation extends HasMany, K extends string, Populate extends Record<string, true> = Relation['options'] extends RelationRefsOptions ? Record<Relation['options']['references'][number], true> : Relation['options'] extends RelationKeysOptions ? Record<Relation['options']['foreignKey'], true> : never, TC extends TableClass = ReturnType<Relation['fn']>, Q extends QueryWithTable = SetQueryTableAlias<DbTable<TC>, K>, NestedCreateQuery extends Query = Relation['options'] extends RelationThroughOptions ? Q : AddQueryDefaults<Q, Populate>> = {
     table: Q;
     query: Q;
@@ -114,7 +114,7 @@ type HasOne = RelationThunkBase & {
     type: 'hasOne';
     options: HasOneOptions;
 };
-type HasOneOptions<Self extends Table = Table, Related extends TableClass = TableClass, Scope extends Query = Query, Through extends string = string, Source extends string = string> = RelationCommonOptions<Related, Scope> & (RelationHasOptions<keyof Self['columns'], keyof InstanceType<Related>['columns']> | RelationThroughOptions<Through, Source>);
+type HasOneOptions<Columns extends ColumnsShapeBase = ColumnsShapeBase, Related extends TableClass = TableClass, Scope extends Query = Query, Through extends string = string, Source extends string = string> = RelationCommonOptions<Related, Scope> & (RelationHasOptions<keyof Columns, keyof InstanceType<Related>['columns']> | RelationThroughOptions<Through, Source>);
 type HasOneInfo<T extends Table, Relations extends RelationThunks, Relation extends HasOne, K extends string, Populate extends Record<string, true> = Relation['options'] extends RelationRefsOptions ? Record<Relation['options']['references'][number], true> : Relation['options'] extends RelationKeysOptions ? Record<Relation['options']['foreignKey'], true> : never, TC extends TableClass = ReturnType<Relation['fn']>, Q extends QueryWithTable = SetQueryTableAlias<DbTable<TC>, K>, NestedCreateQuery extends Query = Relation['options'] extends RelationThroughOptions ? Q : AddQueryDefaults<Q, Populate>> = {
     table: Q;
     query: Q;
@@ -239,8 +239,8 @@ type HasAndBelongsToMany = RelationThunkBase & {
     type: 'hasAndBelongsToMany';
     options: HasAndBelongsToManyOptions;
 };
-type HasAndBelongsToManyOptions<Self extends Table = Table, Related extends TableClass = TableClass, Scope extends Query = Query> = RelationCommonOptions<Related, Scope> & ({
-    columns: (keyof Self['columns'])[];
+type HasAndBelongsToManyOptions<Columns extends ColumnsShapeBase = ColumnsShapeBase, Related extends TableClass = TableClass, Scope extends Query = Query> = RelationCommonOptions<Related, Scope> & ({
+    columns: (keyof Columns)[];
     references: string[];
     through: {
         table: string;
@@ -248,7 +248,7 @@ type HasAndBelongsToManyOptions<Self extends Table = Table, Related extends Tabl
         references: (keyof InstanceType<Related>['columns'])[];
     };
 } | {
-    primaryKey: keyof Self['columns'];
+    primaryKey: keyof Columns;
     foreignKey: string;
     joinTable: string;
     associationPrimaryKey: string;
@@ -344,7 +344,7 @@ type TableClass<T extends Table = Table> = {
 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'];
-} : T['columns']> & {
+} : T['columns'], T['scopes']> & {
     definedAs: string;
     db: OrchidORM;
     getFilePath(): string;
@@ -364,6 +364,7 @@ type Table = {
      * collect computed columns returned by {@link BaseTable.setColumns}
      */
     computed?: ComputedColumnsBase<never>;
+    scopes?: CoreQueryScopes;
 };
 type Queryable<T extends Table> = Partial<ColumnShapeQueryType<T['columns']>>;
 type Selectable<T extends Table> = ColumnShapeOutput<T['columns']>;
@@ -478,22 +479,37 @@ interface BaseTableInstance<ColumnTypes> {
      * @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): {
+    /**
+     * See {@link ScopeMethods}
+     */
+    setScopes<Table extends string, Columns extends ColumnsShapeBase, Keys extends string>(this: {
+        table: Table;
+        columns: Columns;
+    }, scopes: DbTableOptionScopes<Table, Columns, Keys>): CoreQueryScopes<Keys>;
+    belongsTo<Columns extends ColumnsShapeBase, Related extends TableClass, Scope extends Query, Options extends BelongsToOptions<Columns, Related, Scope>>(this: {
+        columns: Columns;
+    }, 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): {
+    hasOne<Columns extends ColumnsShapeBase, Related extends TableClass, Scope extends Query, Through extends string, Source extends string, Options extends HasOneOptions<Columns, Related, Scope, Through, Source>>(this: {
+        columns: Columns;
+    }, 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): {
+    hasMany<Columns extends ColumnsShapeBase, Related extends TableClass, Scope extends Query, Through extends string, Source extends string, Options extends HasManyOptions<Columns, Related, Scope, Through, Source>>(this: {
+        columns: Columns;
+    }, 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): {
+    hasAndBelongsToMany<Columns extends ColumnsShapeBase, Related extends TableClass, Scope extends Query, Options extends HasAndBelongsToManyOptions<Columns, Related, Scope>>(this: {
+        columns: Columns;
+    }, fn: () => Related, options: Options): {
         type: 'hasAndBelongsToMany';
         fn: () => Related;
         options: Options;

package/dist/index.js

@@ -82,6 +82,9 @@ function createBaseTable({
     setComputed(computed) {
       return computed;
     }
+    setScopes(scopes) {
+      return scopes;
+    }
     belongsTo(fn, options) {
       return {
         type: "belongsTo",
@@ -1756,7 +1759,8 @@ const orchidORM = (_a, tables) => {
     tableInstances[key] = table;
     const options2 = __spreadProps(__spreadValues$1({}, commonOptions), {
       schema: table.schema,
-      language: table.language
+      language: table.language,
+      scopes: table.scopes
     });
     if (table.noPrimaryKey)
       options2.noPrimaryKey = "ignore";