orchid-orm 1.74.0 → 1.76.0

package/dist/index.d.ts

@@ -1,67 +1,82 @@
-import { Adapter, AfterCommitStandaloneHook, AfterHook, Column, ColumnSchemaConfig, ColumnsShape, ComputedColumnsFromOptions, ComputedOptionsConfig, ComputedOptionsFactory, CreateData, CreateManyMethodsNames, CreateMethodsNames, CreateSelf, DbSharedOptions, DbSqlMethod, DbTableOptionScopes, DefaultColumnTypes, DefaultSchemaConfig, DeleteMethodsNames, EmptyObject, FromArg, FromResult, Grant, IsQuery, IsolationLevel, JoinQueryMethod, MapTableScopesOption, MaybeArray, MergeQuery, PickQuerySelectableRelations, QueryAfterHook, QueryBeforeActionHook, QueryBeforeHook, QueryData, QueryHasWhere, QueryReturnType, QuerySchema, QueryScopes, RawSqlBase, RecordUnknown, RelationConfigBase, Rls, SelectableFromShape, ShallowSimplify, ShapeColumnPrimaryKeys, ShapeUniqueColumns, StorageOptions, TableData, TableDataFn, TableDataItem, TableDataItemsUniqueColumnTuples, TableDataItemsUniqueColumns, TableDataItemsUniqueConstraints, TransactionOptions, UniqueConstraints, UpdateData, WhereArg } from "pqb/internal";
+import { Adapter, AfterCommitStandaloneHook, AfterHook, Column, ColumnSchemaConfig, ColumnsShape, ComputedOptionsConfig, ComputedOptionsFactory, CreateData, CreateManyMethodsNames, CreateMethodsNames, CreateSelf, DbSharedOptions, DbSqlMethod, DbTableOptionScopes, DefaultColumnTypes, DefaultSchemaConfig, DeleteMethodsNames, EmptyObject, FromArg, FromResult, Grant, IsQuery, IsolationLevel, MaybeArray, MergeQuery, PickQuerySelectableRelations, QueryAfterHook, QueryBeforeActionHook, QueryBeforeHook, QueryData, QueryHasWhere, QueryReturnType, QuerySchema, QueryScopes, RawSqlBase, RecordUnknown, RelationConfigBase, Rls, SelectableFromShape, ShallowSimplify, StorageOptions, TableData, TableDataFn, TableDataItem, TransactionOptions, UpdateData, WhereArg } from "pqb/internal";
 import { Db, Query } from "pqb";
 export * from "pqb";
