orchid-orm 1.14.0 → 1.14.1

package/dist/index.d.ts

@@ -1,15 +1,45 @@
 import * as pqb from 'pqb';
-import { BelongsToRelation, HasManyRelation, HasOneRelation, Db, IsolationLevel, TransactionOptions, Adapter, FromArgs, Query, FromResult, AdapterOptions, QueryLogOptions, NoPrimaryKeyOption, HasAndBelongsToManyRelation, SetQueryTableAlias, BaseRelation, RelationQuery, SetQueryReturnsOne, SetQueryReturnsOneOptional, SetQueryReturnsAll, DefaultColumnTypes, QueryData, QueryBase, ColumnsShape, QueryBeforeHook, QueryAfterHook, AfterHook, WhereResult, MergeQuery, SetQueryReturns, QueryReturnType } from 'pqb';
+import { QueryWithTable, SetQueryTableAlias, Query, WhereArg, UpdateData, CreateData, Db, IsolationLevel, TransactionOptions, Adapter, FromArgs, FromResult, AdapterOptions, QueryLogOptions, NoPrimaryKeyOption, RelationConfigBase, RelationQuery, SetQueryReturnsOne, SetQueryReturnsOneOptional, SetQueryReturnsAll, RelationQueryBase, DefaultColumnTypes, QueryData, QueryBase, ColumnsShape, QueryBeforeHook, QueryAfterHook, AfterHook, WhereResult, MergeQuery, SetQueryReturns, QueryReturnType } from 'pqb';
 export { OrchidOrmError, OrchidOrmInternalError, columnTypes, raw, testTransaction } from 'pqb';
 import * as orchid_core from 'orchid-core';
-import { StringKey, EmptyObject, ColumnTypesBase, ColumnsShapeBase, ColumnShapeOutput } from 'orchid-core';
+import { EmptyObject, MaybeArray, ColumnTypesBase, ColumnsShapeBase, ColumnShapeOutput } from 'orchid-core';
 
 interface BelongsTo extends RelationThunkBase {
     type: 'belongsTo';
     returns: 'one';
-    options: BelongsToRelation['options'];
+    options: RelationCommonOptions & {
+        primaryKey: string;
+        foreignKey: string;
+    };
 }
