pqb 0.7.4 → 0.7.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pqb",
-  "version": "0.7.4",
+  "version": "0.7.6",
   "description": "Postgres query builder",
   "homepage": "https://orchid-orm.netlify.app/guide/query-builder-setup.html",
   "repository": {

package/src/columnsOperators.test.ts

@@ -277,7 +277,7 @@ describe('operators', () => {
         User.where({ name: { contains: 'ko' } }).toSql(),
         `
           SELECT * FROM "user"
-          WHERE "user"."name" LIKE '%' || $1 || '%'
+          WHERE "user"."name" ILIKE '%' || $1 || '%'
         `,
         ['ko'],
       );
@@ -288,7 +288,7 @@ describe('operators', () => {
         User.where({ name: { contains: User.select('name').take() } }).toSql(),
         `
           SELECT * FROM "user"
-          WHERE "user"."name" LIKE '%' || (SELECT "user"."name" FROM "user" LIMIT $1) || '%'
+          WHERE "user"."name" ILIKE '%' || (SELECT "user"."name" FROM "user" LIMIT $1) || '%'
         `,
         [1],
       );
@@ -299,19 +299,19 @@ describe('operators', () => {
         User.where({ name: { contains: db.raw("'ko'") } }).toSql(),
         `
           SELECT * FROM "user"
-          WHERE "user"."name" LIKE '%' || 'ko' || '%'
+          WHERE "user"."name" ILIKE '%' || 'ko' || '%'
         `,
       );
     });
   });
 
