drizzle-orm 1.0.0-beta.1-84d9a79 → 1.0.0-beta.1-d407048

package/relations.d.cts

@@ -1,77 +1,72 @@
-import { type AnyTable, Table } from "./table.cjs";
+import { Table } from "./table.cjs";
 import type { CasingCache } from "./casing.cjs";
 import { type AnyColumn, Column } from "./column.cjs";
 import { entityKind } from "./entity.cjs";
 import { and, arrayContained, arrayContains, arrayOverlaps, asc, between, desc, exists, ilike, inArray, isNotNull, isNull, like, not, notBetween, notExists, notIlike, notInArray, notLike, or } from "./sql/expressions/index.cjs";
 import { Placeholder, SQL, sql, type SQLWrapper, View } from "./sql/sql.cjs";
 import type { Assume, DrizzleTypeError, Equal, Simplify, ValueOrArray } from "./utils.cjs";
-export type FieldValue = Column | SQLWrapper | SQL.Aliased | SQL;
+export type FilteredSchemaEntry = Table<any> | View<string, boolean, FieldSelection>;
+export type SchemaEntry = Table<any> | View<string, boolean, any>;
+export type Schema = Record<string, SchemaEntry>;
+export type GetTableViewColumns<T extends SchemaEntry> = T extends View<string, boolean, any> ? T['_']['selectedFields'] : T extends Table<any> ? T['_']['columns'] : never;
+export type GetTableViewFieldSelection<T extends SchemaEntry> = T extends View<string, boolean, FieldSelection> ? T['_']['selectedFields'] : T extends Table<any> ? T['_']['columns'] : never;
+export type FieldValue = Column<any> | SQLWrapper | SQL.Aliased | SQL;
 export type FieldSelection = Record<string, FieldValue>;
-export declare class Relations<TSchema extends Record<string, unknown> = Record<string, unknown>, TTables extends Record<string, Table | View> = Record<string, Table | View>, TConfig extends RelationsBuilderConfig<TTables> = RelationsBuilderConfig<TTables>> {
-    readonly schema: TSchema;
-    readonly tables: TTables;
-    readonly config: TConfig;
-    static readonly [entityKind]: string;
-    readonly $brand: 'RelationsV2';
-    /** table DB name -> schema table key */
-    readonly tableNamesMap: Record<string, string>;
-    readonly tablesConfig: TablesRelationalConfig;
-    constructor(schema: TSchema, tables: TTables, config: TConfig);
-}
-export type EmptyRelations = Relations<Record<string, never>, Record<string, never>, Record<string, never>>;
-export type AnyRelations = Relations<Record<string, any>, Record<string, any>, Record<string, any>>;
+export declare function processRelations(tablesConfig: TablesRelationalConfig, tables: Schema): TablesRelationalConfig;
+/** Builds relational config for every table in schema */
+export declare function buildRelations<TTables extends Schema, TConfig extends AnyRelationsBuilderConfig>(tables: TTables, config: TConfig): ExtractTablesWithRelations<TConfig, TTables>;
+/** Builds relational config only for tables present in relational config */
+export declare function buildRelationsParts<TTables extends Schema, TConfig extends AnyRelationsBuilderConfig>(tables: TTables, config: TConfig): ExtractTablesWithRelationsParts<TConfig, TTables>;
+export type RelationsRecord = Record<string, AnyRelation>;
+export type EmptyRelations = {};
+export type AnyRelations = TablesRelationalConfig;
 export declare abstract class Relation<TSourceTableName extends string = string, TTargetTableName extends string = string> {
-    readonly targetTable: AnyTable<{
-        name: TTargetTableName;
-    }> | View<TTargetTableName>;
+    readonly targetTableName: TTargetTableName;
     static readonly [entityKind]: string;
     readonly $brand: 'RelationV2';
+    readonly relationType: 'many' | 'one';
     fieldName: string;
-    sourceColumns: AnyColumn<{
-        tableName: TSourceTableName;
-    }>[];
-    targetColumns: AnyColumn<{
-        tableName: TTargetTableName;
-    }>[];
+    sourceColumns: Column<any>[];
+    targetColumns: Column<any>[];
     alias: string | undefined;
     where: AnyTableFilter | undefined;
-    sourceTable: AnyTable<{
-        name: TSourceTableName;
-    }> | View<TSourceTableName>;
+    sourceTable: SchemaEntry;
+    targetTable: SchemaEntry;
     through?: {
         source: RelationsBuilderColumnBase[];
         target: RelationsBuilderColumnBase[];
     };
-    throughTable?: Table | View;
+    throughTable?: SchemaEntry;
     isReversed?: boolean;
-    constructor(targetTable: AnyTable<{
-        name: TTargetTableName;
-    }> | View<TTargetTableName>);
+    /** Type-level only field */
+    readonly sourceTableName: TSourceTableName;
+    constructor(targetTable: SchemaEntry, targetTableName: TTargetTableName);
 }
+export type AnyRelation = Relation<string, string>;
 export declare class One<TSourceTableName extends string, TTargetTableName extends string, TOptional extends boolean = boolean> extends Relation<TSourceTableName, TTargetTableName> {
     static readonly [entityKind]: string;
     protected $relationBrand: 'OneV2';
+    readonly relationType: "one";
     readonly optional: TOptional;
-    constructor(tables: Record<string, Table | View>, targetTable: AnyTable<{
-        name: TTargetTableName;
-    }> | View<TTargetTableName>, config: AnyOneConfig | undefined);
+    constructor(tables: Schema, targetTable: SchemaEntry, targetTableName: TTargetTableName, config: AnyOneConfig | undefined);
 }