-type BelongsToInfo<T extends Table, Relation extends BelongsTo, FK extends string = Relation['options']['foreignKey']> = {
+type BelongsToInfo<T extends Table, Relation extends BelongsTo, K extends string, FK extends string = Relation['options']['foreignKey'], Q extends QueryWithTable = SetQueryTableAlias<DbTable<ReturnType<Relation['fn']>>, K>> = {
+    table: Q;
+    query: Q;
+    joinQuery(fromQuery: Query, toQuery: Query): Query;
+    one: true;
+    required: Relation['options']['required'] extends true ? true : false;
+    omitForeignKeyInCreate: FK;
+    dataForCreate: RelationToOneDataForCreate<{
+        nestedCreateQuery: Q;
+        table: Q;
+    }>;
+    dataForUpdate: {
+        disconnect: boolean;
+    } | {
+        set: WhereArg<Q>;
+    } | {
+        delete: boolean;
+    } | {
+        update: UpdateData<Q>;
+    } | {
+        create: CreateData<Q>;
+    };
+    dataForUpdateOne: {
+        upsert: {
+            update: UpdateData<Q>;
+            create: CreateData<Q> | (() => CreateData<Q>);
+        };
+    };
     params: Record<FK, T['columns']['shape'][FK]['type']>;
     populate: never;
     chainedCreate: false;
@@ -19,17 +49,51 @@ type BelongsToInfo<T extends Table, Relation extends BelongsTo, FK extends strin
 interface HasMany extends RelationThunkBase {
     type: 'hasMany';
     returns: 'many';
-    options: HasManyRelation['options'];
+    options: RelationCommonOptions & ({
+        primaryKey: string;
+        foreignKey: string;
+    } | {
+        through: string;
+        source: string;
+    });
 }
-type HasManyInfo<T extends Table, Relations extends RelationThunks, Relation extends HasMany> = {
+type HasManyInfo<T extends Table, Relations extends RelationThunks, Relation extends HasMany, K extends string, Populate extends string = Relation['options'] extends {
+    foreignKey: string;
+} ? Relation['options']['foreignKey'] : never, TC extends TableClass = ReturnType<Relation['fn']>, Q extends QueryWithTable = SetQueryTableAlias<DbTable<TC>, K>, NestedCreateQuery extends Query = [Populate] extends [never] ? Q : Q & {
+    meta: {
+        defaults: Record<Populate, true>;
+    };
+}> = {
+    table: Q;
+    query: Q;
+    joinQuery(fromQuery: Query, toQuery: Query): Query;
+    one: false;
+    required: Relation['options']['required'] extends true ? true : false;
+    omitForeignKeyInCreate: never;
+    dataForCreate: Relation['options'] extends {
+        through: string;
+    } ? EmptyObject : RelationToManyDataForCreate<{
+        nestedCreateQuery: NestedCreateQuery;
+        table: Q;
+    }>;
+    dataForUpdate: {
+        disconnect?: MaybeArray<WhereArg<Q>>;
+        delete?: MaybeArray<WhereArg<Q>>;
+        update?: {
+            where: MaybeArray<WhereArg<Q>>;
+            data: UpdateData<Q>;
+        };
+    };
+    dataForUpdateOne: {
+        set?: MaybeArray<WhereArg<Q>>;
+        create?: CreateData<NestedCreateQuery>[];
+    };
     params: Relation['options'] extends {
         primaryKey: string;
     } ? Record<Relation['options']['primaryKey'], T['columns']['shape'][Relation['options']['primaryKey']]['type']> : Relation['options'] extends {
         through: string;
-    } ? RelationInfo<T, Relations, Relations[Relation['options']['through']]>['params'] : never;
-    populate: Relation['options'] extends {
-        foreignKey: string;
-    } ? Relation['options']['foreignKey'] : never;
+    } ? RelationConfig<T, Relations, Relations[Relation['options']['through']]>['params'] : never;
+    populate: Populate;
     chainedCreate: Relation['options'] extends {
         primaryKey: string;
     } ? true : false;
@@ -39,17 +103,56 @@ type HasManyInfo<T extends Table, Relations extends RelationThunks, Relation ext
 interface HasOne extends RelationThunkBase {
     type: 'hasOne';
     returns: 'one';
-    options: HasOneRelation['options'];
+    options: RelationCommonOptions & ({
+        primaryKey: string;
+        foreignKey: string;
+    } | {
+        through: string;
+        source: string;
+    });
 }
-type HasOneInfo<T extends Table, Relations extends RelationThunks, Relation extends HasOne> = {
+type HasOneInfo<T extends Table, Relations extends RelationThunks, Relation extends HasOne, K extends string, Populate extends string = Relation['options'] extends {
+    foreignKey: string;
+} ? Relation['options']['foreignKey'] : never, TC extends TableClass = ReturnType<Relation['fn']>, Q extends QueryWithTable = SetQueryTableAlias<DbTable<TC>, K>, NestedCreateQuery extends Query = [Populate] extends [never] ? Q : Q & {
+    meta: {
+        defaults: Record<Populate, true>;
+    };
+}> = {
+    table: Q;
+    query: Q;
+    joinQuery(fromQuery: Query, toQuery: Query): Query;
+    one: true;
+    required: Relation['options']['required'] extends true ? true : false;
+    omitForeignKeyInCreate: never;
+    dataForCreate: Relation['options'] extends {
+        through: string;
+    } ? EmptyObject : RelationToOneDataForCreate<{
+        nestedCreateQuery: NestedCreateQuery;
+        table: Q;
+    }>;
+    dataForUpdate: {
+        disconnect: boolean;
+    } | {
+        delete: boolean;
+    } | {
+        update: UpdateData<Q>;
+    };
+    dataForUpdateOne: {
+        set: WhereArg<Q>;
+    } | {
+        upsert: {
+            update: UpdateData<Q>;
+            create: CreateData<NestedCreateQuery> | (() => CreateData<NestedCreateQuery>);
+        };
+    } | {
+        create: CreateData<NestedCreateQuery>;
+    };
     params: Relation['options'] extends {
         primaryKey: string;
     } ? Record<Relation['options']['primaryKey'], T['columns']['shape'][Relation['options']['primaryKey']]['type']> : Relation['options'] extends {
         through: string;
-    } ? RelationInfo<T, Relations, Relations[Relation['options']['through']]>['params'] : never;
-    populate: Relation['options'] extends {
-        foreignKey: string;
-    } ? Relation['options']['foreignKey'] : never;
+    } ? RelationConfig<T, Relations, Relations[Relation['options']['through']]>['params'] : never;
+    populate: Populate;
     chainedCreate: Relation['options'] extends {
         primaryKey: string;
     } ? true : false;
@@ -141,62 +244,103 @@ declare const orchidORM: <T extends TableClasses>({ log, logger, autoPreparedSta
 interface HasAndBelongsToMany extends RelationThunkBase {
     type: 'hasAndBelongsToMany';
     returns: 'many';
-    options: HasAndBelongsToManyRelation['options'];
+    options: RelationCommonOptions & {
+        primaryKey: string;
+        foreignKey: string;
+        associationPrimaryKey: string;
+        associationForeignKey: string;
+        joinTable: string;
+    };
 }
-type HasAndBelongsToManyInfo<T extends Table, Relation extends HasAndBelongsToMany> = {
+type HasAndBelongsToManyInfo<T extends Table, Relation extends HasAndBelongsToMany, K extends string, TC extends TableClass = ReturnType<Relation['fn']>, Q extends QueryWithTable = SetQueryTableAlias<DbTable<TC>, K>> = {
+    table: Q;
+    query: Q;
+    joinQuery(fromQuery: Query, toQuery: Query): Query;
+    one: false;
+    required: Relation['options']['required'] extends true ? true : false;
+    omitForeignKeyInCreate: never;
+    dataForCreate: RelationToManyDataForCreate<{
+        nestedCreateQuery: Q;
+        table: Q;
+    }>;
+    dataForUpdate: {
+        disconnect?: MaybeArray<WhereArg<Q>>;
+        set?: MaybeArray<WhereArg<Q>>;
+        delete?: MaybeArray<WhereArg<Q>>;
+        update?: {
+            where: MaybeArray<WhereArg<Q>>;
+            data: UpdateData<Q>;
+        };
+        create?: CreateData<Q>[];
+    };
+    dataForUpdateOne: EmptyObject;
     params: Record<Relation['options']['primaryKey'], T['columns']['shape'][Relation['options']['primaryKey']]['type']>;
     populate: never;
     chainedCreate: true;
     chainedDelete: true;
 };
 
+type RelationCommonOptions = {
+    scope?(q: QueryWithTable): QueryWithTable;
+    required?: boolean;
+};
+type RelationToOneDataForCreate<Rel extends {
+    nestedCreateQuery: Query;
+    table: Query;
+}> = {
+    create: CreateData<Rel['nestedCreateQuery']>;
+    connect?: never;
+    connectOrCreate?: never;
+} | {
+    create?: never;
+    connect: WhereArg<Rel['table']>;
+    connectOrCreate?: never;
+} | {
+    create?: never;
+    connect?: never;
+    connectOrCreate: {
+        where: WhereArg<Rel['table']>;
+        create: CreateData<Rel['nestedCreateQuery']>;
+    };
+};
+type RelationToManyDataForCreate<Rel extends {
+    nestedCreateQuery: Query;
+    table: Query;
+}> = {
+    create?: CreateData<Rel['nestedCreateQuery']>[];
+    connect?: WhereArg<Rel['table']>[];
+    connectOrCreate?: {
+        where: WhereArg<Rel['table']>;
+        create: CreateData<Rel['nestedCreateQuery']>;
+    }[];
+};
 interface RelationThunkBase {
     type: string;
     returns: 'one' | 'many';
     fn(): TableClass;
-    options: BaseRelation['options'];
+    options: RelationCommonOptions;
 }
 type RelationThunk = BelongsTo | HasOne | HasMany | HasAndBelongsToMany;
 type RelationThunks = Record<string, RelationThunk>;
-type Relation<T extends Table, Relations extends RelationThunks, K extends StringKey<keyof Relations>, M extends Query = SetQueryTableAlias<DbTable<ReturnType<Relations[K]['fn']>>, K>, Info extends RelationInfo = RelationInfo<T, Relations, Relations[K]>> = {
-    type: Relations[K]['type'];
-    returns: Relations[K]['returns'];
-    key: K;
-    table: M;
-    query: M;
-    joinQuery(fromQuery: Query, toQuery: Query): Query;
-    defaults: Info['populate'];
-    nestedCreateQuery: [Info['populate']] extends [never] ? M : M & {
-        meta: {
-            defaults: Record<Info['populate'], true>;
-        };
-    };
-    primaryKey: string;
-    options: Relations[K]['options'];
-};
-type RelationScopeOrTable<Relation extends RelationThunkBase> = Relation['options']['scope'] extends (q: Query) => Query ? ReturnType<Relation['options']['scope']> : DbTable<ReturnType<Relation['fn']>>;
-type RelationInfo<T extends Table = Table, Relations extends RelationThunks = RelationThunks, Relation extends RelationThunk = RelationThunk> = Relation extends BelongsTo ? BelongsToInfo<T, Relation> : Relation extends HasOne ? HasOneInfo<T, Relations, Relation> : Relation extends HasMany ? HasManyInfo<T, Relations, Relation> : Relation extends HasAndBelongsToMany ? HasAndBelongsToManyInfo<T, Relation> : never;
-type MapRelation<T extends Table, Relations extends RelationThunks, RelationName extends keyof Relations, Relation extends RelationThunk = Relations[RelationName], RelatedQuery extends Query = RelationScopeOrTable<Relation>, Info extends {
-    params: Record<string, unknown>;
-    populate: string;
-    chainedCreate: boolean;
-    chainedDelete: boolean;
-} = RelationInfo<T, Relations, Relation>> = RelationQuery<RelationName, Info['params'], Info['populate'], Relation['returns'] extends 'one' ? Relation['options']['required'] extends true ? SetQueryReturnsOne<RelatedQuery> : SetQueryReturnsOneOptional<RelatedQuery> : SetQueryReturnsAll<RelatedQuery>, Relation['options']['required'] extends boolean ? Relation['options']['required'] : false, Info['chainedCreate'], Info['chainedDelete']>;
-type MapRelations<T extends Table> = 'relations' extends keyof T ? T['relations'] extends RelationThunks ? {
+type RelationScopeOrTable<Relation extends RelationThunkBase> = Relation['options']['scope'] extends (q: Query) => Query ? ReturnType<Relation['options']['scope']> : RelationQueryFromFn<Relation>;
+type RelationQueryFromFn<Relation extends RelationThunkBase, TC extends TableClass = ReturnType<Relation['fn']>, Q extends Query = DbTable<TC>> = Q;
+type RelationConfig<T extends Table = Table, Relations extends RelationThunks = RelationThunks, Relation extends RelationThunk = RelationThunk, K extends string = string, Result extends RelationConfigBase = Relation extends BelongsTo ? BelongsToInfo<T, Relation, K> : Relation extends HasOne ? HasOneInfo<T, Relations, Relation, K> : Relation extends HasMany ? HasManyInfo<T, Relations, Relation, K> : Relation extends HasAndBelongsToMany ? HasAndBelongsToManyInfo<T, Relation, K> : never> = Result;
+type MapRelation<T extends Table, Relations extends RelationThunks, RelationName extends keyof Relations, Relation extends RelationThunk = Relations[RelationName], RelatedQuery extends Query = RelationScopeOrTable<Relation>, Config extends RelationConfigBase = RelationConfig<T, Relations, Relation>> = RelationQuery<RelationName, Config, Config['one'] extends true ? Config['required'] extends true ? SetQueryReturnsOne<RelatedQuery> : SetQueryReturnsOneOptional<RelatedQuery> : SetQueryReturnsAll<RelatedQuery>>;
+type MapRelations<T extends Table> = T extends {
+    relations: RelationThunks;
+} ? {
     [K in keyof T['relations']]: MapRelation<T, T['relations'], K>;
-} : EmptyObject : EmptyObject;
+} : EmptyObject;
 
 type TableClass<T extends Table = Table> = new () => T;
 type TableClasses = Record<string, TableClass>;
-type TableToDb<T extends Table> = Db<T['table'], T['columns']['shape'], 'relations' extends keyof T ? T['relations'] extends RelationThunks ? {
-    [K in StringKey<keyof T['relations']>]: Relation<T, T['relations'], K>;
-} : Query['relations'] : Query['relations'], T['columnTypes']> & {
+type TableToDb<T extends Table, RelationQueries extends Record<string, RelationQueryBase>> = Db<T['table'], T['columns']['shape'], RelationQueries, T['columnTypes']> & {
     definedAs: string;
     db: OrchidORM;
     getFilePath(): string;
     name: string;
 };
-type DbTable<T extends TableClass> = TableToDb<InstanceType<T>> & Omit<MapRelations<InstanceType<T>>, keyof Query>;
+type DbTable<TC extends TableClass, T extends Table = InstanceType<TC>, RelationQueries extends Record<string, RelationQueryBase> = MapRelations<T>, Q extends QueryWithTable = TableToDb<T, RelationQueries>, Result extends QueryWithTable = Q & RelationQueries> = Result;
 type ColumnsConfig = {
     shape: ColumnsShape;
     type: unknown;

package/dist/index.js

@@ -178,8 +178,7 @@ const makeBelongsToMethod = (relation, relationName, query) => {
     },
     reverseJoin(fromQuery, toQuery) {
       return pqb.addQueryOn(fromQuery, toQuery, fromQuery, foreignKey, primaryKey);
-    },
-    primaryKey
+    }
   };
 };
 const nestedInsert$3 = ({ query, primaryKey }) => {
@@ -302,10 +301,12 @@ const nestedUpdate$3 = ({ query, primaryKey, foreignKey }) => {
 };
 
 const getThroughRelation = (table, through) => {
-  return table.relations[through];
+  var _a;
+  return (_a = table.relations[through]) == null ? void 0 : _a.relationConfig;
 };
 const getSourceRelation = (throughRelation, source) => {
-  return throughRelation.table.relations[source];
+  var _a;
+  return (_a = throughRelation.table.relations[source]) == null ? void 0 : _a.relationConfig;
 };
 const hasRelationHandleCreate = (q, ctx, item, rowIndex, key, primaryKey, nestedInsert) => {
   const value = item[key];
@@ -443,8 +444,7 @@ const makeHasOneMethod = (table, relation, relationName, query) => {
             );
           }
         );
-      },
-      primaryKey: sourceRelation.primaryKey
+      }
     };
   }
   const { primaryKey, foreignKey } = relation.options;
@@ -463,7 +463,6 @@ const makeHasOneMethod = (table, relation, relationName, query) => {
     reverseJoin(fromQuery, toQuery) {
       return pqb.addQueryOn(fromQuery, toQuery, fromQuery, primaryKey, foreignKey);
     },
-    primaryKey,
     modifyRelatedQuery(relationQuery) {
       return (query2) => {
         const fromQuery = query2.clone();
@@ -642,8 +641,7 @@ const makeHasManyMethod = (table, relation, relationName, query) => {
             );
           }
         );
-      },
-      primaryKey: sourceRelation.primaryKey
+      }
     };
   }
   const { primaryKey, foreignKey } = relation.options;