-  describe('containsInsensitive', () => {
+  describe('containsSensitive', () => {
     it('should handle value', () => {
       expectSql(
-        User.where({ name: { containsInsensitive: 'ko' } }).toSql(),
+        User.where({ name: { containsSensitive: 'ko' } }).toSql(),
         `
           SELECT * FROM "user"
-          WHERE "user"."name" ILIKE '%' || $1 || '%'
+          WHERE "user"."name" LIKE '%' || $1 || '%'
         `,
         ['ko'],
       );
@@ -320,11 +320,11 @@ describe('operators', () => {
     it('should handle sub query', () => {
       expectSql(
         User.where({
-          name: { containsInsensitive: User.select('name').take() },
+          name: { containsSensitive: User.select('name').take() },
         }).toSql(),
         `
           SELECT * FROM "user"
-          WHERE "user"."name" ILIKE '%' || (SELECT "user"."name" FROM "user" LIMIT $1) || '%'
+          WHERE "user"."name" LIKE '%' || (SELECT "user"."name" FROM "user" LIMIT $1) || '%'
         `,
         [1],
       );
@@ -332,10 +332,10 @@ describe('operators', () => {
 
     it('should handle raw query', () => {
       expectSql(
-        User.where({ name: { containsInsensitive: db.raw("'ko'") } }).toSql(),
+        User.where({ name: { containsSensitive: db.raw("'ko'") } }).toSql(),
         `
           SELECT * FROM "user"
-          WHERE "user"."name" ILIKE '%' || 'ko' || '%'
+          WHERE "user"."name" LIKE '%' || 'ko' || '%'
         `,
       );
     });
@@ -347,7 +347,7 @@ describe('operators', () => {
         User.where({ name: { startsWith: 'ko' } }).toSql(),
         `
           SELECT * FROM "user"
-          WHERE "user"."name" LIKE $1 || '%'
+          WHERE "user"."name" ILIKE $1 || '%'
         `,
         ['ko'],
       );
@@ -360,7 +360,7 @@ describe('operators', () => {
         }).toSql(),
         `
           SELECT * FROM "user"
-          WHERE "user"."name" LIKE (SELECT "user"."name" FROM "user" LIMIT $1) || '%'
+          WHERE "user"."name" ILIKE (SELECT "user"."name" FROM "user" LIMIT $1) || '%'
         `,
         [1],
       );
@@ -371,19 +371,19 @@ describe('operators', () => {
         User.where({ name: { startsWith: db.raw("'ko'") } }).toSql(),
         `
           SELECT * FROM "user"
-          WHERE "user"."name" LIKE 'ko' || '%'
+          WHERE "user"."name" ILIKE 'ko' || '%'
         `,
       );
     });
   });
 
-  describe('startsWithInsensitive', () => {
+  describe('startsWithSensitive', () => {
     it('should handle value', () => {
       expectSql(
-        User.where({ name: { startsWithInsensitive: 'ko' } }).toSql(),
+        User.where({ name: { startsWithSensitive: 'ko' } }).toSql(),
         `
           SELECT * FROM "user"
-          WHERE "user"."name" ILIKE $1 || '%'
+          WHERE "user"."name" LIKE $1 || '%'
         `,
         ['ko'],
       );
@@ -392,11 +392,11 @@ describe('operators', () => {
     it('should handle sub query', () => {
       expectSql(
         User.where({
-          name: { startsWithInsensitive: User.select('name').take() },
+          name: { startsWithSensitive: User.select('name').take() },
         }).toSql(),
         `
           SELECT * FROM "user"
-          WHERE "user"."name" ILIKE (SELECT "user"."name" FROM "user" LIMIT $1) || '%'
+          WHERE "user"."name" LIKE (SELECT "user"."name" FROM "user" LIMIT $1) || '%'
         `,
         [1],
       );
@@ -404,10 +404,10 @@ describe('operators', () => {
 
     it('should handle raw query', () => {
       expectSql(
-        User.where({ name: { startsWithInsensitive: db.raw("'ko'") } }).toSql(),
+        User.where({ name: { startsWithSensitive: db.raw("'ko'") } }).toSql(),
         `
           SELECT * FROM "user"
-          WHERE "user"."name" ILIKE 'ko' || '%'
+          WHERE "user"."name" LIKE 'ko' || '%'
         `,
       );
     });
@@ -419,7 +419,7 @@ describe('operators', () => {
         User.where({ name: { endsWith: 'ko' } }).toSql(),
         `
           SELECT * FROM "user"
-          WHERE "user"."name" LIKE '%' || $1
+          WHERE "user"."name" ILIKE '%' || $1
         `,
         ['ko'],
       );
@@ -432,7 +432,7 @@ describe('operators', () => {
         }).toSql(),
         `
           SELECT * FROM "user"
-          WHERE "user"."name" LIKE '%' || (SELECT "user"."name" FROM "user" LIMIT $1)
+          WHERE "user"."name" ILIKE '%' || (SELECT "user"."name" FROM "user" LIMIT $1)
         `,
         [1],
       );
@@ -443,19 +443,19 @@ describe('operators', () => {
         User.where({ name: { endsWith: db.raw("'ko'") } }).toSql(),
         `
           SELECT * FROM "user"
-          WHERE "user"."name" LIKE '%' || 'ko'
+          WHERE "user"."name" ILIKE '%' || 'ko'
         `,
       );
     });
   });
 
-  describe('endsWithInsensitive', () => {
+  describe('endsWithSensitive', () => {
     it('should handle value', () => {
       expectSql(
-        User.where({ name: { endsWithInsensitive: 'ko' } }).toSql(),
+        User.where({ name: { endsWithSensitive: 'ko' } }).toSql(),
         `
           SELECT * FROM "user"
-          WHERE "user"."name" ILIKE '%' || $1
+          WHERE "user"."name" LIKE '%' || $1
         `,
         ['ko'],
       );
@@ -464,11 +464,11 @@ describe('operators', () => {
     it('should handle sub query', () => {
       expectSql(
         User.where({
-          name: { endsWithInsensitive: User.select('name').take() },
+          name: { endsWithSensitive: User.select('name').take() },
         }).toSql(),
         `
           SELECT * FROM "user"
-          WHERE "user"."name" ILIKE '%' || (SELECT "user"."name" FROM "user" LIMIT $1)
+          WHERE "user"."name" LIKE '%' || (SELECT "user"."name" FROM "user" LIMIT $1)
         `,
         [1],
       );
@@ -476,10 +476,10 @@ describe('operators', () => {
 
     it('should handle raw query', () => {
       expectSql(
-        User.where({ name: { endsWithInsensitive: db.raw("'ko'") } }).toSql(),
+        User.where({ name: { endsWithSensitive: db.raw("'ko'") } }).toSql(),
         `
           SELECT * FROM "user"
-          WHERE "user"."name" ILIKE '%' || 'ko'
+          WHERE "user"."name" LIKE '%' || 'ko'
         `,
       );
     });

package/src/columnsOperators.ts

@@ -77,31 +77,31 @@ const all = {
   contains: <T>() =>
     createOperator<T | Query | RawExpression>(
       (key, value, values) =>
-        `${key} LIKE '%' || ${quoteValue(value, values)} || '%'`,
+        `${key} ILIKE '%' || ${quoteValue(value, values)} || '%'`,
     ),
-  containsInsensitive: <T>() =>
+  containsSensitive: <T>() =>
     createOperator<T | Query | RawExpression>(
       (key, value, values) =>
-        `${key} ILIKE '%' || ${quoteValue(value, values)} || '%'`,
+        `${key} LIKE '%' || ${quoteValue(value, values)} || '%'`,
     ),
   startsWith: <T>() =>
-    createOperator<T | Query | RawExpression>(
-      (key, value, values) => `${key} LIKE ${quoteValue(value, values)} || '%'`,
-    ),
-  startsWithInsensitive: <T>() =>
     createOperator<T | Query | RawExpression>(
       (key, value, values) =>
         `${key} ILIKE ${quoteValue(value, values)} || '%'`,
     ),
-  endsWith: <T>() =>
+  startsWithSensitive: <T>() =>
     createOperator<T | Query | RawExpression>(
-      (key, value, values) => `${key} LIKE '%' || ${quoteValue(value, values)}`,
+      (key, value, values) => `${key} LIKE ${quoteValue(value, values)} || '%'`,
     ),
-  endsWithInsensitive: <T>() =>
+  endsWith: <T>() =>
     createOperator<T | Query | RawExpression>(
       (key, value, values) =>
         `${key} ILIKE '%' || ${quoteValue(value, values)}`,
     ),
+  endsWithSensitive: <T>() =>
+    createOperator<T | Query | RawExpression>(
+      (key, value, values) => `${key} LIKE '%' || ${quoteValue(value, values)}`,
+    ),
   between: <T>() =>
     createOperator<[T | Query | RawExpression, T | Query | RawExpression]>(
       (key, [from, to], values) =>
@@ -148,11 +148,11 @@ const numeric = <T>() => ({
 const text = <T>() => ({
   ...base<T>(),
   contains: all.contains<T>(),
-  containsInsensitive: all.containsInsensitive<T>(),
+  containsSensitive: all.containsSensitive<T>(),
   startsWith: all.startsWith<T>(),
-  startsWithInsensitive: all.startsWithInsensitive<T>(),
+  startsWithSensitive: all.startsWithSensitive<T>(),
   endsWith: all.endsWith<T>(),
-  endsWithInsensitive: all.endsWithInsensitive<T>(),
+  endsWithSensitive: all.endsWithSensitive<T>(),
 });
 
 const json = <T>() => ({

package/src/queryMethods/delete.test.ts

@@ -12,13 +12,13 @@ import { DeleteQueryData } from '../sql';
 describe('delete', () => {
   useTestDatabase();
 
-  it('should throw when updating without where condition', () => {
+  it('should prevent deleting all with TS error', () => {
     // @ts-expect-error update should have where condition or forceAll flag
-    expect(() => User.delete()).toThrow();
+    User.delete();
   });
 
-  it('should run without where condition when forceAll flag provided', async () => {
-    await expect(User.delete(true)).resolves.not.toThrow();
+  it('should allow deleting all with empty where', () => {
+    User.where().delete();
   });
 
   it('should be aliased as `del`', () => {

package/src/queryMethods/delete.ts

@@ -2,29 +2,17 @@ import { Query, SetQueryReturnsRowCount } from '../query';
 
 export type DeleteMethodsNames = 'del' | '_del' | 'delete' | '_delete';
 
-type DeleteArgs<T extends Query> = T['hasWhere'] extends true
-  ? [forceAll?: boolean]
-  : [true];
+type DeleteArgs<T extends Query> = T['hasWhere'] extends true ? [] : [never];
 
 type DeleteResult<T extends Query> = T['hasSelect'] extends true
   ? T
   : SetQueryReturnsRowCount<T>;
 
-const del = <T extends Query>(
-  self: T,
-  ...args: DeleteArgs<T>
-): DeleteResult<T> => {
-  return self.clone()._del(...args) as unknown as DeleteResult<T>;
+const del = <T extends Query>(self: T): DeleteResult<T> => {
+  return _del(self.clone()) as unknown as DeleteResult<T>;
 };
 
-const _del = <T extends Query>(
-  q: T,
-  ...args: DeleteArgs<T>
-): DeleteResult<T> => {
-  if (!q.query.and?.length && !q.query.or?.length && !args[0]) {
-    throw new Error('No where conditions or forceAll flag provided to delete');
-  }
-
+const _del = <T extends Query>(q: T): DeleteResult<T> => {
   if (!q.query.select) {
     q.query.returnType = 'rowCount';
   }
@@ -34,19 +22,23 @@ const _del = <T extends Query>(
 };
 
 export class Delete {
-  del<T extends Query>(this: T, ...args: DeleteArgs<T>): DeleteResult<T> {
-    return del(this, ...args);
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  del<T extends Query>(this: T, ..._args: DeleteArgs<T>): DeleteResult<T> {
+    return del(this);
   }
 
-  _del<T extends Query>(this: T, ...args: DeleteArgs<T>): DeleteResult<T> {
-    return _del(this, ...args);
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  _del<T extends Query>(this: T, ..._args: DeleteArgs<T>): DeleteResult<T> {
+    return _del(this);
   }
 
-  delete<T extends Query>(this: T, ...args: DeleteArgs<T>): DeleteResult<T> {
-    return del(this, ...args);
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  delete<T extends Query>(this: T, ..._args: DeleteArgs<T>): DeleteResult<T> {
+    return del(this);
   }
 
-  _delete<T extends Query>(this: T, ...args: DeleteArgs<T>): DeleteResult<T> {
-    return _del(this, ...args);
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  _delete<T extends Query>(this: T, ..._args: DeleteArgs<T>): DeleteResult<T> {
+    return _del(this);
   }
 }

package/src/queryMethods/update.test.ts

@@ -23,15 +23,13 @@ describe('update', () => {
     expectQueryNotMutated(q);
   });
 
-  it('should throw when updating without where condition', () => {
+  it('should prevent from updating without conditions with TS error', () => {
     // @ts-expect-error update should have where condition or forceAll flag
-    expect(() => User.update({ name: 'new name' })).toThrow();
+    User.update({ name: 'new name' });
   });
 
-  it('should run without where condition when forceAll flag provided', async () => {
-    await expect(
-      User.update({ name: 'new name' }, true),
-    ).resolves.not.toThrow();
+  it('should let update all with empty where', () => {
+    User.where().update({ name: 'new name' });
   });
 
   it('should update record with raw sql, returning updated rows count', async () => {

package/src/queryMethods/update.ts

@@ -98,17 +98,13 @@ type UpdateHasAndBelongsToManyData<Rel extends HasAndBelongsToManyRelation> = {
   create?: CreateData<Rel['nestedCreateQuery']>[];
 };
 
-type UpdateArgs<T extends Query, ForceAll extends boolean> = (
-  T['hasWhere'] extends true ? true : ForceAll
-) extends true
-  ? [update: UpdateData<T>]
-  : [update: UpdateData<T>, forceAll: true];
-
-type UpdateRawArgs<T extends Query, ForceAll extends boolean> = (
-  T['hasWhere'] extends true ? true : ForceAll
-) extends true
-  ? [update: RawExpression]
-  : [update: RawExpression, forceAll: true];
+type UpdateArg<T extends Query> = T['hasWhere'] extends true
+  ? UpdateData<T>
+  : never;
+
+type UpdateRawArg<T extends Query> = T['hasWhere'] extends true
+  ? RawExpression
+  : never;
 
 type UpdateResult<T extends Query> = T['hasSelect'] extends true
   ? T
@@ -143,14 +139,10 @@ const checkIfUpdateIsEmpty = (q: UpdateQueryData) => {
   return !q.updateData?.some((item) => isRaw(item) || Object.keys(item).length);
 };
 
-const update = <T extends Query>(q: T, forceAll: boolean): UpdateResult<T> => {
+const update = <T extends Query>(q: T): UpdateResult<T> => {
   const { query } = q;
   query.type = 'update';
 
-  if (!query.and?.length && !query.or?.length && !forceAll) {
-    throw new Error('No where conditions or forceAll flag provided to update');
-  }
-
   if (!query.select) {
     query.returnType = 'rowCount';
   }
@@ -159,22 +151,14 @@ const update = <T extends Query>(q: T, forceAll: boolean): UpdateResult<T> => {
 };
 
 export class Update {
-  update<T extends Query, ForceAll extends boolean = false>(
-    this: T,
-    ...args: UpdateArgs<T, ForceAll>
-  ): UpdateResult<T> {
+  update<T extends Query>(this: T, arg: UpdateArg<T>): UpdateResult<T> {
     const q = this.clone() as T;
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    return q._update(...(args as any));
+    return q._update(arg);
   }
-  _update<T extends Query, ForceAll extends boolean = false>(
-    this: T,
-    ...args: UpdateArgs<T, ForceAll>
-  ): UpdateResult<T> {
+  _update<T extends Query>(this: T, arg: UpdateArg<T>): UpdateResult<T> {
     const { query } = this;
-    const data = args[0];
 
-    const set: Record<string, unknown> = { ...data };
+    const set: Record<string, unknown> = { ...arg };
     pushQueryValue(this, 'updateData', set);
 
     const { relations, shape } = this as {
@@ -187,13 +171,13 @@ export class Update {
 
     const originalReturnType = query.returnType || 'all';
 
-    for (const key in data) {
+    for (const key in arg) {
       if (relations[key]) {
         delete set[key];
         if (relations[key].type === 'belongsTo') {
-          prependRelations[key] = data[key] as Record<string, unknown>;
+          prependRelations[key] = arg[key] as Record<string, unknown>;
         } else {
-          const value = data[key] as NestedUpdateItem;
+          const value = arg[key] as NestedUpdateItem;
 
           if (
             !value.set &&
@@ -217,7 +201,7 @@ export class Update {
               this._select(primaryKey as StringKey<keyof T['selectable']>);
             }
           }
-          appendRelations[key] = data[key] as Record<string, unknown>;
+          appendRelations[key] = arg[key] as Record<string, unknown>;
         }
       } else if (!shape[key] && shape !== anyShape) {
         delete set[key];
@@ -335,41 +319,26 @@ export class Update {
       query.wrapInTransaction = true;
     }
 
-    return update(this, (args as [unknown, boolean])[1]);
+    return update(this);
   }
 
-  updateRaw<T extends Query, ForceAll extends boolean = false>(
-    this: T,
-    ...args: UpdateRawArgs<T, ForceAll>
-  ): UpdateResult<T> {
+  updateRaw<T extends Query>(this: T, arg: UpdateRawArg<T>): UpdateResult<T> {
     const q = this.clone() as T;
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    return q._updateRaw(...(args as any));
+    return q._updateRaw(arg);
   }
-  _updateRaw<T extends Query, ForceAll extends boolean = false>(
-    this: T,
-    ...args: UpdateRawArgs<T, ForceAll>
-  ): UpdateResult<T> {
-    pushQueryValue(this, 'updateData', args[0]);
-    return update(this, (args as [unknown, boolean])[1]);
+  _updateRaw<T extends Query>(this: T, arg: UpdateRawArg<T>): UpdateResult<T> {
+    pushQueryValue(this, 'updateData', arg);
+    return update(this);
   }
 
-  updateOrThrow<T extends Query, ForceAll extends boolean = false>(
-    this: T,
-    ...args: UpdateArgs<T, ForceAll>
-  ): UpdateResult<T> {
+  updateOrThrow<T extends Query>(this: T, arg: UpdateArg<T>): UpdateResult<T> {
     const q = this.clone() as T;
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    return q._updateOrThrow(...(args as any));
+    return q._updateOrThrow(arg);
   }
 
-  _updateOrThrow<T extends Query, ForceAll extends boolean = false>(
-    this: T,
-    ...args: UpdateArgs<T, ForceAll>
-  ): UpdateResult<T> {
+  _updateOrThrow<T extends Query>(this: T, arg: UpdateArg<T>): UpdateResult<T> {
     this.query.throwOnNotFound = true;
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    return this._update(...(args as any)) as unknown as UpdateResult<T>;
+    return this._update(arg);
   }
 
   increment<T extends Query>(