pqb 0.2.4 → 0.2.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pqb",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "description": "Postgres query builder",
   "homepage": "https://porm.netlify.app/guide/query-builder.html",
   "repository": {

package/src/adapter.test.ts

@@ -1,10 +1,10 @@
 import { adapter } from './test-utils';
 
 describe('adapter', () => {
-  it('should run query and close connection by calling .destroy()', async () => {
+  it('should run query and close connection by calling .close()', async () => {
     const result = await adapter.query('SELECT 1 as num');
     expect(result.rows).toEqual([{ num: 1 }]);
 
-    await adapter.destroy();
+    await adapter.close();
   });
 });

package/src/adapter.ts

@@ -99,7 +99,7 @@ export class Adapter {
     }
   }
 
-  destroy(): Promise<void> {
+  close(): Promise<void> {
     return this.pool.end();
   }
 }
@@ -167,7 +167,7 @@ export class TransactionAdapter implements Adapter {
     return await cb(this);
   }
 
-  destroy() {
+  close() {
     return this.pool.end();
   }
 }

package/src/db.ts

@@ -162,7 +162,7 @@ type DbResult<CT extends ColumnTypesBase> = Db & {
   ): Db<Table, Shape>;
 
   adapter: Adapter;
-  destroy: Adapter['destroy'];
+  close: Adapter['close'];
 };
 
 export type DbOptions<CT extends ColumnTypesBase = ColumnTypes> = (
@@ -206,7 +206,7 @@ export const createDb = <CT extends ColumnTypesBase = ColumnTypes>({
       );
     },
     qb,
-    { adapter, destroy: () => adapter.destroy() },
+    { adapter, close: () => adapter.close() },
   );
 
   // Set all methods from prototype to the db instance (needed for transaction at least):

package/src/queryMethods/insert.ts

@@ -20,7 +20,7 @@ import {
   Relation,
   RelationsBase,
 } from '../relations';
-import { SetOptional } from '../utils';
+import { EmptyObject, SetOptional } from '../utils';
 import { InsertQueryData, OnConflictItem, OnConflictMergeUpdate } from '../sql';
 import { WhereArg } from './where';
 import { parseResult, queryMethodByReturnType } from './then';
@@ -43,14 +43,13 @@ type OmitBelongsToForeignKeys<R extends RelationsBase, Data> = Omit<
 >;
 
 type InsertRelationData<T extends Query> = {
-  [Key in keyof T['relations']]: T['relations'][Key] extends BelongsToRelation
-    ? InsertBelongsToData<T, Key, T['relations'][Key]>
-    : T['relations'][Key] extends HasOneRelation
-    ? InsertHasOneData<T, Key, T['relations'][Key]>
-    : T['relations'][Key] extends HasManyRelation | HasAndBelongsToManyRelation
-    ? InsertHasManyData<T, Key, T['relations'][Key]>
-    : // eslint-disable-next-line @typescript-eslint/ban-types
-      {};
+  [K in keyof T['relations']]: T['relations'][K] extends BelongsToRelation
+    ? InsertBelongsToData<T, K, T['relations'][K]>
+    : T['relations'][K] extends HasOneRelation
+    ? InsertHasOneData<T, K, T['relations'][K]>
+    : T['relations'][K] extends HasManyRelation | HasAndBelongsToManyRelation
+    ? InsertHasManyData<T, K, T['relations'][K]>
+    : EmptyObject;
 }[keyof T['relations']];
 
 type InsertBelongsToData<

package/src/queryMethods/update.ts

@@ -3,12 +3,16 @@ import { pushQueryArray, pushQueryValue } from '../queryDataUtils';
 import { isRaw, RawExpression, StringKey } from '../common';
 import {
   BelongsToNestedUpdate,
+  BelongsToRelation,
+  HasAndBelongsToManyRelation,
+  HasManyRelation,
   HasOneNestedUpdate,
+  HasOneRelation,
   NestedUpdateOneItem,
   Relation,
 } from '../relations';
 import { WhereArg, WhereResult } from './where';
-import { MaybeArray } from '../utils';
+import { EmptyObject, MaybeArray } from '../utils';
 import { InsertData } from './insert';
 import { parseResult, queryMethodByReturnType } from './then';
 
@@ -16,86 +20,77 @@ export type UpdateData<T extends Query> = {
   [K in keyof T['type']]?: T['type'][K] | RawExpression;
 } & (T['relations'] extends Record<string, Relation>
   ? {
-      [K in keyof T['relations']]?: T['relations'][K]['type'] extends 'belongsTo'
-        ?
-            | { disconnect: boolean }
-            | { set: WhereArg<T['relations'][K]['model']> }
-            | { delete: boolean }
-            | { update: UpdateData<T['relations'][K]['model']> }
-            | {
-                create: InsertData<T['relations'][K]['nestedCreateQuery']>;
-              }
-            | (T['returnType'] extends 'one' | 'oneOrThrow'
-                ? {
-                    upsert: {
-                      update: UpdateData<T['relations'][K]['model']>;
-                      create: InsertData<
-                        T['relations'][K]['nestedCreateQuery']
-                      >;
-                    };
-                  }
-                : never)
-        : T['relations'][K]['type'] extends 'hasOne'
-        ?
-            | { disconnect: boolean }
-            | { delete: boolean }
-            | { update: UpdateData<T['relations'][K]['model']> }
-            | (T['returnType'] extends 'one' | 'oneOrThrow'
-                ?
-                    | { set: WhereArg<T['relations'][K]['model']> }
-                    | {
-                        upsert: {
-                          update: UpdateData<T['relations'][K]['model']>;
-                          create: InsertData<
-                            T['relations'][K]['nestedCreateQuery']
-                          >;
-                        };
-                      }
-                    | {
-                        create: InsertData<
-                          T['relations'][K]['nestedCreateQuery']
-                        >;
-                      }
-                : never)
-        : T['relations'][K]['type'] extends 'hasMany'
-        ?
-            | { disconnect: MaybeArray<WhereArg<T['relations'][K]['model']>> }
-            | { delete: MaybeArray<WhereArg<T['relations'][K]['model']>> }
-            | {
-                update: {
-                  where: MaybeArray<WhereArg<T['relations'][K]['model']>>;
-                  data: UpdateData<T['relations'][K]['model']>;
-                };
-              }
-            | (T['returnType'] extends 'one' | 'oneOrThrow'
-                ?
-                    | { set: MaybeArray<WhereArg<T['relations'][K]['model']>> }
-                    | {
-                        create: InsertData<
-                          T['relations'][K]['nestedCreateQuery']
-                        >[];
-                      }
-                : never)
-        : T['relations'][K]['type'] extends 'hasAndBelongsToMany'
-        ?
-            | { disconnect: MaybeArray<WhereArg<T['relations'][K]['model']>> }
-            | {
-                set: MaybeArray<WhereArg<T['relations'][K]['model']>>;
-              }
-            | { delete: MaybeArray<WhereArg<T['relations'][K]['model']>> }
-            | {
-                update: {
-                  where: MaybeArray<WhereArg<T['relations'][K]['model']>>;
-                  data: UpdateData<T['relations'][K]['model']>;
-                };
-              }
-            | {
-                create: InsertData<T['relations'][K]['nestedCreateQuery']>[];
-              }
+      [K in keyof T['relations']]?: T['relations'][K] extends BelongsToRelation
+        ? UpdateBelongsToData<T, T['relations'][K]>
+        : T['relations'][K] extends HasOneRelation
+        ? UpdateHasOneData<T, T['relations'][K]>
+        : T['relations'][K] extends HasManyRelation
+        ? UpdateHasManyData<T, T['relations'][K]>
+        : T['relations'][K] extends HasAndBelongsToManyRelation
+        ? UpdateHasAndBelongsToManyData<T['relations'][K]>
         : never;
     }
-  : // eslint-disable-next-line @typescript-eslint/ban-types
-    {});
+  : EmptyObject);
+
+type UpdateBelongsToData<T extends Query, Rel extends BelongsToRelation> =
+  | { disconnect: boolean }
+  | { set: WhereArg<Rel['model']> }
+  | { delete: boolean }
+  | { update: UpdateData<Rel['model']> }
+  | {
+      create: InsertData<Rel['nestedCreateQuery']>;
+    }
+  | (T['returnType'] extends 'one' | 'oneOrThrow'
+      ? {
+          upsert: {
+            update: UpdateData<Rel['model']>;
+            create: InsertData<Rel['nestedCreateQuery']>;
+          };
+        }
+      : never);
+
+type UpdateHasOneData<T extends Query, Rel extends HasOneRelation> =
+  | { disconnect: boolean }
+  | { delete: boolean }
+  | { update: UpdateData<Rel['model']> }
+  | (T['returnType'] extends 'one' | 'oneOrThrow'
+      ?
+          | { set: WhereArg<Rel['model']> }
+          | {
+              upsert: {
+                update: UpdateData<Rel['model']>;
+                create: InsertData<Rel['nestedCreateQuery']>;
+              };
+            }
+          | {
+              create: InsertData<Rel['nestedCreateQuery']>;
+            }
+      : never);
+
+type UpdateHasManyData<T extends Query, Rel extends HasManyRelation> = {
+  disconnect?: MaybeArray<WhereArg<Rel['model']>>;
+  delete?: MaybeArray<WhereArg<Rel['model']>>;
+  update?: {
+    where: MaybeArray<WhereArg<Rel['model']>>;
+    data: UpdateData<Rel['model']>;
+  };
+} & (T['returnType'] extends 'one' | 'oneOrThrow'
+  ? {
+      set?: MaybeArray<WhereArg<Rel['model']>>;
+      create?: InsertData<Rel['nestedCreateQuery']>[];
+    }
+  : EmptyObject);
+
+type UpdateHasAndBelongsToManyData<Rel extends HasAndBelongsToManyRelation> = {
+  disconnect?: MaybeArray<WhereArg<Rel['model']>>;
+  set?: MaybeArray<WhereArg<Rel['model']>>;
+  delete?: MaybeArray<WhereArg<Rel['model']>>;
+  update?: {
+    where: MaybeArray<WhereArg<Rel['model']>>;
+    data: UpdateData<Rel['model']>;
+  };
+  create?: InsertData<Rel['nestedCreateQuery']>[];
+};
 
 type UpdateArgs<T extends Query, ForceAll extends boolean> = (
   T['hasWhere'] extends true ? true : ForceAll