orchid-orm 1.73.1 → 1.75.0

package/dist/index.d.ts

@@ -1,67 +1,74 @@
-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> = Rel['related']['softDelete'] extends true | string ? false : { [K in Rel['options']['columns'][number] & string]: T['columns']['shape'][K]['data']['isNullable'] extends true ? false : true }[Rel['options']['columns'][number] & string] 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;
+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 +107,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 +171,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;
@@ -276,7 +270,7 @@ interface RelationThunks {
 }
 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;
+} ? TableQueryBuilder<R> : never;
 interface RelationConfigSelf {
   columns: {
     shape: Column.Shape.QueryInit;
@@ -323,19 +317,19 @@ interface OrchidORMTableHelper<T extends Query> {
 }
 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 };
+} ? OrchidORMTableHelper<TableQueryBuilder<R>> : never };
 type OrchidORMViews<T extends TableClasses = TableClasses> = { [K in keyof T]: T[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 };
+} ? OrchidORMTableHelper<TableQueryBuilder<R>> : never };
 type OrchidORMBundle<T extends TableClasses = TableClasses, V extends TableClasses = TableClasses> = OrchidORMTables<T> & {
   $views: OrchidORMViews<V>;
 };
 type OrchidORMDbTables<T extends TableClasses = TableClasses> = { [K in keyof T]: T[K] extends {
   new (): infer R extends ORMTableInput;
-} ? TableToDb<R, R['table'], R['readOnly'] extends true ? true : undefined> : never };
+} ? TableQueryBuilder<R> : 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 };
+} ? TableQueryBuilder<R> : never };
 type OrchidORM<T extends TableClasses = TableClasses, V extends TableClasses = TableClasses> = OrchidORMDbTables<T> & {
   $views: OrchidORMDbViews<V>;
 } & OrchidORMMethods;
@@ -535,7 +529,7 @@ type BelongsToRequired<T extends RelationConfigSelf, Rel extends BelongsTo> = Re
   required: infer Required extends boolean;
 } ? Required : Rel['options'] extends {
   on: unknown;
-} ? false : BelongsToColumnsRequired<T, Rel['options']['columns'][number] & string>;
+} ? false : BelongsToDefaultRequired<T, Rel>;
 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>>;
 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']];
@@ -544,7 +538,7 @@ type RelationDataForCreate<T extends RelationConfigSelf, Name extends keyof T['r
 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> {
+interface TableQueryBuilder<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<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;
@@ -632,6 +626,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.
@@ -897,4 +892,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, OrchidORMDbViews, OrchidORMTables, OrchidORMViews, 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

@@ -209,7 +209,7 @@ function joinHasThrough(q, baseQuery, joiningQuery, throughRelation, sourceRelat
 function joinHasRelation(baseQuery, joiningQuery, primaryKeys, foreignKeys, len) {
 	const baseAs = (0, pqb_internal.getQueryAs)(baseQuery);
 	const q = joiningQuery.clone();
-	(0, pqb_internal.setQueryObjectValueImmutable)(q, "joinedShapes", baseAs, baseQuery.q.shape);
+	(0, pqb_internal.setQueryObjectValueImmutable)(q, "joinedShapes", baseAs, baseQuery.q.selectShape);
 	for (let i = 0; i < len; i++) (0, pqb_internal.pushQueryOnForOuter)(q, baseQuery, joiningQuery, foreignKeys[i], `${baseAs}.${primaryKeys[i]}`);
 	return q;
 }
@@ -410,9 +410,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;
 	});
@@ -437,7 +438,7 @@ const makeBelongsToMethod = (tableConfig, table, relation, relationName, query)
 	const join = (baseQuery, joiningQuery, primaryKeys, foreignKeys) => {
 		const baseAs = (0, pqb_internal.getQueryAs)(baseQuery);
 		const q = joiningQuery.clone();
-		(0, pqb_internal.setQueryObjectValueImmutable)(q, "joinedShapes", baseAs, baseQuery.q.shape);
+		(0, pqb_internal.setQueryObjectValueImmutable)(q, "joinedShapes", baseAs, baseQuery.q.selectShape);
 		for (let i = 0; i < len; i++) (0, pqb_internal.pushQueryOnForOuter)(q, baseQuery, joiningQuery, primaryKeys[i], `${baseAs}.${foreignKeys[i]}`);
 		return q;
 	};
@@ -1129,7 +1130,7 @@ const makeHasAndBelongsToManyMethod = (tableConfig, table, qb, relation, relatio
 		const foreignAs = (0, pqb_internal.getQueryAs)(joiningQuery);
 		return joinQuery(baseQuery, (0, pqb_internal.getQueryAs)(baseQuery), foreignAs, {
 			...baseQuery.q.joinedShapes,
-			[foreignAs]: joiningQuery.q.shape
+			[foreignAs]: joiningQuery.q.selectShape
 		});
 	};
 	return {
@@ -1147,7 +1148,7 @@ const makeHasAndBelongsToManyMethod = (tableConfig, table, qb, relation, relatio
 		virtualColumn: new HasAndBelongsToManyVirtualColumn(subQuery, pqb_internal.internalSchemaConfig, relationName, state),
 		joinQuery: joinQueryChainHOF((0, pqb_internal.getPrimaryKeys)(query), reverseJoin, (joiningQuery, baseQuery) => joinQuery(joiningQuery, (0, pqb_internal.getQueryAs)(baseQuery), (0, pqb_internal.getQueryAs)(joiningQuery), {
 			...joiningQuery.q.joinedShapes,
-			[baseQuery.q.as || baseQuery.table]: baseQuery.q.shape
+			[baseQuery.q.as || baseQuery.table]: baseQuery.q.selectShape
 		})),
 		reverseJoin,
 		modifyRelatedQuery(relationQuery) {
@@ -1359,6 +1360,7 @@ const applyRelations = (qb, tables, result, schema) => {
 			const data = {
 				relationName,
 				relation,
+				otherTable: otherTable[1],
 				dbTable,
 				otherDbTable
 			};
@@ -1402,7 +1404,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 +1417,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.shape[relationName] = data.virtualColumn;
+	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,