pqb 0.1.9 → 0.2.0

package/package.json

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

package/src/db.ts

@@ -59,7 +59,7 @@ export interface Db<
   columnsParsers?: ColumnsParsers;
   result: Pick<Shape, DefaultSelectColumns<Shape>[number]>;
   hasSelect: false;
-  hasWhere: false;
+  hasWhere: boolean;
   selectable: { [K in keyof Shape]: { as: K; column: Shape[K] } } & {
     [K in keyof Shape as `${Table}.${StringKey<K>}`]: {
       as: K;

package/src/queryMethods/queryMethods.test.ts

@@ -43,11 +43,6 @@ describe('queryMethods', () => {
   });
 
   describe('.all', () => {
-    it('should return the same query if already all', () => {
-      const q = User.all();
-      expect(q.all()).toBe(q);
-    });
-
     it('should remove `take` from query if it is set', () => {
       const q = User.take();
       expect((q.query as SelectQueryData)?.take).toBe(true);

package/src/queryMethods/queryMethods.ts

@@ -109,9 +109,7 @@ export class QueryMethods {
   __model!: Query;
 
   all<T extends Query>(this: T): SetQueryReturnsAll<T> {
-    return this.query.returnType === 'all'
-      ? (this as unknown as SetQueryReturnsAll<T>)
-      : this.clone()._all();
+    return this.clone()._all();
   }
 
   _all<T extends Query>(this: T): SetQueryReturnsAll<T> {
@@ -121,9 +119,7 @@ export class QueryMethods {
   }
 
   take<T extends Query>(this: T): SetQueryReturnsOne<T> {
-    return this.query.returnType === 'oneOrThrow'
-      ? (this as unknown as SetQueryReturnsOne<T>)
-      : this.clone()._take();
+    return this.clone()._take();
   }
 
   _take<T extends Query>(this: T): SetQueryReturnsOne<T> {
@@ -133,9 +129,7 @@ export class QueryMethods {
   }
 
   takeOptional<T extends Query>(this: T): SetQueryReturnsOneOptional<T> {
-    return this.query.returnType === 'one'
-      ? (this as unknown as SetQueryReturnsOneOptional<T>)
-      : this.clone()._takeOptional();
+    return this.clone()._takeOptional();
   }
 
   _takeOptional<T extends Query>(this: T): SetQueryReturnsOneOptional<T> {
@@ -145,9 +139,7 @@ export class QueryMethods {
   }
 
   rows<T extends Query>(this: T): SetQueryReturnsRows<T> {
-    return this.query.returnType === 'rows'
-      ? (this as unknown as SetQueryReturnsRows<T>)
-      : this.clone()._rows();
+    return this.clone()._rows();
   }
 
   _rows<T extends Query>(this: T): SetQueryReturnsRows<T> {
@@ -160,9 +152,7 @@ export class QueryMethods {
     this: T,
     select: S,
   ): SetQueryReturnsPluck<T, S> {
-    return this.query.returnType === 'pluck'
-      ? (this as unknown as SetQueryReturnsPluck<T, S>)
-      : this.clone()._pluck(select);
+    return this.clone()._pluck(select);
   }
 
   _pluck<T extends Query, S extends Expression<T>>(
@@ -177,9 +167,7 @@ export class QueryMethods {
   }
 
   exec<T extends Query>(this: T): SetQueryReturnsVoid<T> {
-    return this.query.returnType === 'void'
-      ? (this as unknown as SetQueryReturnsVoid<T>)
-      : this.clone()._exec();
+    return this.clone()._exec();
   }
 
   _exec<T extends Query>(this: T): SetQueryReturnsVoid<T> {

package/src/queryMethods/where.test.ts

@@ -1360,51 +1360,51 @@ export const testWhere = (
     );
   });
 
-  describe('orWhereExists', () => {
-    testJoin(
-      'orWhereExists',
-      (target: string, conditions: string) => `
-        SELECT * FROM "user"
-        WHERE "user"."id" = $1 OR EXISTS (
-          SELECT 1 FROM ${target}
-          WHERE ${conditions}
-          LIMIT 1
-        )
-      `,
-      User.where({ id: 1 }),
-      [1],
-    );
-  });
-
-  describe('whereNotExists', () => {
-    testJoin(
-      'whereNotExists',
-      (target: string, conditions: string) => `
-        SELECT * FROM "user"
-        WHERE NOT EXISTS (
-          SELECT 1 FROM ${target}
-          WHERE ${conditions}
-          LIMIT 1
-        )
-      `,
-    );
-  });
-
-  describe('orWhereNotExists', () => {
-    testJoin(
-      'orWhereNotExists',
-      (target: string, conditions: string) => `
-        SELECT * FROM "user"
-        WHERE "user"."id" = $1 OR NOT EXISTS (
-          SELECT 1 FROM ${target}
-          WHERE ${conditions}
-          LIMIT 1
-        )
-      `,
-      User.where({ id: 1 }),
-      [1],
-    );
-  });
+  // describe('orWhereExists', () => {
+  //   testJoin(
+  //     'orWhereExists',
+  //     (target: string, conditions: string) => `
+  //       SELECT * FROM "user"
+  //       WHERE "user"."id" = $1 OR EXISTS (
+  //         SELECT 1 FROM ${target}
+  //         WHERE ${conditions}
+  //         LIMIT 1
+  //       )
+  //     `,
+  //     User.where({ id: 1 }),
+  //     [1],
+  //   );
+  // });
+  //
+  // describe('whereNotExists', () => {
+  //   testJoin(
+  //     'whereNotExists',
+  //     (target: string, conditions: string) => `
+  //       SELECT * FROM "user"
+  //       WHERE NOT EXISTS (
+  //         SELECT 1 FROM ${target}
+  //         WHERE ${conditions}
+  //         LIMIT 1
+  //       )
+  //     `,
+  //   );
+  // });
+  //
+  // describe('orWhereNotExists', () => {
+  //   testJoin(
+  //     'orWhereNotExists',
+  //     (target: string, conditions: string) => `
+  //       SELECT * FROM "user"
+  //       WHERE "user"."id" = $1 OR NOT EXISTS (
+  //         SELECT 1 FROM ${target}
+  //         WHERE ${conditions}
+  //         LIMIT 1
+  //       )
+  //     `,
+  //     User.where({ id: 1 }),
+  //     [1],
+  //   );
+  // });
 };
 
 export const testJoin = (
@@ -1554,21 +1554,23 @@ export const testJoin = (
       };
     };
 
-    withRelation.relations = {
-      message: {
-        key: 'message',
-        query: Message,
-        joinQuery(fromQuery, toQuery) {
-          return pushQueryOn(
-            toQuery.clone(),
-            fromQuery,
-            toQuery,
-            'authorId',
-            'id',
-          );
+    Object.assign(withRelation.__model, {
+      relations: {
+        message: {
+          key: 'message',
+          query: Message,
+          joinQuery(fromQuery: Query, toQuery: Query) {
+            return pushQueryOn(
+              toQuery.clone(),
+              fromQuery,
+              toQuery,
+              'authorId',
+              'id',
+            );
+          },
         },
       },
-    };
+    });
 
     it('should join relation', () => {
       expectSql(
@@ -1604,3 +1606,11 @@ const buildSql = (cb: (q: Query) => Query) => {
 const startSql = `SELECT * FROM "user" WHERE`;
 
 testWhere(buildSql, startSql);
+
+describe('where', () => {
+  it('should be assignable to the query', () => {
+    let q = User.all();
+    q = q.where({ id: 1 });
+    expectSql(q.toSql(), 'SELECT * FROM "user" WHERE "user"."id" = $1', [1]);
+  });
+});

package/src/queryMethods/where.ts

@@ -50,7 +50,7 @@ export type WhereInValues<
       | Query
       | RawExpression;
 
-export type WhereResult<T extends QueryBase> = Omit<T, 'hasWhere'> & {
+export type WhereResult<T extends QueryBase> = T & {
   hasWhere: true;
 };