-interface RelationRefsOptions<Column extends PropertyKey = string, Shape extends Column.Shape.QueryInit = Column.Shape.QueryInit> {
+interface BelongsTo extends RelationThunkBase {
+  type: 'belongsTo';
+  options: BelongsToOptions;
+}
+interface BelongsToOptions<Columns extends Column.Shape.QueryInit = Column.Shape.QueryInit, Related extends ORMTableInput = ORMTableInput> {
   required?: boolean;
-  columns: Column[];
-  references: (keyof Shape)[];
+  columns: (keyof Columns)[];
+  references: (keyof Related['columns']['shape'])[];
   foreignKey?: boolean | TableData.References.Options;
-  on?: ColumnsShape.InputPartial<Shape>;
-}
-interface RelationThroughOptions<Through extends PropertyKey = string, Source extends PropertyKey = string> {
-  through: Through;
-  source: Source;
-}
-interface HasOne extends RelationThunkBase {
-  type: 'hasOne';
-  options: HasOneOptions;
+  on?: ColumnsShape.InputPartial<Related['columns']['shape']>;
 }
-interface RelationHasOneThroughOptions<Through extends string, Source extends string> extends RelationThroughOptions<Through, Source> {
-  required?: boolean;
+type BelongsToParams<T extends RelationConfigSelf, FK extends string> = { [Name in FK]: T['columns']['shape'][Name]['__type'] };
+type BelongsToDefaultRequired<T extends RelationConfigSelf, Rel extends BelongsTo, Related> = Related extends {
+  softDelete: true;
+} ? false : BelongsToDefaultRequiredFromColumns<T, Rel>;
+type BelongsToDefaultRequiredFromColumns<T extends RelationConfigSelf, Rel extends BelongsTo> = BelongsToColumnRequired<T['columns']['shape'][Rel['options']['columns'][number] & string]> extends true ? true : false;
+type BelongsToColumnRequired<Column> = Column extends {
+  data: {
+    isNullable: true;
+  };
+} ? false : true;
+type BelongsToQuery<T extends Query, Name extends string> = { [P in keyof T]: P extends '__selectable' ? SelectableFromShape<T['shape'], Name> : P extends '__as' ? Name : P extends CreateMethodsNames | DeleteMethodsNames ? never : T[P] } & QueryHasWhere;
+interface BelongsToDataForCreate<Name extends string, FK extends string, Required, Q extends Query> {
+  columns: FK;
+  nested: Q extends Query.Pick.IsNotReadOnly ? Required extends true ? { [Key in Name]: RelationToOneDataForCreateSameQuery<Q> } : { [Key in Name]?: RelationToOneDataForCreateSameQuery<Q> } : { [Key in Name]?: never };
 }
-type HasOneOptions<Columns extends Column.Shape.QueryInit = Column.Shape.QueryInit, Related extends ORMTableInput = ORMTableInput, Through extends string = string, Source extends string = string> = RelationRefsOptions<keyof Columns, Related['columns']['shape']> | RelationHasOneThroughOptions<Through, Source>;
-type HasOneParams<T extends RelationConfigSelf, Options> = Options extends RelationRefsOptions ? { [Name in Options['columns'][number]]: T['columns']['shape'][Name]['__type'] } : Options extends RelationThroughOptions ? RelationConfigParams<T, T['relations'][Options['through']]> : never;
-type HasOneQueryThrough<Name extends string, TableQuery extends Query> = { [K in keyof TableQuery]: K extends '__selectable' ? SelectableFromShape<TableQuery['shape'], Name> : K extends '__as' ? Name : K extends CreateMethodsNames ? never : TableQuery[K] } & QueryHasWhere & HasRelJoin;
-type HasOneQuery<T extends RelationConfigSelf, Name extends string, TableQuery extends Query> = T['relations'][Name]['options'] extends RelationRefsOptions ? { [K in keyof TableQuery]: K extends '__defaults' ? { [K in keyof TableQuery['__defaults'] | T['relations'][Name]['options']['references'][number]]: true } : K extends '__selectable' ? SelectableFromShape<TableQuery['shape'], Name> : K extends '__as' ? Name : K extends CreateManyMethodsNames ? never : TableQuery[K] } & QueryHasWhere & HasRelJoin : HasOneQueryThrough<Name, TableQuery>;
-interface HasOneInfo<T extends RelationConfigSelf, Name extends string, Rel extends HasOne, Q extends Query> extends RelationConfigBase {
+interface BelongsToInfo<T extends RelationConfigSelf, FK extends string, Required, Q extends Query> extends RelationConfigBase {
   returnsOne: true;
-  required: T['relations'][Name]['options']['required'];
+  required: Required;
   query: Q;
-  params: HasOneParams<T, Rel['options']>;
-  omitForeignKeyInCreate: never;
-  dataForCreate: { [K in Name]?: Q extends Query.Pick.IsNotReadOnly ? T['relations'][Name]['options'] extends RelationThroughOptions ? EmptyObject : RelationToOneDataForCreate<{
-    nestedCreateQuery: CreateData<Q>;
-    table: Q;
-  }> : never };
-  dataForUpdate: Q extends Query.Pick.IsNotReadOnly ? {
+  params: BelongsToParams<T, FK>;
+  omitForeignKeyInCreate: FK;
+  dataForUpdate: {
     disconnect: boolean;
   } | {
+    set: WhereArg<Q>;
+  } | (Q extends Query.Pick.IsNotReadOnly ? {
     delete: boolean;
   } | {
     update: UpdateData<Q>;
-  } : never;
-  dataForUpdateOne: Q extends Query.Pick.IsNotReadOnly ? {
+  } | {
+    create: CreateData<Q>;
+  } : never);
+  dataForUpdateOne: {
     disconnect: boolean;
   } | {
     set: WhereArg<Q>;
-  } | {
+  } | (Q extends Query.Pick.IsNotReadOnly ? {
     delete: boolean;
   } | {
     update: UpdateData<Q>;
+  } | {
+    create: CreateData<Q>;
   } | {
     upsert: {
       update: UpdateData<Q>;
       create: CreateData<Q> | (() => CreateData<Q>);
     };
-  } | {
-    create: CreateData<Q>;
-  } : never;
+  } : never);
+}
+interface RelationRefsOptions<Column extends PropertyKey = string, Shape extends Column.Shape.QueryInit = Column.Shape.QueryInit> {
+  required?: boolean;
+  columns: Column[];
+  references: (keyof Shape)[];
+  foreignKey?: boolean | TableData.References.Options;
+  on?: ColumnsShape.InputPartial<Shape>;
+}
+interface RelationThroughOptions<Through extends PropertyKey = string, Source extends PropertyKey = string> {
+  through: Through;
+  source: Source;
 }
 interface HasMany extends RelationThunkBase {
   type: 'hasMany';
   options: HasOneOptions;
 }
-type HasManyQuery<T extends RelationConfigSelf, Name extends string, TableQuery extends Query> = T['relations'][Name]['options'] extends RelationRefsOptions ? { [K in keyof TableQuery]: K extends '__defaults' ? { [K in keyof TableQuery['__defaults'] | T['relations'][Name]['options']['references'][number]]: true } : K extends '__selectable' ? SelectableFromShape<TableQuery['shape'], Name> : K extends '__as' ? Name : TableQuery[K] } & QueryHasWhere & HasRelJoin : HasOneQueryThrough<Name, TableQuery>;
+type HasManyQuery<T extends RelationConfigSelf, Name extends string, TableQuery extends Query> = T['relations'][Name]['options'] extends RelationRefsOptions ? { [K in keyof TableQuery]: K extends '__defaults' ? { [K in keyof TableQuery['__defaults'] | T['relations'][Name]['options']['references'][number]]: true } : K extends '__selectable' ? SelectableFromShape<TableQuery['shape'], Name> : K extends '__as' ? Name : TableQuery[K] } & QueryHasWhere : HasOneQueryThrough<Name, TableQuery>;
 interface HasManyInfo<T extends RelationConfigSelf, Name extends string, Rel extends HasMany, Q extends Query> extends RelationConfigBase {
   returnsOne: false;
   query: Q;
@@ -100,63 +115,50 @@ interface HasManyInfo<T extends RelationConfigSelf, Name extends string, Rel ext
     };
   } : never;
 }
-interface RelJoin extends JoinQueryMethod {
-  <T extends Query>(this: T): T;
-}
-interface HasRelJoin {
-  join: RelJoin;
-}
-interface BelongsTo extends RelationThunkBase {
-  type: 'belongsTo';
-  options: BelongsToOptions;
+interface HasOne extends RelationThunkBase {
+  type: 'hasOne';
+  options: HasOneOptions;
 }
-interface BelongsToOptions<Columns extends Column.Shape.QueryInit = Column.Shape.QueryInit, Related extends ORMTableInput = ORMTableInput> {
+interface RelationHasOneThroughOptions<Through extends string, Source extends string> extends RelationThroughOptions<Through, Source> {
   required?: boolean;
-  columns: (keyof Columns)[];
-  references: (keyof Related['columns']['shape'])[];
-  foreignKey?: boolean | TableData.References.Options;
-  on?: ColumnsShape.InputPartial<Related['columns']['shape']>;
-}
-type BelongsToParams<T extends RelationConfigSelf, FK extends string> = { [Name in FK]: T['columns']['shape'][Name]['__type'] };
-type BelongsToColumnsRequired<T extends RelationConfigSelf, FK extends string> = { [K in FK]: T['columns']['shape'][K]['data']['isNullable'] extends true ? false : true }[FK] extends true ? true : false;
-type BelongsToQuery<T extends Query, Name extends string> = { [P in keyof T]: P extends '__selectable' ? SelectableFromShape<T['shape'], Name> : P extends '__as' ? Name : P extends CreateMethodsNames | DeleteMethodsNames ? never : T[P] } & QueryHasWhere & HasRelJoin;
-interface BelongsToDataForCreate<Name extends string, FK extends string, Required, Q extends Query> {
-  columns: FK;
-  nested: Q extends Query.Pick.IsNotReadOnly ? Required extends true ? { [Key in Name]: RelationToOneDataForCreateSameQuery<Q> } : { [Key in Name]?: RelationToOneDataForCreateSameQuery<Q> } : { [Key in Name]?: never };
 }
-interface BelongsToInfo<T extends RelationConfigSelf, FK extends string, Required, Q extends Query> extends RelationConfigBase {
+type HasOneOptions<Columns extends Column.Shape.QueryInit = Column.Shape.QueryInit, Related extends ORMTableInput = ORMTableInput, Through extends string = string, Source extends string = string> = RelationRefsOptions<keyof Columns, Related['columns']['shape']> | RelationHasOneThroughOptions<Through, Source>;
+type HasOneParams<T extends RelationConfigSelf, Options> = Options extends RelationRefsOptions ? { [Name in Options['columns'][number]]: T['columns']['shape'][Name]['__type'] } : Options extends RelationThroughOptions ? RelationConfigParams<T, T['relations'][Options['through']]> : never;
+type HasOneQueryThrough<Name extends string, TableQuery extends Query> = { [K in keyof TableQuery]: K extends '__selectable' ? SelectableFromShape<TableQuery['shape'], Name> : K extends '__as' ? Name : K extends CreateMethodsNames ? never : TableQuery[K] } & QueryHasWhere;
+type HasOneQuery<T extends RelationConfigSelf, Name extends string, TableQuery extends Query> = T['relations'][Name]['options'] extends RelationRefsOptions ? { [K in keyof TableQuery]: K extends '__defaults' ? { [K in keyof TableQuery['__defaults'] | T['relations'][Name]['options']['references'][number]]: true } : K extends '__selectable' ? SelectableFromShape<TableQuery['shape'], Name> : K extends '__as' ? Name : K extends CreateManyMethodsNames ? never : TableQuery[K] } & QueryHasWhere : HasOneQueryThrough<Name, TableQuery>;
+interface HasOneInfo<T extends RelationConfigSelf, Name extends string, Rel extends HasOne, Q extends Query> extends RelationConfigBase {
   returnsOne: true;
-  required: Required;
+  required: T['relations'][Name]['options']['required'];
   query: Q;
-  params: BelongsToParams<T, FK>;
-  omitForeignKeyInCreate: FK;
-  dataForUpdate: {
+  params: HasOneParams<T, Rel['options']>;
+  omitForeignKeyInCreate: never;
+  dataForCreate: { [K in Name]?: Q extends Query.Pick.IsNotReadOnly ? T['relations'][Name]['options'] extends RelationThroughOptions ? EmptyObject : RelationToOneDataForCreate<{
+    nestedCreateQuery: CreateData<Q>;
+    table: Q;
+  }> : never };
+  dataForUpdate: Q extends Query.Pick.IsNotReadOnly ? {
     disconnect: boolean;
   } | {
-    set: WhereArg<Q>;
-  } | (Q extends Query.Pick.IsNotReadOnly ? {
     delete: boolean;
   } | {
     update: UpdateData<Q>;
-  } | {
-    create: CreateData<Q>;
-  } : never);
-  dataForUpdateOne: {
+  } : never;
+  dataForUpdateOne: Q extends Query.Pick.IsNotReadOnly ? {
     disconnect: boolean;
   } | {
     set: WhereArg<Q>;
-  } | (Q extends Query.Pick.IsNotReadOnly ? {
+  } | {
     delete: boolean;
   } | {
     update: UpdateData<Q>;
-  } | {
-    create: CreateData<Q>;
   } | {
     upsert: {
       update: UpdateData<Q>;
       create: CreateData<Q> | (() => CreateData<Q>);
     };
-  } : never);
+  } | {
+    create: CreateData<Q>;
+  } : never;
 }
 interface HasAndBelongsToMany extends RelationThunkBase {
   type: 'hasAndBelongsToMany';
@@ -177,7 +179,7 @@ interface HasAndBelongsToManyOptions<Columns extends Column.Shape.QueryInit = Co
   on?: ColumnsShape.InputPartial<Related['columns']['shape']>;
 }
 type HasAndBelongsToManyParams<T extends RelationConfigSelf, FK extends string> = { [Name in FK]: T['columns']['shape'][Name]['__type'] };
-type HasAndBelongsToManyQuery<Name extends string, TableQuery extends Query> = { [K in keyof TableQuery]: K extends '__selectable' ? SelectableFromShape<TableQuery['shape'], Name> : K extends '__as' ? Name : TableQuery[K] } & QueryHasWhere & HasRelJoin;
+type HasAndBelongsToManyQuery<Name extends string, TableQuery extends Query> = { [K in keyof TableQuery]: K extends '__selectable' ? SelectableFromShape<TableQuery['shape'], Name> : K extends '__as' ? Name : TableQuery[K] } & QueryHasWhere;
 interface HasAndBelongsToManyInfo<T extends RelationConfigSelf, Name extends string, FK extends string, Q extends Query> extends RelationConfigBase {
   returnsOne: false;
   query: Q;
@@ -267,16 +269,27 @@ type RelationToOneDataForCreateSameQuery<Q extends RelationToOneDataForCreateSam
 };
 interface RelationThunkBase {
   type: string;
-  related: ORMTableInput;
+  id: string;
   options: unknown;
 }
 type RelationThunk = BelongsTo | HasOne | HasMany | HasAndBelongsToMany;
 interface RelationThunks {
   [K: string]: RelationThunk;
 }
-type RelationTableToQuery<Relation> = Relation extends {
-  related: infer R extends ORMTableInput;
-} ? TableToDb<R, R['table'] extends string ? R['table'] : R['name'], R['table'] extends string ? R['readOnly'] extends true ? true : undefined : R['readOnly'] extends false ? undefined : true> : never;
+type TableClassInstances<T extends TableClasses> = InstanceType<T[keyof T]>;
+type RelationToTableInputById<Tables, Id extends string> = Extract<Tables, {
+  id: Id;
+}>;
+type RelationToTableInputByKey<T extends TableClasses, Id extends string> = Id extends keyof T ? InstanceType<T[Id]> : never;
+type RelationToTableInputByName<Tables, Id extends string> = Extract<Tables, {
+  table: Id;
+} | {
+  name: Id;
+}>;
+type RelationToTableInputByKeyOrName<T extends TableClasses, Id extends string> = Id extends keyof T ? RelationToTableInputByKey<T, Id> : RelationToTableInputByName<TableClassInstances<T>, Id>;
+type RelationToTableInputFromClasses<T extends TableClasses, Id extends string> = RelationToTableInputById<TableClassInstances<T>, Id> extends infer Result ? [Result] extends [never] ? RelationToTableInputByKeyOrName<T, Id> : Result : never;
+type RelationToTableInput<TC extends TableClasses, VC extends TableClasses, Rel extends RelationThunkBase> = RelationToTableInputFromClasses<TC, Rel['id']> extends infer Result ? [Result] extends [never] ? RelationToTableInputFromClasses<VC, Rel['id']> extends infer Result ? [Result] extends [never] ? false : Result : never : Result : never;
+type RelationTableToQuery<TC extends TableClasses, VC extends TableClasses, Rel extends RelationThunkBase> = RelationToTableInput<TC, VC, Rel> extends infer Result extends ORMTableInput ? TableQueryBuilder<TC, VC, Result> : never;
 interface RelationConfigSelf {
   columns: {
     shape: Column.Shape.QueryInit;
@@ -321,23 +334,17 @@ interface OrchidORMTableHelper<T extends Query> {
    */
   makeHelper<Args extends unknown[], Result>(fn: (q: T, ...args: Args) => Result): OrchidORMQueryHelper<T, Args, Result>;
 }
-type OrchidORMTables<T extends TableClasses = TableClasses> = { [K in keyof T]: T[K] extends {
-  new (): infer R extends ORMTableInput;
-} ? OrchidORMTableHelper<TableToDb<R, R['table'], R['readOnly'] extends true ? true : undefined>> : never };
-type OrchidORMViews<T extends TableClasses = TableClasses> = { [K in keyof T]: T[K] extends {
+type OrchidORMTables<TC extends TableClasses = TableClasses, VC extends TableClasses = TableClasses> = { [K in keyof TC]: TC[K] extends {
   new (): infer R extends ORMTableInput;
-} ? OrchidORMTableHelper<TableToDb<R, R['name'], R['readOnly'] extends false ? undefined : true, R['materialized'] extends true ? true : undefined>> : never };
-type OrchidORMBundle<T extends TableClasses = TableClasses, V extends TableClasses = TableClasses> = OrchidORMTables<T> & {
-  $views: OrchidORMViews<V>;
+} ? OrchidORMTableHelper<TableQueryBuilder<TC, VC, R>> : never };
+type OrchidORMBundle<TC extends TableClasses = TableClasses, VC extends TableClasses = TableClasses> = OrchidORMTables<TC> & {
+  $views: OrchidORMTables<VC, TC>;
 };
-type OrchidORMDbTables<T extends TableClasses = TableClasses> = { [K in keyof T]: T[K] extends {
+type OrchidORMDbTables<TC extends TableClasses = TableClasses, VC extends TableClasses = TableClasses> = { [K in keyof TC]: TC[K] extends {
   new (): infer R extends ORMTableInput;
-} ? TableToDb<R, R['table'], R['readOnly'] extends true ? true : undefined> : never };
-type OrchidORMDbViews<T extends TableClasses = TableClasses> = { [K in keyof T]: T[K] extends {
-  new (): infer R extends ORMTableInput;
-} ? TableToDb<R, R['name'], R['readOnly'] extends false ? undefined : true, R['materialized'] extends true ? true : undefined> : never };
-type OrchidORM<T extends TableClasses = TableClasses, V extends TableClasses = TableClasses> = OrchidORMDbTables<T> & {
-  $views: OrchidORMDbViews<V>;
+} ? TableQueryBuilder<TC, VC, R> : never };
+type OrchidORM<TC extends TableClasses = TableClasses, VC extends TableClasses = TableClasses> = OrchidORMDbTables<TC, VC> & {
+  $views: OrchidORMDbTables<VC, TC>;
 } & OrchidORMMethods;
 /**
  * Identity helper for table row-level security configuration.
@@ -531,23 +538,23 @@ interface TableInfo {
   name: string;
 }
 interface Table extends Query, TableInfo {}
-type BelongsToRequired<T extends RelationConfigSelf, Rel extends BelongsTo> = Rel['options'] extends {
+type BelongsToRequired<T extends RelationConfigSelf, Rel extends BelongsTo, Related> = Rel['options'] extends {
   required: infer Required extends boolean;
 } ? Required : Rel['options'] extends {
   on: unknown;
-} ? false : BelongsToColumnsRequired<T, Rel['options']['columns'][number] & string>;
-type BelongsToRelationInfo<T extends RelationConfigSelf, Name extends string, Rel extends BelongsTo> = BelongsToInfo<T, Rel['options']['columns'][number] & string, BelongsToRequired<T, Rel>, BelongsToQuery<RelationTableToQuery<Rel>, Name>>;
-type BelongsToCreateData<T extends RelationConfigSelf, Name extends string, Rel extends BelongsTo> = BelongsToDataForCreate<Name, Rel['options']['columns'][number] & string, BelongsToRequired<T, Rel>, BelongsToQuery<RelationTableToQuery<Rel>, Name>>;
+} ? false : BelongsToDefaultRequired<T, Rel, Related>;
+type BelongsToRelationInfo<TC extends TableClasses, VC extends TableClasses, T extends RelationConfigSelf, Name extends string, Rel extends BelongsTo> = RelationToTableInput<TC, VC, Rel> extends infer Related extends ORMTableInput ? BelongsToInfo<T, Rel['options']['columns'][number] & string, BelongsToRequired<T, Rel, Related>, BelongsToQuery<TableQueryBuilder<TC, VC, Related>, Name>> : never;
+type BelongsToCreateData<TC extends TableClasses, VC extends TableClasses, T extends RelationConfigSelf, Name extends string, Rel extends BelongsTo> = RelationToTableInput<TC, VC, Rel> extends infer Related extends ORMTableInput ? BelongsToDataForCreate<Name, Rel['options']['columns'][number] & string, BelongsToRequired<T, Rel, Related>, BelongsToQuery<TableQueryBuilder<TC, VC, Related>, Name>> : never;
 type BelongsToCreateDataColumns<T extends RelationConfigSelf> = { [K in keyof T['relations']]: T['relations'][K] extends BelongsTo ? T['relations'][K]['options']['columns'][number] & string : never }[keyof T['relations']];
-type BelongsToCreateDataForColumn<T extends RelationConfigSelf, Column extends string> = { [K in keyof T['relations']]: T['relations'][K] extends BelongsTo ? Column extends T['relations'][K]['options']['columns'][number] ? BelongsToCreateData<T, K & string, T['relations'][K]> : never : never }[keyof T['relations']];
-type RelationDataForCreate<T extends RelationConfigSelf, Name extends keyof T['relations'] & string> = T['relations'][Name] extends HasOne ? HasOneInfo<T, Name, T['relations'][Name], HasOneQuery<T, Name, RelationTableToQuery<T['relations'][Name]>>>['dataForCreate'] : T['relations'][Name] extends HasMany ? HasManyInfo<T, Name, T['relations'][Name], HasManyQuery<T, Name, RelationTableToQuery<T['relations'][Name]>>>['dataForCreate'] : T['relations'][Name] extends HasAndBelongsToMany ? HasAndBelongsToManyInfo<T, Name, T['relations'][Name]['options']['columns'][number] & string, HasAndBelongsToManyQuery<Name, RelationTableToQuery<T['relations'][Name]>>>['dataForCreate'] : never;
+type BelongsToCreateDataForColumn<TC extends TableClasses, VC extends TableClasses, T extends RelationConfigSelf, Column extends string> = { [K in keyof T['relations']]: T['relations'][K] extends BelongsTo ? Column extends T['relations'][K]['options']['columns'][number] ? BelongsToCreateData<TC, VC, T, K & string, T['relations'][K]> : never : never }[keyof T['relations']];
+type RelationDataForCreate<TC extends TableClasses, VC extends TableClasses, T extends RelationConfigSelf, Name extends keyof T['relations'] & string> = T['relations'][Name] extends HasOne ? HasOneInfo<T, Name, T['relations'][Name], HasOneQuery<T, Name, RelationTableToQuery<TC, VC, T['relations'][Name]>>>['dataForCreate'] : T['relations'][Name] extends HasMany ? HasManyInfo<T, Name, T['relations'][Name], HasManyQuery<T, Name, RelationTableToQuery<TC, VC, T['relations'][Name]>>>['dataForCreate'] : T['relations'][Name] extends HasAndBelongsToMany ? HasAndBelongsToManyInfo<T, Name, T['relations'][Name]['options']['columns'][number] & string, HasAndBelongsToManyQuery<Name, RelationTableToQuery<TC, VC, T['relations'][Name]>>>['dataForCreate'] : never;
 type RelationDataForCreateOptionalNames<T extends RelationConfigSelf> = { [K in keyof T['relations'] & string]: T['relations'][K] extends BelongsTo ? never : K }[keyof T['relations'] & string];
-type BelongsToRelationsDataForCreate<T extends RelationConfigSelf> = { [Column in BelongsToCreateDataColumns<T>]: BelongsToCreateDataForColumn<T, Column> };
-type RelationsDataForCreateOptional<T extends RelationConfigSelf> = RelationDataForCreateOptionalNames<T> extends never ? EmptyObject : { [K in RelationDataForCreateOptionalNames<T>]: (u: RelationDataForCreate<T, K>) => void }[RelationDataForCreateOptionalNames<T>] extends ((u: infer Obj) => void) ? Obj : EmptyObject;
-interface TableToDb<T extends ORMTableInput, Name extends string | undefined, ReadOnly extends true | undefined, Materialized extends true | undefined = undefined> extends TableInfo, Db<Name, T['columns']['shape'], keyof ShapeColumnPrimaryKeys<T['columns']['shape']> extends never ? never : ShapeColumnPrimaryKeys<T['columns']['shape']>, ShapeUniqueColumns<T['columns']['shape']> | TableDataItemsUniqueColumns<T['columns']['shape'], T['columns']['data']>, TableDataItemsUniqueColumnTuples<T['columns']['shape'], T['columns']['data']>, UniqueConstraints<T['columns']['shape']> | TableDataItemsUniqueConstraints<T['columns']['data']>, T['types'], T['columns']['shape'] & ComputedColumnsFromOptions<T['computed']>, MapTableScopesOption<T>, ColumnsShape.DefaultSelectKeys<T['columns']['shape']>, ReadOnly, Materialized> {
-  relations: T extends RelationConfigSelf ? { [K in keyof T['relations'] & string]: T['relations'][K] extends BelongsTo ? BelongsToRelationInfo<T, K, T['relations'][K]> : T['relations'][K] extends HasOne ? HasOneInfo<T, K, T['relations'][K], HasOneQuery<T, K, RelationTableToQuery<T['relations'][K]>>> : T['relations'][K] extends HasMany ? HasManyInfo<T, K, T['relations'][K], HasManyQuery<T, K, RelationTableToQuery<T['relations'][K]>>> : T['relations'][K] extends HasAndBelongsToMany ? HasAndBelongsToManyInfo<T, K, T['relations'][K]['options']['columns'][number] & string, HasAndBelongsToManyQuery<K, RelationTableToQuery<T['relations'][K]>>> : never } : EmptyObject;
-  relationsDataForCreate: T extends RelationConfigSelf ? BelongsToRelationsDataForCreate<T> : EmptyObject;
-  relationsDataForCreateOptional: T extends RelationConfigSelf ? RelationsDataForCreateOptional<T> : EmptyObject;
+type BelongsToRelationsDataForCreate<TC extends TableClasses, VC extends TableClasses, T extends RelationConfigSelf> = { [Column in BelongsToCreateDataColumns<T>]: BelongsToCreateDataForColumn<TC, VC, T, Column> };
+type RelationsDataForCreateOptional<TC extends TableClasses, VC extends TableClasses, T extends RelationConfigSelf> = RelationDataForCreateOptionalNames<T> extends never ? EmptyObject : { [K in RelationDataForCreateOptionalNames<T>]: (u: RelationDataForCreate<TC, VC, T, K>) => void }[RelationDataForCreateOptionalNames<T>] extends ((u: infer Obj) => void) ? Obj : EmptyObject;
+interface TableQueryBuilder<TC extends TableClasses, VC extends TableClasses, T extends ORMTableInput> extends TableInfo, Db<T['table'] extends string ? T['table'] : T['name'], T['columns']['shape'], T['columns']['data'], T['types'], T['table'] extends string ? T['readOnly'] extends true ? true : undefined : T['readOnly'] extends false ? undefined : true, T> {
+  relations: T extends RelationConfigSelf ? { [K in keyof T['relations'] & string]: T['relations'][K] extends BelongsTo ? BelongsToRelationInfo<TC, VC, T, K, T['relations'][K]> : T['relations'][K] extends HasOne ? HasOneInfo<T, K, T['relations'][K], HasOneQuery<T, K, RelationTableToQuery<TC, VC, T['relations'][K]>>> : T['relations'][K] extends HasMany ? HasManyInfo<T, K, T['relations'][K], HasManyQuery<T, K, RelationTableToQuery<TC, VC, T['relations'][K]>>> : T['relations'][K] extends HasAndBelongsToMany ? HasAndBelongsToManyInfo<T, K, T['relations'][K]['options']['columns'][number] & string, HasAndBelongsToManyQuery<K, RelationTableToQuery<TC, VC, T['relations'][K]>>> : never } : EmptyObject;
+  relationsDataForCreate: T extends RelationConfigSelf ? BelongsToRelationsDataForCreate<TC, VC, T> : EmptyObject;
+  relationsDataForCreateOptional: T extends RelationConfigSelf ? RelationsDataForCreateOptional<TC, VC, T> : EmptyObject;
 }
 interface PickORMTableInputColumns {
   columns: {
@@ -563,8 +570,10 @@ interface PickORMTableComputed {
 }
 interface PickORMTableInputColumnsAndComputed extends PickORMTableInputColumns, PickORMTableComputed {}
 interface ORMTableInput extends PickORMTableInputColumnsAndComputed {
+  id?: string;
   autoForeignKeys?: TableData.References.BaseOptions | boolean;
   schema?: QuerySchema;
+  nameInDb?: string;
   types: unknown;
   filePath: string;
   language?: string;
@@ -621,6 +630,10 @@ interface SetColumnsResult<Shape extends Column.Shape.QueryInit, Data extends Ma
 }
 interface BaseTableInstance<ColumnTypes> {
   table?: string;
+  /**
+   * Database relation name used in SQL and migration generation.
+   */
+  nameInDb?: string;
   columns: {
     shape: Column.Shape.QueryInit;
     data: MaybeArray<TableDataItem>;
@@ -632,6 +645,7 @@ interface BaseTableInstance<ColumnTypes> {
   q: QueryData;
   language?: string;
   filePath: string;
+  materialized?: true;
   /**
    * Keep this table-like definition available at runtime, but exclude it from
    * generated migration DDL reconciliation.
@@ -756,7 +770,7 @@ interface BaseTableInstance<ColumnTypes> {
     new (): Related;
   }, options: Options): {
     type: 'belongsTo';
-    related: Related;
+    id: Related['id'] extends string ? Related['id'] : Related['table'] extends string ? Related['table'] : Related['name'];
     options: Options;
   };
   hasOne<Columns extends Column.Shape.QueryInit, Related extends ORMTableInput, Through extends string, Source extends string, Options extends HasOneOptions<Columns, Related, Through, Source>>(this: {
@@ -767,7 +781,7 @@ interface BaseTableInstance<ColumnTypes> {
     new (): Related;
   }, options: Options): {
     type: 'hasOne';
-    related: Related;
+    id: Related['id'] extends string ? Related['id'] : Related['table'] extends string ? Related['table'] : Related['name'];
     options: Options;
   };
   hasMany<Columns extends Column.Shape.QueryInit, Related extends ORMTableInput, Through extends string, Source extends string, Options extends HasOneOptions<Columns, Related, Through, Source>>(this: {
@@ -778,7 +792,7 @@ interface BaseTableInstance<ColumnTypes> {
     new (): Related;
   }, options: Options): {
     type: 'hasMany';
-    related: Related;
+    id: Related['id'] extends string ? Related['id'] : Related['table'] extends string ? Related['table'] : Related['name'];
     options: Options;
   };
   hasAndBelongsToMany<Columns extends Column.Shape.QueryInit, Related extends ORMTableInput, Options extends HasAndBelongsToManyOptions<Columns, Related>>(this: {
@@ -789,7 +803,7 @@ interface BaseTableInstance<ColumnTypes> {
     new (): Related;
   }, options: Options): {
     type: 'hasAndBelongsToMany';
-    related: Related;
+    id: Related['id'] extends string ? Related['id'] : Related['table'] extends string ? Related['table'] : Related['name'];
     options: Options;
   };
   beforeQuery: BeforeHookMethod;
@@ -897,4 +911,4 @@ declare const createRepo: <T extends Query, Methods extends MethodsBase<T>>(tabl
   table: T["table"];
   shape: T["shape"];
 }>(q: Q) => Query & Q & MapMethods<T, Methods>) & T, Methods>;
-export { BaseMaterializedViewInstance, BaseTableClass, BaseTableInstance, BaseViewInstance, DefaultSelect, FromQuery, Insertable, MapMethods, MapQueryMethods, MethodsBase, ORMTableInput, OrchidORM, OrchidORMBundle, OrchidORMDbTables, OrchidORMDbViews, OrchidORMTableHelper, OrchidORMTables, OrchidORMViews, OrchidOrmParam, PickORMTableComputed, PickORMTableInputColumns, PickORMTableInputColumnsAndComputed, Queryable, Repo, Selectable, SetColumnsResult, Table, TableClass, TableClasses, TableInfo, TableToDb, Updatable, bundleOrchidORM, bundleOrchidORMTables, createBaseTable, createRepo, defineRls, makeOrchidOrmDbWithAdapter, orchidORMWithAdapter, setGrants };
+export { BaseMaterializedViewInstance, BaseTableClass, BaseTableInstance, BaseViewInstance, DefaultSelect, FromQuery, Insertable, MapMethods, MapQueryMethods, MethodsBase, ORMTableInput, OrchidORM, OrchidORMBundle, OrchidORMDbTables, OrchidORMTables, OrchidOrmParam, PickORMTableComputed, PickORMTableInputColumns, PickORMTableInputColumnsAndComputed, Queryable, Repo, Selectable, SetColumnsResult, Table, TableClass, TableClasses, TableInfo, TableQueryBuilder, Updatable, bundleOrchidORM, bundleOrchidORMTables, createBaseTable, createRepo, defineRls, makeOrchidOrmDbWithAdapter, orchidORMWithAdapter, setGrants };

package/dist/index.js

@@ -67,6 +67,8 @@ function createBaseTable({ schemaConfig = pqb_internal.defaultSchemaConfig, colu
 			let instance = instances.get(this);
 			if (!instance) {
 				instance = new this();
+				const name = instance.table || instance.name;
+				if (instance.nameInDb === void 0 && name) instance.nameInDb = instance.snakeCase ? (0, pqb_internal.toSnakeCase)(name) : name;
 				instances.set(this, instance);
 			}
 			return instance;
@@ -214,7 +216,7 @@ function joinHasRelation(baseQuery, joiningQuery, primaryKeys, foreignKeys, len)
 	return q;
 }
 const addAutoForeignKey = (tableConfig, from, to, primaryKeys, foreignKeys, options, originalForeignKeys) => {
-	const toTable = to.table;
+	const toTable = to.q.nameInDb || to.table;
 	let fkeyOptions = options.foreignKey !== void 0 ? options.foreignKey : tableConfig.autoForeignKeys;
 	if (!fkeyOptions) return;
 	if (fkeyOptions === true) fkeyOptions = tableConfig.autoForeignKeys || pqb_internal.emptyObject;
@@ -228,7 +230,10 @@ const addAutoForeignKey = (tableConfig, from, to, primaryKeys, foreignKeys, opti
 				if (typeof fkey.fnOrTable === "string") {
 					fkeyTable = fkey.fnOrTable;
 					fkeyColumn = getColumnKeyFromDbName(to, fkeyColumn);
-				} else fkeyTable = fkey.fnOrTable().instance().table;
+				} else {
+					const instance = fkey.fnOrTable().instance();
+					fkeyTable = instance.nameInDb || instance.table;
+				}
 				if (toTable === fkeyTable && pkey === fkeyColumn) return;
 			}
 		}
@@ -239,7 +244,13 @@ const addAutoForeignKey = (tableConfig, from, to, primaryKeys, foreignKeys, opti
 		const sortedFkeys = [...foreignKeys].sort();
 		for (const { references: refs } of constraints) {
 			if (!refs) continue;
-			if (refs.columns.length === sortedFkeys.length && refs.columns.every((column, i) => column === sortedFkeys[i]) && refs.foreignColumns.length === sortedPkeys.length && (typeof refs.fnOrTable === "string" ? refs.fnOrTable === toTable && refs.foreignColumns.every((column, i) => getColumnKeyFromDbName(to, column) === sortedPkeys[i]) : refs.fnOrTable().instance().table === toTable && refs.foreignColumns.every((column, i) => column === sortedPkeys[i]))) return;
+			let sameForeignTable = false;
+			if (typeof refs.fnOrTable === "string") sameForeignTable = refs.fnOrTable === toTable && refs.foreignColumns.every((column, i) => getColumnKeyFromDbName(to, column) === sortedPkeys[i]);
+			else {
+				const instance = refs.fnOrTable().instance();
+				sameForeignTable = (instance.nameInDb || instance.table) === toTable && refs.foreignColumns.every((column, i) => column === sortedPkeys[i]);
+			}
+			if (refs.columns.length === sortedFkeys.length && refs.columns.every((column, i) => column === sortedFkeys[i]) && refs.foreignColumns.length === sortedPkeys.length && sameForeignTable) return;
 		}
 	}
 	(from.internal.tableData.constraints ??= []).push({
@@ -410,9 +421,10 @@ var BelongsToVirtualColumn = class extends pqb_internal.VirtualColumn {
 		this.nestedUpdate(queryForUpdate, set, data);
 	}
 };
-const getBelongsToRequired = (tableConfig, relation) => {
+const getBelongsToRequired = (tableConfig, relatedTableConfig, relation) => {
 	const { required } = relation.options;
 	if (typeof required === "boolean") return required;
+	if (relatedTableConfig.softDelete) return false;
 	return relation.options.columns.every((key) => {
 		return !tableConfig.columns.shape[key].data.isNullable;
 	});
@@ -1359,6 +1371,7 @@ const applyRelations = (qb, tables, result, schema) => {
 			const data = {
 				relationName,
 				relation,
+				otherTable: otherTable[1],
 				dbTable,
 				otherDbTable
 			};
@@ -1402,7 +1415,7 @@ const delayRelation = (delayedRelations, table, relationName, data) => {
 	if (tableRelations[relationName]) tableRelations[relationName].push(data);
 	else tableRelations[relationName] = [data];
 };
-const applyRelation = (table, qb, { relationName, relation, dbTable, otherDbTable }, delayedRelations, schema) => {
+const applyRelation = (table, qb, { relationName, relation, otherTable, dbTable, otherDbTable }, delayedRelations, schema) => {
 	const baseQuery = Object.create(otherDbTable);
 	baseQuery.baseQuery = baseQuery;
 	const query = baseQuery.as(relationName);
@@ -1415,21 +1428,12 @@ const applyRelation = (table, qb, { relationName, relation, dbTable, otherDbTabl
 	else if (type === "hasAndBelongsToMany") data = makeHasAndBelongsToManyMethod(table, dbTable, qb, relation, relationName, query, schema);
 	else throw new Error(`Unknown relation type ${type}`);
 	if (data.returns === "one") {
-		if (type === "belongsTo" ? getBelongsToRequired(table, relation) : relation.options.required) (0, pqb_internal._queryTake)(query);
+		if (type === "belongsTo" ? getBelongsToRequired(table, otherTable, relation) : relation.options.required) (0, pqb_internal._queryTake)(query);
 		else (0, pqb_internal._queryTakeOptional)(query);
 		query.q.returnsOne = true;
 	}
 	if (data.virtualColumn) dbTable.shape[relationName] = dbTable.q.selectShape[relationName] = data.virtualColumn;
 	baseQuery.joinQuery = data.joinQuery;
-	const { join: originalJoin } = baseQuery;
-	baseQuery.join = function(...args) {
-		if (args.length) return originalJoin.apply(this, args);
-		else {
-			const q = this.clone();
-			q.q.innerJoinLateral = true;
-			return q;
-		}
-	};
 	dbTable.relations[relationName] = {
 		table: otherDbTable,
 		query,
@@ -1486,6 +1490,7 @@ const assignTablesToOrm = (isTable, tables, result, adapter, qb, asyncStorage, c
 			scopes: table.scopes,
 			softDelete: table.softDelete,
 			snakeCase: table.snakeCase,
+			nameInDb: table.nameInDb,
 			comment: table.comment,
 			readOnly: isTable ? table.readOnly ? true : void 0 : table.materialized || table.readOnly !== false ? true : void 0,
 			materialized: !isTable && table.materialized ? true : void 0,
@@ -1615,12 +1620,12 @@ const privateOrchidORMWithAdapter = ({ log, logger, autoPreparedStatements, noPr
 		viewInstances = assignTablesToOrm(false, views, result.$views, adapter, qb, asyncStorage, commonOptions, schema);
 		const tableDbNames = Object.values(tableInstances).map((table) => {
 			const s = typeof table.schema === "function" ? table.schema() : table.schema;
-			return `${s ? s + "." : ""}${table.table}`;
+			return `${s ? s + "." : ""}${table.nameInDb}`;
 		});
 		for (const key in views) {
 			const view = viewInstances[key];
 			const s = typeof view.schema === "function" ? view.schema() : view.schema;
-			const name = `${s ? s + "." : ""}${view.name}`;
+			const name = `${s ? s + "." : ""}${view.nameInDb}`;
 			if (tableDbNames.includes(name)) throw new Error(`Cannot configure both a table and a view for database relation ${name}`);
 		}
 	}