@@ -662,7 +660,6 @@ const makeHasManyMethod = (table, relation, relationName, query) => {
     reverseJoin(fromQuery, toQuery) {
       return pqb.addQueryOn(fromQuery, toQuery, fromQuery, primaryKey, foreignKey);
     },
-    primaryKey,
     modifyRelatedQuery(relationQuery) {
       return (query2) => {
         const fromQuery = query2.clone();
@@ -696,7 +693,9 @@ const nestedInsert$1 = ({ query, primaryKey, foreignKey }) => {
     if (connect.length) {
       await Promise.all(
         connect.flatMap(
-          ([selfData, { connect: connect2 }]) => t.or(...connect2)._updateOrThrow({ [foreignKey]: selfData[primaryKey] })
+          ([selfData, { connect: connect2 }]) => t.or(...connect2)._updateOrThrow({
+            [foreignKey]: selfData[primaryKey]
+          })
         )
       );
     }
@@ -914,7 +913,6 @@ const makeHasAndBelongsToManyMethod = (table, qb, relation, relationName, query)
         (q) => q._on(associationForeignKeyFull, `${pqb.getQueryAs(toQuery)}.${apk}`)._on(foreignKeyFull, `${pqb.getQueryAs(fromQuery)}.${pk}`)
       );
     },
-    primaryKey: pk,
     modifyRelatedQuery(relationQuery) {
       const ref = {};
       relationQuery._afterCreate([], async (result) => {
@@ -1152,6 +1150,7 @@ var __spreadValues$2 = (a, b) => {
   return a;
 };
 const applyRelations = (qb, tables, result) => {
+  var _a;
   const tableEntries = Object.entries(tables);
   const delayedRelations = /* @__PURE__ */ new Map();
   for (const name in tables) {
@@ -1215,7 +1214,7 @@ const applyRelations = (qb, tables, result) => {
         let message = `Cannot define a \`${item.relationName}\` relation on \`${as}\``;
         const table = result[as];
         const { through, source } = relation.options;
-        const throughRel = table.relations[through];
+        const throughRel = (_a = table.relations[through]) == null ? void 0 : _a.relationConfig;
         if (through && !throughRel) {
           message += `: cannot find \`${through}\` relation required by the \`through\` option`;
         } else if (source && throughRel && !throughRel.table.relations[source]) {
@@ -1291,16 +1290,12 @@ const applyRelation = (qb, { relationName, relation, dbTable, otherDbTable }, de
       return q;
     }
   };
-  dbTable.relations[relationName] = {
-    type,
-    key: relationName,
+  baseQuery.relationConfig = {
     table: otherDbTable,
     query,
-    joinQuery: data.joinQuery,
-    primaryKey: data.primaryKey,
-    options: relation.options
+    joinQuery: data.joinQuery
   };
-  dbTable.relationsQueries[relationName] = query;
+  dbTable.relations[relationName] = query;
   const tableRelations = delayedRelations.get(dbTable);
   if (!tableRelations)
     return;
@@ -1321,12 +1316,6 @@ const makeRelationQuery = (table, relationName, data, q) => {
       query.q.joinedShapes = __spreadValues$2({
         [pqb.getQueryAs(this)]: this.q.shape
       }, this.q.joinedShapes);
-      query.q[pqb.relationQueryKey] = {
-        relationName,
-        sourceQuery: this,
-        relationQuery: toTable,
-        joinQuery: data.joinQuery
-      };
       const setQuery = (_a = data.modifyRelatedQuery) == null ? void 0 : _a.call(data, query);
       setQuery == null ? void 0 : setQuery(this);
       return new Proxy(data.method, {