+export type AnyOne = One<string, string, boolean>;
 export declare class Many<TSourceTableName extends string, TTargetTableName extends string> extends Relation<TSourceTableName, TTargetTableName> {
     readonly config: AnyManyConfig | undefined;
     static readonly [entityKind]: string;
     protected $relationBrand: 'ManyV2';
-    constructor(tables: Record<string, Table | View>, targetTable: AnyTable<{
-        name: TTargetTableName;
-    }> | View<TTargetTableName>, config: AnyManyConfig | undefined);
+    readonly relationType: "many";
+    constructor(tables: Schema, targetTable: SchemaEntry, targetTableName: TTargetTableName, config: AnyManyConfig | undefined);
 }
+export type AnyMany = Many<string, string>;
 export declare abstract class AggregatedField<T = unknown> implements SQLWrapper<T> {
     static readonly [entityKind]: string;
     readonly $brand: 'AggregatedField';
     readonly _: {
         readonly data: T;
     };
-    protected table: Table | View | undefined;
-    onTable(table: Table | View): this;
+    protected table: SchemaEntry | undefined;
+    onTable(table: SchemaEntry): this;
     abstract getSQL(): SQL<T>;
 }
 export declare class Count extends AggregatedField<number> {
@@ -81,9 +76,6 @@ export declare class Count extends AggregatedField<number> {
     getSQL(): SQL<number>;
 }
 export type ExtractObjectValues<T> = T[keyof T];
-export type ExtractRelationsFromTableExtraConfigSchema<TConfig extends unknown[]> = ExtractObjectValues<{
-    [K in keyof TConfig as TConfig[K] extends Relations<any> ? K : never]: TConfig[K] extends Relations<infer TRelationConfig> ? TRelationConfig : never;
-}>;
 export declare const operators: {
     and: typeof and;
     between: typeof between;
@@ -117,106 +109,92 @@ export declare const orderByOperators: {
     asc: typeof asc;
     desc: typeof desc;
 };
-export declare function getOrderByOperators(): {
-    sql: typeof sql;
-    asc: typeof asc;
-    desc: typeof desc;
-};
-export type OrderByOperators = ReturnType<typeof getOrderByOperators>;
-export type FindTableInRelationalConfig<TSchema extends TablesRelationalConfig, TTargetTable extends Table | View, TTableName extends string = TTargetTable['_']['name']> = ExtractObjectValues<{
-    [K in keyof TSchema as TSchema[K]['tsName'] extends TTableName ? K : never]: TSchema[K];
-}>;
+export type OrderByOperators = typeof orderByOperators;
+export declare function getOrderByOperators(): OrderByOperators;
+export type FindTargetTableInRelationalConfig<TConfig extends TablesRelationalConfig, TRelation extends AnyRelation> = TConfig[TRelation['targetTableName']];
 export interface SQLOperator {
     sql: Operators['sql'];
 }
+export type DBQueryConfigColumns<TColumns extends FieldSelection> = {
+    [K in keyof TColumns]?: boolean | undefined;
+};
+export type DBQueryConfigExtras<TTable extends SchemaEntry> = Record<string, SQLWrapper | ((table: TTable, operators: SQLOperator) => SQLWrapper)>;
+export type DBQueryConfigOrderByCallback<TTable extends SchemaEntry> = (table: TTable, operators: OrderByOperators) => ValueOrArray<AnyColumn | SQL>;
+export type DBQueryConfigOrderByObject<TColumns extends FieldSelection> = {
+    [K in keyof TColumns]?: 'asc' | 'desc' | undefined;
+};
+export type DBQueryConfigOrderBy<TTable extends SchemaEntry, TColumns extends FieldSelection> = DBQueryConfigOrderByCallback<TTable> | DBQueryConfigOrderByObject<TColumns>;
+export type DBQueryConfigWith<TSchema extends TablesRelationalConfig, TRelations extends RelationsRecord> = {
+    [K in keyof TRelations]?: boolean | (DBQueryConfig<TRelations[K]['relationType'], TSchema, FindTargetTableInRelationalConfig<TSchema, TRelations[K]>, true>) | undefined;
+};
 export type DBQueryConfig<TRelationType extends 'one' | 'many' = 'one' | 'many', TSchema extends TablesRelationalConfig = TablesRelationalConfig, TTableConfig extends TableRelationalConfig = TableRelationalConfig, TIsNested extends boolean = false> = (TTableConfig['relations'] extends Record<string, never> ? {} : {
-    with?: {
-        [K in keyof TTableConfig['relations']]?: boolean | (TTableConfig['relations'][K] extends Relation ? DBQueryConfig<TTableConfig['relations'][K] extends One<string, string> ? 'one' : 'many', TSchema, FindTableInRelationalConfig<TSchema, TTableConfig['relations'][K]['targetTable']>, true> : never) | undefined;
-    } | undefined;
+    with?: DBQueryConfigWith<TSchema, TTableConfig['relations']> | undefined;
 }) & {
-    columns?: {
-        [K in keyof TTableConfig['columns']]?: boolean | undefined;
-    } | undefined;
+    columns?: DBQueryConfigColumns<GetTableViewFieldSelection<TTableConfig['table']>> | undefined;
     where?: RelationsFilter<TTableConfig, TSchema> | undefined;
-    extras?: Record<string, SQLWrapper | ((table: TTableConfig['table'], operators: SQLOperator) => SQLWrapper)> | undefined;
+    extras?: DBQueryConfigExtras<TTableConfig['table']> | undefined;
 } & (`${TRelationType}_${TIsNested}` extends 'one_true' ? {} : {
-    orderBy?: {
-        [K in keyof TTableConfig['columns']]?: 'asc' | 'desc' | undefined;
-    } | ((table: TTableConfig['table'], operators: OrderByOperators) => ValueOrArray<AnyColumn | SQL>) | undefined;
+    orderBy?: DBQueryConfigOrderBy<TTableConfig['table'], GetTableViewFieldSelection<TTableConfig['table']>> | undefined;
     offset?: number | Placeholder | undefined;
 }) & (TRelationType extends 'many' ? {
     limit?: number | Placeholder | undefined;
 } : {});
 export type AnyDBQueryConfig = {
-    columns?: {
-        [K in keyof TableRelationalConfig['columns']]?: boolean | undefined;
-    } | undefined;
+    columns?: DBQueryConfigColumns<GetTableViewFieldSelection<TableRelationalConfig['table']>> | undefined;
     where?: RelationsFilter<TableRelationalConfig, TablesRelationalConfig> | undefined;
-    extras?: Record<string, SQLWrapper | ((table: TableRelationalConfig['table'], operators: SQLOperator) => SQLWrapper)> | undefined;
-    with?: {
-        [K in keyof TableRelationalConfig['relations']]?: boolean | (TableRelationalConfig['relations'][K] extends Relation ? DBQueryConfig<TableRelationalConfig['relations'][K] extends One<string, string> ? 'one' : 'many', TablesRelationalConfig, FindTableInRelationalConfig<TablesRelationalConfig, TableRelationalConfig['relations'][K]['targetTable']>> : never) | undefined;
-    } | undefined;
-    orderBy?: {
-        [K in keyof TableRelationalConfig['columns']]?: 'asc' | 'desc' | undefined;
-    } | ((table: TableRelationalConfig['table'], operators: OrderByOperators) => ValueOrArray<AnyColumn | SQL>) | undefined;
+    extras?: DBQueryConfigExtras<TableRelationalConfig['table']> | undefined;
+    with?: Record<string, AnyDBQueryConfig> | undefined;
+    orderBy?: DBQueryConfigOrderBy<TableRelationalConfig['table'], GetTableViewFieldSelection<TableRelationalConfig['table']>> | undefined;
     offset?: number | Placeholder | undefined;
     limit?: number | Placeholder | undefined;
 };
 export interface TableRelationalConfig {
-    table: Table | View;
-    tsName: string;
-    dbName: string;
-    schema: string | undefined;
-    columns: FieldSelection;
-    relations: Record<string, RelationsBuilderEntry>;
+    table: SchemaEntry;
+    name: string;
+    relations: RelationsRecord;
 }
 export type TablesRelationalConfig = Record<string, TableRelationalConfig>;
-export interface RelationalSchemaConfig<TTablesConfig extends TablesRelationalConfig> {
-    tables: Record<string, Table>;
-    tablesConfig: TTablesConfig;
-    tableNamesMap: Record<string, string>;
-}
-type NonUndefinedRecord<TRecord extends Record<string, any>> = {
-    [K in keyof TRecord as K extends undefined ? never : K]: TRecord[K];
-};
-export type ExtractTablesWithRelations<TRelations extends Relations, TTables extends Record<string, Table | View> = TRelations['tables']> = {
+export type ExtractTablesWithRelations<TConfig extends AnyRelationsBuilderConfig, TTables extends Schema> = {
     [K in keyof TTables]: {
         table: TTables[K];
-        tsName: K & string;
-        dbName: TTables[K]['_']['name'];
-        columns: TTables[K] extends Table ? TTables[K]['_']['columns'] : Assume<TTables[K], View>['_']['selectedFields'];
-        relations: K extends keyof TRelations['config'] ? TRelations['config'][K] extends Record<string, any> ? NonUndefinedRecord<TRelations['config'][K]> : Record<string, never> : Record<string, never>;
-        schema: TTables[K] extends Table ? TTables[K]['_']['schema'] : string | undefined;
+        name: K & string;
+        relations: TConfig extends {
+            [CK in K]: Record<string, any>;
+        } ? TConfig[K] : {};
+    };
+};
+export type ExtractTablesWithRelationsParts<TConfig extends AnyRelationsBuilderConfig, TTables extends Schema> = {
+    [K in NonUndefinedKeysOnly<TConfig> & keyof TTables]: {
+        table: TTables[K & string];
+        name: K & string;
+        relations: TConfig[K] extends Record<string, any> ? TConfig[K] : {};
     };
 };
 export type ReturnTypeOrValue<T> = T extends (...args: any[]) => infer R ? R : T;
-export type BuildRelationResult<TConfig extends TablesRelationalConfig, TInclude, TRelations extends Record<string, RelationsBuilderEntry>> = {
-    [K in TruthyKeysOnly<TInclude> & keyof TRelations]: TRelations[K] extends infer TRel extends Relation ? BuildQueryResult<TConfig, FindTableInRelationalConfig<TConfig, TRel['targetTable']>, Assume<TInclude[K], true | Record<string, unknown>>> extends infer TResult ? TRel extends One<string, string> ? TResult | (Equal<TRel['optional'], true> extends true ? null : TInclude[K] extends Record<string, unknown> ? TInclude[K]['where'] extends Record<string, any> ? null : never : never) : TResult[] : never : TRelations[K] extends AggregatedField<infer TData> ? TData : never;
+export type RelationResultKind<TResult, TInclude, TRelation extends AnyRelation> = TRelation extends AnyOne ? (TResult | (Equal<TRelation['optional'], true> extends true ? null : TInclude extends Record<string, unknown> ? TInclude['where'] extends Record<string, any> ? null : never : never)) : TResult[];
+export type BuildRelationResult<TConfig extends TablesRelationalConfig, TInclude, TRelations extends RelationsRecord> = {
+    [K in TruthyKeysOnly<TInclude> & keyof TRelations]: TRelations[K] extends infer TRel extends AnyRelation ? RelationResultKind<BuildQueryResult<TConfig, FindTargetTableInRelationalConfig<TConfig, TRel>, Assume<TInclude[K], true | Record<string, unknown>>>, TInclude[K], TRel> : TRelations[K] extends AggregatedField<infer TData> ? TData : never;
 };
-export type NonUndefinedKeysOnly<T> = ExtractObjectValues<{
-    [K in keyof T as T[K] extends undefined ? never : K]: K;
-}> & keyof T;
-export type TruthyKeysOnly<T> = ExtractObjectValues<{
-    [K in keyof T as T[K] extends undefined | false ? never : K]: K;
-}> & keyof T;
-export type InferRelationalQueryTableResult<TTable extends Table | View, TRawSelection extends Record<string, unknown>, TSelectedFields extends Record<string, unknown> | 'Full' = 'Full', TFilteredSelection extends Record<string, unknown> = TSelectedFields extends 'Full' ? TRawSelection : {
+export type NonUndefinedKeysOnly<T> = {
+    [K in keyof T]: T[K] extends undefined ? never : K;
+}[keyof T];
+export type TruthyKeysOnly<T> = {
+    [K in keyof T]: T[K] extends undefined | false ? never : K;
+}[keyof T];
+export type InferRelationalQueryTableResult<TRawSelection extends Record<string, unknown>, TSelectedFields extends Record<string, unknown> | 'Full' = 'Full'> = TSelectedFields extends 'Full' ? TRawSelection : {
     [K in Equal<Exclude<TSelectedFields[keyof TSelectedFields & keyof TRawSelection], undefined>, false> extends true ? Exclude<keyof TRawSelection, NonUndefinedKeysOnly<TSelectedFields>> : {
         [K in keyof TSelectedFields]: Equal<TSelectedFields[K], true> extends true ? K : never;
     }[keyof TSelectedFields] & keyof TRawSelection]: TRawSelection[K];
-}> = {
-    [K in keyof TFilteredSelection]: TTable['$inferSelect'][Assume<K, keyof TTable['$inferSelect']>];
 };
-export type BuildQueryResult<TSchema extends TablesRelationalConfig, TTableConfig extends TableRelationalConfig, TFullSelection extends true | Record<string, unknown>> = Equal<TFullSelection, true> extends true ? Simplify<InferRelationalQueryTableResult<TTableConfig['table'], TTableConfig['columns']>> : TFullSelection extends Record<string, unknown> ? Simplify<(InferRelationalQueryTableResult<TTableConfig['table'], TTableConfig['columns'], TFullSelection['columns'] extends Record<string, unknown> ? TFullSelection['columns'] : 'Full'>) & (TFullSelection['extras'] extends Record<string, SQLWrapper | ((...args: any[]) => SQLWrapper)> ? {
-    [K in NonUndefinedKeysOnly<ReturnTypeOrValue<TFullSelection['extras']>>]: ReturnType<Assume<ReturnTypeOrValue<TFullSelection['extras'][K]>, SQLWrapper>['getSQL']>['_']['type'];
+export type BuildQueryResult<TSchema extends TablesRelationalConfig, TTableConfig extends TableRelationalConfig, TFullSelection extends true | Record<string, unknown>, TModel extends Record<string, unknown> = Assume<TTableConfig['table'], {
+    $inferSelect: Record<string, unknown>;
+}>['$inferSelect']> = Equal<TFullSelection, true> extends true ? Simplify<InferRelationalQueryTableResult<TModel>> : TFullSelection extends Record<string, unknown> ? Simplify<(InferRelationalQueryTableResult<TModel, TFullSelection['columns'] extends Record<string, unknown> ? TFullSelection['columns'] : 'Full'>) & (TFullSelection['extras'] extends Record<string, SQLWrapper | ((...args: any[]) => SQLWrapper)> ? {
+    [K in NonUndefinedKeysOnly<ReturnTypeOrValue<TFullSelection['extras']>>]: ReturnType<Assume<ReturnTypeOrValue<TFullSelection['extras'][K & string]>, SQLWrapper>['getSQL']>['_']['type'];
 } : {}) & (TFullSelection['with'] extends Record<string, unknown> ? BuildRelationResult<TSchema, TFullSelection['with'], TTableConfig['relations']> : {})> : never;
-export interface NormalizedRelation {
-    fields: AnyColumn[];
-    references: AnyColumn[];
-}
 export interface BuildRelationalQueryResult {
     selection: {
         key: string;
-        field: Column | Table | SQL | SQL.Aliased | SQLWrapper | AggregatedField;
+        field: Column<any> | Table | SQL | SQL.Aliased | SQLWrapper | AggregatedField;
         isArray?: boolean;
         selection?: BuildRelationalQueryResult['selection'];
         isOptional?: boolean;
@@ -228,57 +206,40 @@ export declare function mapRelationalRow(row: Record<string, unknown>, buildQuer
 parseJson?: boolean, path?: string): Record<string, unknown>;
 export declare class RelationsBuilderTable<TTableName extends string = string> {
     static readonly [entityKind]: string;
-    readonly _: {
+    protected readonly _: {
         readonly name: TTableName;
-        readonly table: AnyTable<{
-            name: TTableName;
-        }> | View<TTableName>;
+        readonly table: SchemaEntry;
     };
-    constructor(table: AnyTable<{
-        name: TTableName;
-    }> | View<TTableName>, key: string);
+    constructor(table: SchemaEntry, name: TTableName);
 }
-export interface RelationsBuilderColumnConfig<TTableName extends string = string, TData = unknown> {
+export interface RelationsBuilderColumnConfig<TTableName extends string = string> {
     readonly tableName: TTableName;
-    readonly data: TData;
-    readonly column: AnyColumn<{
-        tableName: TTableName;
-    }> | SQL<TData> | SQLWrapper<TData> | SQL.Aliased<TData>;
+    readonly column: FieldValue;
     readonly through?: RelationsBuilderColumnBase;
     readonly key: string;
 }
-export type RelationsBuilderColumnBase<TTableName extends string = string, TData = unknown> = {
-    _: RelationsBuilderColumnConfig<TTableName, TData>;
-};
-export declare class RelationsBuilderColumn<TTableName extends string = string, TData = unknown> implements RelationsBuilderColumnBase<TTableName, TData> {
+export interface RelationsBuilderColumnBase<TTableName extends string = string> {
+    _: RelationsBuilderColumnConfig<TTableName>;
+}
+export declare class RelationsBuilderColumn<TTableName extends string = string> implements RelationsBuilderColumnBase<TTableName> {
     static readonly [entityKind]: string;
     readonly _: {
         readonly tableName: TTableName;
-        readonly data: TData;
-        readonly column: AnyColumn<{
-            tableName: TTableName;
-        }> | SQL<TData> | SQLWrapper<TData> | SQL.Aliased<TData>;
+        readonly column: FieldValue;
         readonly key: string;
     };
-    constructor(column: AnyColumn<{
-        tableName: TTableName;
-    }> | SQL<TData> | SQLWrapper<TData> | SQL.Aliased<TData>, tableName: TTableName, key: string);
-    through(column: RelationsBuilderColumn): RelationsBuilderJunctionColumn<TTableName, TData>;
+    constructor(column: FieldValue, tableName: TTableName, key: string);
+    through(column: RelationsBuilderColumn): RelationsBuilderJunctionColumn<TTableName>;
 }
-export declare class RelationsBuilderJunctionColumn<TTableName extends string = string, TData = unknown> implements RelationsBuilderColumnBase<TTableName, TData> {
+export declare class RelationsBuilderJunctionColumn<TTableName extends string = string> implements RelationsBuilderColumnBase<TTableName> {
     static readonly [entityKind]: string;
     readonly _: {
         readonly tableName: TTableName;
-        readonly data: TData;
-        readonly column: AnyColumn<{
-            tableName: TTableName;
-        }> | SQL<TData> | SQLWrapper<TData> | SQL.Aliased<TData>;
+        readonly column: FieldValue;
         readonly through: RelationsBuilderColumnBase;
         readonly key: string;
     };
-    constructor(column: AnyColumn<{
-        tableName: TTableName;
-    }> | SQL<TData> | SQLWrapper<TData> | SQL.Aliased<TData>, tableName: TTableName, key: string, through: RelationsBuilderColumnBase);
+    constructor(column: FieldValue, tableName: TTableName, key: string, through: RelationsBuilderColumnBase);
 }
 export interface RelationFieldsFilterInternals<T> {
     eq?: T | Placeholder | undefined;
@@ -309,23 +270,34 @@ export interface RelationsFilterCommons<TTable extends TableRelationalConfig = T
     AND?: RelationsFilter<TTable, TSchema>[] | undefined;
     RAW?: SQLWrapper | ((table: TTable['table'], operators: Operators) => SQL) | undefined;
 }
-export type RelationsFilter<TTable extends TableRelationalConfig, TSchema extends TablesRelationalConfig, TRelations extends Record<string, Relation> = TTable['relations'], TColumns extends FieldSelection = TTable['columns']> = TTable['relations'] extends Record<string, never> ? TableFilter<TTable['table']> : {
-    [K in keyof TColumns]?: (TColumns[K] extends Column ? RelationsFieldFilter<TColumns[K]['_']['data']> : RelationsFieldFilter<unknown>) | undefined;
-} & {
-    [K in keyof TRelations]?: boolean | RelationsFilter<FindTableInRelationalConfig<TSchema, TRelations[K]['targetTable']>, TSchema> | undefined;
-} & RelationsFilterCommons<TTable, TSchema>;
-export interface TableFilterCommons<TTable extends Table | View = Table | View, TColumns extends FieldSelection = TTable extends View ? Assume<TTable['_']['selectedFields'], FieldSelection> : Assume<TTable, Table>['_']['columns']> {
+export type RelationsFilterColumns<TColumns extends Record<string, unknown>> = {
+    [K in keyof TColumns]?: (TColumns[K] extends {
+        _: {
+            data: infer Data;
+        };
+    } ? RelationsFieldFilter<Data> : RelationsFieldFilter<unknown>) | undefined;
+};
+export type RelationsFilterRelations<TTable extends TableRelationalConfig, TSchema extends TablesRelationalConfig, TRelations extends RelationsRecord = TTable['relations']> = {
+    [K in keyof TRelations]?: boolean | RelationsFilter<FindTargetTableInRelationalConfig<TSchema, TRelations[K]>, TSchema> | undefined;
+};
+export type RelationsFilter<TTable extends TableRelationalConfig, TSchema extends TablesRelationalConfig, TColumns extends FieldSelection = GetTableViewFieldSelection<TTable['table']>> = TTable['relations'] extends Record<string, never> ? TableFilter<TTable['table']> : RelationsFilterColumns<TColumns> & RelationsFilterRelations<TTable, TSchema> & RelationsFilterCommons<TTable, TSchema>;
+export interface TableFilterCommons<TTable extends SchemaEntry = SchemaEntry, TColumns extends Record<string, unknown> = GetTableViewColumns<TTable>> {
     OR?: TableFilter<TTable, TColumns>[] | undefined;
     NOT?: TableFilter<TTable, TColumns> | undefined;
     AND?: TableFilter<TTable, TColumns>[] | undefined;
     RAW?: SQLWrapper | ((table: TTable, operators: Operators) => SQL) | undefined;
 }
-export type TableFilter<TTable extends Table | View = Table | View, TColumns extends FieldSelection = TTable extends View ? Assume<TTable['_']['selectedFields'], FieldSelection> : Assume<TTable, Table>['_']['columns']> = {
-    [K in keyof TColumns as K extends keyof TableFilterCommons ? never : K]?: (TColumns[K] extends Column ? RelationsFieldFilter<TColumns[K]['_']['data']> : RelationsFieldFilter<unknown>) | undefined;
-} & TableFilterCommons<TTable, TColumns>;
-export type AnyRelationsFilter = RelationsFilter<TableRelationalConfig, TablesRelationalConfig, Record<string, Relation>, FieldSelection>;
-export type AnyTableFilter = TableFilter<Table | View, FieldSelection>;
-export interface OneConfig<TSchema extends Record<string, Table | View>, TSourceColumns extends Readonly<[RelationsBuilderColumnBase, ...RelationsBuilderColumnBase[]]> | Readonly<RelationsBuilderColumnBase>, TTargetTableName extends string, TOptional extends boolean> {
+export type TableFilterColumns<TColumns extends Record<string, unknown>> = {
+    [K in keyof TColumns]?: (TColumns[K] extends {
+        _: {
+            data: infer Data;
+        };
+    } ? RelationsFieldFilter<Data> : RelationsFieldFilter<unknown>) | undefined;
+};
+export type TableFilter<TTable extends SchemaEntry = SchemaEntry, TColumns extends Record<string, unknown> = GetTableViewColumns<TTable>> = TableFilterColumns<TColumns> & TableFilterCommons<TTable, TColumns>;
+export type AnyRelationsFilter = RelationsFilter<TableRelationalConfig, TablesRelationalConfig, FieldSelection>;
+export type AnyTableFilter = TableFilter<SchemaEntry, FieldSelection>;
+export interface OneConfig<TSchema extends Schema, TSourceColumns extends Readonly<[RelationsBuilderColumnBase, ...RelationsBuilderColumnBase[]]> | Readonly<RelationsBuilderColumnBase>, TTargetTableName extends string, TOptional extends boolean> {
     from?: TSourceColumns;
     to?: TSourceColumns extends RelationsBuilderJunctionColumn | [RelationsBuilderJunctionColumn, ...RelationsBuilderJunctionColumn[]] ? RelationsBuilderJunctionColumn<TTargetTableName> | [
         RelationsBuilderJunctionColumn<TTargetTableName>,
@@ -337,8 +309,8 @@ export interface OneConfig<TSchema extends Record<string, Table | View>, TSource
     optional?: TOptional;
     alias?: string;
 }
-export type AnyOneConfig = OneConfig<Record<string, Table | View>, Readonly<[RelationsBuilderColumnBase, ...RelationsBuilderColumnBase[]] | RelationsBuilderColumnBase<string, unknown>>, string, boolean>;
-export interface ManyConfig<TSchema extends Record<string, Table | View>, TSourceColumns extends Readonly<[RelationsBuilderColumnBase, ...RelationsBuilderColumnBase[]]> | Readonly<RelationsBuilderColumnBase>, TTargetTableName extends string> {
+export type AnyOneConfig = OneConfig<Schema, Readonly<[RelationsBuilderColumnBase, ...RelationsBuilderColumnBase[]] | RelationsBuilderColumnBase>, string, boolean>;
+export interface ManyConfig<TSchema extends Schema, TSourceColumns extends Readonly<[RelationsBuilderColumnBase, ...RelationsBuilderColumnBase[]]> | Readonly<RelationsBuilderColumnBase>, TTargetTableName extends string> {
     from?: TSourceColumns;
     to?: TSourceColumns extends RelationsBuilderJunctionColumn | [RelationsBuilderJunctionColumn, ...RelationsBuilderJunctionColumn[]] ? RelationsBuilderJunctionColumn<TTargetTableName> | [
         RelationsBuilderJunctionColumn<TTargetTableName>,
@@ -349,48 +321,57 @@ export interface ManyConfig<TSchema extends Record<string, Table | View>, TSourc
     where?: TableFilter<TSchema[TTargetTableName]>;
     alias?: string;
 }
-export type AnyManyConfig = ManyConfig<Record<string, Table | View>, Readonly<[RelationsBuilderColumnBase, ...RelationsBuilderColumnBase[]]> | Readonly<RelationsBuilderColumnBase>, string>;
-export interface OneFn<TTables extends Record<string, Table | View>, TTargetTableName extends string> {
+export type AnyManyConfig = ManyConfig<Schema, Readonly<[RelationsBuilderColumnBase, ...RelationsBuilderColumnBase[]] | RelationsBuilderColumnBase>, string>;
+export interface OneFn<TTables extends Schema, TTargetTableName extends string> {
     <TSourceColumns extends Readonly<[RelationsBuilderColumnBase, ...RelationsBuilderColumnBase[]]> | RelationsBuilderColumnBase = any, TOptional extends boolean = true>(config?: OneConfig<TTables, TSourceColumns, TTargetTableName, TOptional>): One<TSourceColumns extends [RelationsBuilderColumnBase, ...RelationsBuilderColumnBase[]] ? TSourceColumns[number]['_']['tableName'] : Assume<TSourceColumns, RelationsBuilderColumnBase>['_']['tableName'], TTargetTableName, TOptional>;
 }
-export interface ManyFn<TTables extends Record<string, Table | View>, TTargetTableName extends string> {
+export interface ManyFn<TTables extends Schema, TTargetTableName extends string> {
     <TSourceColumns extends Readonly<[RelationsBuilderColumnBase, ...RelationsBuilderColumnBase[]]> | RelationsBuilderColumnBase = any>(config?: ManyConfig<TTables, TSourceColumns, TTargetTableName>): Many<TSourceColumns extends [RelationsBuilderColumnBase, ...RelationsBuilderColumnBase[]] ? TSourceColumns[number]['_']['tableName'] : Assume<TSourceColumns, RelationsBuilderColumnBase>['_']['tableName'], TTargetTableName>;
 }
-export declare class RelationsHelperStatic<TTables extends Record<string, Table | View>> {
+export declare class RelationsHelperStatic<TTables extends Schema> {
     static readonly [entityKind]: string;
-    readonly $brand: 'RelationsHelperStatic';
-    readonly _: {
-        readonly tables: TTables;
-    };
+    private readonly _;
     constructor(tables: TTables);
     one: {
-        [K in keyof TTables]: TTables[K] extends Table | View<string, boolean, FieldSelection> ? OneFn<TTables, K & string> : DrizzleTypeError<'Views with nested selections are not supported by the relational query builder'>;
+        [K in keyof TTables]: TTables[K] extends FilteredSchemaEntry ? OneFn<TTables, K & string> : DrizzleTypeError<'Views with nested selections are not supported by the relational query builder'>;
     };
     many: {
-        [K in keyof TTables]: TTables[K] extends Table | View<string, boolean, FieldSelection> ? ManyFn<TTables, K & string> : DrizzleTypeError<'Views with nested selections are not supported by the relational query builder'>;
+        [K in keyof TTables]: TTables[K] extends FilteredSchemaEntry ? ManyFn<TTables, K & string> : DrizzleTypeError<'Views with nested selections are not supported by the relational query builder'>;
     };
 }
-export type RelationsBuilder<TSchema extends Record<string, Table | View>> = {
-    [TTableName in keyof TSchema & string]: TSchema[TTableName] extends Table | View<string, boolean, FieldSelection> ? ({
-        [TColumnName in keyof (TSchema[TTableName] extends Table ? TSchema[TTableName]['_']['columns'] : Assume<TSchema[TTableName], View>['_']['selectedFields'])]: RelationsBuilderColumn<TTableName, (TSchema[TTableName] extends Table ? TSchema[TTableName]['_']['columns'] : Assume<Assume<TSchema[TTableName], View>['_']['selectedFields'], FieldSelection>)[TColumnName] extends infer Field ? Field extends Column ? Field['_']['data'] : Field extends SQLWrapper<infer Data> | SQL<infer Data> | SQL.Aliased<infer Data> ? Data : never : never>;
-    } & RelationsBuilderTable<TTableName>) : DrizzleTypeError<'Views with nested selections are not supported by the relational query builder'>;
-} & RelationsHelperStatic<TSchema>;
-export type RelationsBuilderConfig<TTables extends Record<string, Table | View>> = {
-    [TTableName in keyof TTables & string]?: Record<string, RelationsBuilderEntry<TTables, TTableName>>;
+export type RelationsBuilderColumns<TTable extends SchemaEntry, TTableName extends string> = {
+    [TColumnName in keyof GetTableViewColumns<TTable>]: RelationsBuilderColumn<TTableName>;
 };
-export type RelationsBuilderEntry<TTables extends Record<string, Table | View> = Record<string, Table | View>, TSourceTableName extends string = string> = Relation<TSourceTableName, keyof TTables & string>;
-export type ExtractTablesFromSchema<TSchema extends Record<string, unknown>> = {
-    [K in keyof TSchema as TSchema[K] extends Table | View ? K : never]: TSchema[K] extends Table | View ? TSchema[K] : never;
+export type RelationsBuilderTables<TSchema extends Schema> = {
+    [TTableName in keyof TSchema]: TSchema[TTableName] extends FilteredSchemaEntry ? (RelationsBuilderColumns<TSchema[TTableName], TTableName & string> & RelationsBuilderTable<TTableName & string>) : DrizzleTypeError<'Views with nested selections are not supported by the relational query builder'>;
 };
-export declare function createRelationsHelper<TSchema extends Record<string, unknown>, TTables extends Record<string, Table | View>>(schema: TSchema): RelationsBuilder<TTables>;
-export declare function defineRelations<TSchema extends Record<string, unknown>, TConfig extends RelationsBuilderConfig<TTables>, TTables extends Record<string, Table | View> = ExtractTablesFromSchema<TSchema>>(schema: TSchema, relations?: (helpers: RelationsBuilder<TTables>) => TConfig): Relations<TSchema, TTables, TConfig>;
-export interface WithContainer<TRelatedTables extends Record<string, Table> = Record<string, Table>> {
-    with?: {
-        [K in keyof TRelatedTables]?: boolean | AnyDBQueryConfig;
-    };
+export type RelationsBuilder<TSchema extends Schema> = Simplify<RelationsBuilderTables<TSchema> & RelationsHelperStatic<TSchema>>;
+export type RelationsBuilderConfigValue = RelationsRecord | undefined;
+export type RelationsBuilderConfig<TTables extends Schema> = {
+    [TTableName in keyof TTables]?: RelationsBuilderConfigValue;
+};
+export type AnyRelationsBuilderConfig = Record<string, RelationsBuilderConfigValue>;
+export type ExtractTablesFromSchema<TSchema extends Record<string, unknown>> = Simplify<Assume<{
+    [K in keyof TSchema as TSchema[K] extends SchemaEntry ? K extends string ? K : never : never]: TSchema[K];
+}, Schema>>;
+export declare function createRelationsHelper<TTables extends Schema>(tables: TTables): RelationsBuilder<TTables>;
+export declare function extractTablesFromSchema<TSchema extends Record<string, unknown>>(schema: TSchema): ExtractTablesFromSchema<TSchema>;
+export type IncludeEveryTable<TTables extends Schema> = {
+    [K in keyof TTables]: {};
+};
+/** Builds relational config for every table in schema */
+export declare function defineRelations<TSchema extends Record<string, unknown>, TTables extends Schema = ExtractTablesFromSchema<TSchema>>(schema: TSchema): ExtractTablesWithRelations<{}, TTables>;
+/** Builds relational config for every table in schema */
+export declare function defineRelations<TSchema extends Record<string, unknown>, TConfig extends RelationsBuilderConfig<TTables>, TTables extends Schema = ExtractTablesFromSchema<TSchema>>(schema: TSchema, relations: (helpers: RelationsBuilder<TTables>) => TConfig): ExtractTablesWithRelations<TConfig, TTables>;
+/** Builds relational config for every table in schema */
+export declare function defineRelationsPart<TSchema extends Record<string, unknown>, TTables extends Schema = ExtractTablesFromSchema<TSchema>>(schema: TSchema): ExtractTablesWithRelationsParts<IncludeEveryTable<TTables>, TTables>;
+/** Builds relational config only for tables present in relational config */
+export declare function defineRelationsPart<TSchema extends Record<string, unknown>, TConfig extends RelationsBuilderConfig<TTables>, TTables extends Schema = ExtractTablesFromSchema<TSchema>>(schema: TSchema, relations: (helpers: RelationsBuilder<TTables>) => TConfig): ExtractTablesWithRelationsParts<TConfig, TTables>;
+export interface WithContainer {
+    with?: Record<string, boolean | AnyDBQueryConfig | undefined>;
 }
 export interface ColumnWithTSName {
-    column: Column | SQL | SQLWrapper | SQL.Aliased;
+    column: Column<any> | SQL | SQLWrapper | SQL.Aliased;
     tsName: string;
 }
 export type RelationsOrder<TColumns extends FieldSelection> = {
@@ -398,14 +379,14 @@ export type RelationsOrder<TColumns extends FieldSelection> = {
 };
 export type OrderBy = Exclude<AnyDBQueryConfig['orderBy'], undefined>;
 export type Extras = Exclude<AnyDBQueryConfig['extras'], undefined>;
-export declare function relationsFilterToSQL(table: Table | View, filter: AnyRelationsFilter | AnyTableFilter): SQL | undefined;
-export declare function relationsFilterToSQL(table: Table | View, filter: AnyRelationsFilter | AnyTableFilter, tableRelations: Record<string, Relation>, tablesRelations: TablesRelationalConfig, tableNamesMap: Record<string, string>, casing: CasingCache, depth?: number): SQL | undefined;
-export declare function relationsOrderToSQL(table: Table | View, orders: OrderBy): SQL | undefined;
-export declare function relationExtrasToSQL(table: Table | View, extras: Extras): {
+export declare function relationsFilterToSQL(table: SchemaEntry, filter: AnyRelationsFilter | AnyTableFilter): SQL | undefined;
+export declare function relationsFilterToSQL(table: SchemaEntry, filter: AnyRelationsFilter | AnyTableFilter, tableRelations: RelationsRecord, tablesRelations: TablesRelationalConfig, casing: CasingCache, depth?: number): SQL | undefined;
+export declare function relationsOrderToSQL(table: SchemaEntry, orders: OrderBy): SQL | undefined;
+export declare function relationExtrasToSQL(table: SchemaEntry, extras: Extras): {
     sql: SQL<unknown> | undefined;
     selection: {
         key: string;
-        field: Column | Table | SQL | SQL.Aliased | SQLWrapper | AggregatedField;
+        field: Column<any> | Table | SQL | SQL.Aliased | SQLWrapper | AggregatedField;
         isArray?: boolean;
         selection?: BuildRelationalQueryResult["selection"];
         isOptional?: boolean;
@@ -415,6 +396,5 @@ export interface BuiltRelationFilters {
     filter?: SQL;
     joinCondition?: SQL;
 }
-export declare function relationToSQL(casing: CasingCache, relation: Relation, sourceTable: Table | View, targetTable: Table | View, throughTable?: Table | View): BuiltRelationFilters;
-export declare function getTableAsAliasSQL(table: Table | View): SQL<unknown>;
-export {};
+export declare function relationToSQL(casing: CasingCache, relation: Relation, sourceTable: SchemaEntry, targetTable: SchemaEntry, throughTable?: SchemaEntry): BuiltRelationFilters;
+export declare function getTableAsAliasSQL(table: SchemaEntry): SQL<unknown>;