pqb 0.3.0 → 0.3.2

package/package.json

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

package/src/columnSchema/columnType.ts

@@ -3,6 +3,7 @@ import { JSONTypeAny } from './json/typeBase';
 import { ColumnsShape } from './columnsSchema';
 import { RawExpression, StringKey } from '../common';
 import { MaybeArray } from '../utils';
+import { Query } from '../query';
 
 export type ColumnOutput<T extends ColumnType> = T['type'];
 
@@ -44,6 +45,7 @@ export type ColumnData = {
   collate?: string;
   compression?: string;
   foreignKey?: ForeignKey<string, string[]>;
+  modifyQuery?: (q: Query) => void;
 };
 
 type ForeignKeyMatch = 'FULL' | 'PARTIAL' | 'SIMPLE';
@@ -109,6 +111,16 @@ export type ForeignKeyModelWithColumns = new () => {
 export type ColumnNameOfModel<Model extends ForeignKeyModelWithColumns> =
   StringKey<keyof InstanceType<Model>['columns']['shape']>;
 
+const addColumnData = <T extends ColumnType, K extends keyof ColumnData>(
+  q: T,
+  key: K,
+  value: T['data'][K],
+): T => {
+  const cloned = Object.create(q);
+  cloned.data = { ...q.data, [key]: value };
+  return cloned;
+};
+
 export abstract class ColumnType<
   Type = unknown,
   Ops extends Operators = Operators,
@@ -217,51 +229,43 @@ export abstract class ColumnType<
     this: T,
     value: T['type'] | RawExpression,
   ): T & { hasDefault: true } {
-    const cloned = Object.create(this);
-    cloned.data = { ...cloned.data, default: value };
-    return cloned;
+    return addColumnData(this, 'default', value as unknown) as T & {
+      hasDefault: true;
+    };
   }
 
   index<T extends ColumnType>(
     this: T,
     options: Omit<SingleColumnIndexOptions, 'column'> = {},
   ): T {
-    const cloned = Object.create(this);
-    cloned.data = { ...cloned.data, index: options };
-    return cloned;
+    return addColumnData(this, 'index', options);
   }
 
   unique<T extends ColumnType>(
     this: T,
     options: Omit<SingleColumnIndexOptions, 'column' | 'unique'> = {},
   ): T {
-    const cloned = Object.create(this);
-    cloned.data = { ...cloned.data, index: { ...options, unique: true } };
-    return cloned;
+    return addColumnData(this, 'index', { ...options, unique: true });
   }
 
   comment<T extends ColumnType>(this: T, comment: string): T {
-    const cloned = Object.create(this);
-    cloned.data = { ...cloned.data, comment };
-    return cloned;
+    return addColumnData(this, 'comment', comment);
   }
 
   validationDefault<T extends ColumnType>(this: T, value: T['type']): T {
-    const cloned = Object.create(this);
-    cloned.data = { ...cloned.data, validationDefault: value };
-    return cloned;
+    return addColumnData(this, 'validationDefault', value as unknown);
   }
 
   compression<T extends ColumnType>(this: T, compression: string): T {
-    const cloned = Object.create(this);
-    cloned.data = { ...cloned.data, compression };
-    return cloned;
+    return addColumnData(this, 'compression', compression);
   }
 
   collate<T extends ColumnType>(this: T, collate: string): T {
-    const cloned = Object.create(this);
-    cloned.data = { ...cloned.data, collate };
-    return cloned;
+    return addColumnData(this, 'collate', collate);
+  }
+
+  modifyQuery<T extends ColumnType>(this: T, cb: (q: Query) => void): T {
+    return addColumnData(this, 'modifyQuery', cb);
   }
 
   transform<T extends ColumnType, Transformed>(

package/src/columnSchema/columnTypes.ts

@@ -58,7 +58,7 @@ import {
 } from './columnType';
 import { emptyObject, EmptyObject, MaybeArray, toArray } from '../utils';
 import { ColumnsShape } from './columnsSchema';
-import { raw } from '../common';
+import { timestamps } from './timestamps';
 
 export type ColumnTypes = typeof columnTypes;
 
@@ -177,17 +177,7 @@ export const columnTypes = {
   jsonText: () => new JSONTextColumn(),
   array: <Item extends ColumnType>(item: Item) => new ArrayColumn(item),
 
-  timestamps<T extends ColumnType>(this: {
-    timestamp(): T;
-  }): {
-    createdAt: T & { hasDefault: true };
-    updatedAt: T & { hasDefault: true };
-  } {
-    return {
-      createdAt: this.timestamp().default(raw('now()')),
-      updatedAt: this.timestamp().default(raw('now()')),
-    };
-  },
+  timestamps,
 
   primaryKey(columns: string[], options?: { name?: string }) {
     tableData.primaryKey = { columns, options };

package/src/columnSchema/timestamps.test.ts

@@ -0,0 +1,79 @@
+import { db, expectSql, now, useTestDatabase } from '../test-utils';
+import { raw } from '../common';
+
+describe('timestamps', () => {
+  useTestDatabase();
+
+  const model = db('user', (t) => ({
+    name: t.string(),
+    ...t.timestamps(),
+  }));
+
+  it('should update updatedAt column when updating', async () => {
+    const query = model.update({}, true);
+    await query;
+
+    expectSql(
+      query.toSql(),
+      `
+        UPDATE "user"
+        SET "updatedAt" = now()
+      `,
+    );
+  });
+
+  it('should not update updatedAt column when updating it via object', async () => {
+    const query = model.update({ updatedAt: now }, true);
+    await query;
+
+    expectSql(
+      query.toSql(),
+      `
+        UPDATE "user"
+        SET "updatedAt" = $1
+      `,
+      [now],
+    );
+  });
+
+  it('should update updatedAt when updating with raw sql', async () => {
+    const query = model.updateRaw(raw('name = $1', 'name'), true);
+    await query;
+
+    expectSql(
+      query.toSql(),
+      `
+        UPDATE "user"
+        SET name = $1, "updatedAt" = now()
+      `,
+      ['name'],
+    );
+  });
+
+  it('should update updatedAt when updating with raw sql which has updatedAt somewhere but not in set', async () => {
+    const query = model.updateRaw(raw('"createdAt" = "updatedAt"'), true);
+    await query;
+
+    expectSql(
+      query.toSql(),
+      `
+        UPDATE "user"
+        SET "createdAt" = "updatedAt", "updatedAt" = now()
+      `,
+    );
+  });
+
+  it('should not update updatedAt column when updating with raw sql which contains `updatedAt = `', async () => {
+    const query = model.updateRaw(raw('"updatedAt" = $1', now), true);
+    await query;
+
+    expectSql(
+      query.toSql(),
+      `
+        UPDATE "user"
+        SET "updatedAt" = $1
+      `,
+      [now],
+    );
+  });
+});

package/src/columnSchema/timestamps.ts

@@ -0,0 +1,49 @@
+import { ColumnType } from './columnType';
+import { getRawSql, isRaw, raw } from '../common';
+import { Query } from '../query';
+import { makeRegexToFindInSql, pushOrNewArrayToObject } from '../utils';
+import {
+  UpdatedAtDataInjector,
+  UpdateQueryData,
+  UpdateQueryDataItem,
+} from '../sql';
+
+export function timestamps<T extends ColumnType>(this: {
+  timestamp(): T;
+}): {
+  createdAt: T & { hasDefault: true };
+  updatedAt: T & { hasDefault: true };
+} {
+  return {
+    createdAt: this.timestamp().default(raw('now()')),
+    updatedAt: this.timestamp()
+      .default(raw('now()'))
+      .modifyQuery(addHookForUpdate),
+  };
+}
+
+const updatedAtRegex = makeRegexToFindInSql('\\bupdatedAt\\b"?\\s*=');
+const updateUpdatedAtItem = raw('"updatedAt" = now()');
+
+const addHookForUpdate = (q: Query) => {
+  pushOrNewArrayToObject(
+    q.query as UpdateQueryData,
+    'updateData',
+    updatedAtInjector,
+  );
+};
+
+const updatedAtInjector: UpdatedAtDataInjector = (data) => {
+  return checkIfDataHasUpdatedAt(data) ? undefined : updateUpdatedAtItem;
+};
+
+const checkIfDataHasUpdatedAt = (data: UpdateQueryDataItem[]) => {
+  return data.some((item) => {
+    if (isRaw(item)) {
+      updatedAtRegex.lastIndex = 0;
+      return updatedAtRegex.test(getRawSql(item));
+    } else {
+      return typeof item !== 'function' && item.updatedAt;
+    }
+  });
+};

package/src/columnsOperators.ts

@@ -25,7 +25,7 @@ const quoteValue = (
     }
 
     if ('toSql' in arg) {
-      const sql = (arg as Query).toSql(values);
+      const sql = (arg as Query).toSql({ values });
       return `(${sql.text})`;
     }
 

package/src/common.ts

@@ -1,5 +1,5 @@
 import { Query, Selectable } from './query';
-import { ColumnOutput, ColumnType } from './columnSchema';
+import { ColumnOutput, ColumnType } from './columnSchema/columnType';
 
 export type AliasOrTable<T extends Pick<Query, 'tableAlias' | 'table'>> =
   T['tableAlias'] extends string
@@ -81,6 +81,10 @@ export const getRaw = (raw: RawExpression, values: unknown[]) => {
   return raw.__raw;
 };
 
+export const getRawSql = (raw: RawExpression) => {
+  return raw.__raw;
+};
+
 export const EMPTY_OBJECT = {};
 
 export const getQueryParsers = (q: Query) => {

package/src/db.ts

@@ -4,8 +4,16 @@ import {
   defaultsKey,
   Query,
 } from './query';
-import { QueryMethods } from './queryMethods/queryMethods';
-import { QueryData, SelectQueryData, Sql } from './sql';
+import {
+  QueryMethods,
+  handleResult,
+  ThenResult,
+  WhereQueryBuilder,
+  OnQueryBuilder,
+  logParamToLogObject,
+  QueryLogOptions,
+} from './queryMethods';
+import { QueryData, SelectQueryData, Sql, ToSqlOptions } from './sql';
 import { AdapterOptions, Adapter } from './adapter';
 import {
   ColumnsShape,
@@ -17,12 +25,8 @@ import {
   ColumnTypesBase,
   getColumnTypes,
 } from './columnSchema';
-import { applyMixins } from './utils';
+import { applyMixins, pushOrNewArray } from './utils';
 import { StringKey } from './common';
-import { handleResult, ThenResult } from './queryMethods/then';
-import { WhereQueryBuilder } from './queryMethods/where';
-import { OnQueryBuilder } from './queryMethods/join';
-import { logParamToLogObject, QueryLogOptions } from './queryMethods/log';
 
 export type DbTableOptions = {
   schema?: string;
@@ -128,26 +132,33 @@ export class Db<
 
     const columnsParsers = {} as ColumnsParsers;
     let hasParsers = false;
+    let modifyQuery: ((q: Query) => void)[] | undefined;
     for (const key in shape) {
       const column = shape[key];
       if (column.parseFn) {
         hasParsers = true;
         columnsParsers[key] = column.parseFn;
       }
+
+      if (column.data.modifyQuery) {
+        modifyQuery = pushOrNewArray(modifyQuery, column.data.modifyQuery);
+      }
     }
     this.columnsParsers = hasParsers ? columnsParsers : undefined;
 
     this.toSql = defaultSelect
-      ? function <T extends Query>(this: T, values?: unknown[]): Sql {
+      ? function <T extends Query>(this: T, options?: ToSqlOptions): Sql {
           const q = this.clone();
           if (!(q.query as SelectQueryData).select) {
             (q.query as SelectQueryData).select = defaultSelect as string[];
           }
-          return toSql.call(q, values);
+          return toSql.call(q, options);
         }
       : toSql;
 
     this.relations = {} as Relations;
+
+    modifyQuery?.forEach((cb) => cb(this));
   }
 }
 

package/src/queryDataUtils.ts

@@ -1,5 +1,6 @@
 import { Query } from './query';
 import { QueryData } from './sql';
+import { pushOrNewArrayToObject } from './utils';
 
 // TODO: remove
 export const removeFromQuery = <T extends Query>(q: T, key: string): T => {
@@ -26,10 +27,12 @@ export const pushQueryValue = <T extends { query: QueryData }>(
   key: string,
   value: unknown,
 ): T => {
-  if (!q.query[key as keyof typeof q.query])
-    (q.query as Record<string, unknown>)[key] = [value];
-  else (q.query[key as keyof typeof q.query] as unknown[]).push(value);
-  return q as unknown as T;
+  pushOrNewArrayToObject(
+    q.query as unknown as Record<string, unknown[]>,
+    key,
+    value,
+  );
+  return q;
 };
 
 export const setQueryObjectValue = <T extends { query: QueryData }>(

package/src/queryMethods/aggregate.test.ts

@@ -351,7 +351,7 @@ describe('aggregate', () => {
       expectQueryNotMutated(q);
 
       q[`_${method}` as `_count`]('name');
-      expectSql(q.toSql(), expectedSql);
+      expectSql(q.toSql({ clearCache: true }), expectedSql);
     });
 
     it('should support raw sql parameter', () => {
@@ -449,7 +449,7 @@ describe('aggregate', () => {
       expectQueryNotMutated(q);
 
       q[`_${method}` as '_jsonObjectAgg']({ alias: 'name' });
-      expectSql(q.toSql(), expectedSql, ['alias']);
+      expectSql(q.toSql({ clearCache: true }), expectedSql, ['alias']);
     });
 
     it('should support raw sql parameter', () => {
@@ -545,7 +545,7 @@ describe('aggregate', () => {
       expectQueryNotMutated(q);
 
       q._stringAgg('name', ' & ');
-      expectSql(q.toSql(), expectedSql, [' & ']);
+      expectSql(q.toSql({ clearCache: true }), expectedSql, [' & ']);
     });
 
     it('should support raw sql parameter', async () => {

package/src/queryMethods/callbacks.test.ts

@@ -66,4 +66,24 @@ describe('callbacks', () => {
       expect(fn.mock.calls[0]).toEqual([query, result]);
     });
   });
+
+  describe('beforeDelete', () => {
+    it('should run callback before delete', async () => {
+      const fn = jest.fn();
+      const query = User.beforeDelete(fn).where({ id: 1 }).delete();
+      await query;
+
+      expect(fn.mock.calls[0]).toEqual([query]);
+    });
+  });
+
+  describe('afterDelete', () => {
+    it('should run callback after delete', async () => {
+      const fn = jest.fn();
+      const query = User.afterDelete(fn).where({ id: 1 }).delete();
+      const result = await query;
+
+      expect(fn.mock.calls[0]).toEqual([query, result]);
+    });
+  });
 });

package/src/queryMethods/callbacks.ts

@@ -1,11 +1,11 @@
 import { Query } from '../query';
 import { pushQueryValue } from '../queryDataUtils';
 
-export type BeforeCallback<T extends Query> = (
+export type BeforeCallback<T extends Query = Query> = (
   query: T,
 ) => void | Promise<void>;
 
-export type AfterCallback<T extends Query> = (
+export type AfterCallback<T extends Query = Query> = (
   query: T,
   data: unknown,
 ) => void | Promise<void>;
@@ -52,4 +52,18 @@ export class QueryCallbacks {
   _afterUpdate<T extends Query>(this: T, cb: AfterCallback<T>): T {
     return pushQueryValue(this, 'afterUpdate', cb);
   }
+
+  beforeDelete<T extends Query>(this: T, cb: BeforeCallback<T>): T {
+    return this.clone()._beforeDelete(cb);
+  }
+  _beforeDelete<T extends Query>(this: T, cb: BeforeCallback<T>): T {
+    return pushQueryValue(this, 'beforeDelete', cb);
+  }
+
+  afterDelete<T extends Query>(this: T, cb: AfterCallback<T>): T {
+    return this.clone()._afterDelete(cb);
+  }
+  _afterDelete<T extends Query>(this: T, cb: AfterCallback<T>): T {
+    return pushQueryValue(this, 'afterDelete', cb);
+  }
 }

package/src/queryMethods/clear.test.ts

@@ -39,7 +39,7 @@ describe('clear', () => {
 
   it('should clear increment and decrement', () => {
     const expectedSql = line(`
-      UPDATE "user" SET "name" = $1
+      UPDATE "user" SET "name" = $1, "updatedAt" = now()
     `);
     const expectedValues = ['new name'];
 

package/src/queryMethods/clear.ts

@@ -28,8 +28,8 @@ export class Clear {
         removeFromQuery(this, 'or');
       } else if (clear === 'counters') {
         if ('type' in this.query && this.query.type === 'update') {
-          this.query.data = this.query.data.filter((item) => {
-            if (!isRaw(item)) {
+          this.query.updateData = this.query.updateData.filter((item) => {
+            if (!isRaw(item) && typeof item !== 'function') {
               let removed = false;
               for (const key in item) {
                 const value = item[key] as Record<string, unknown>;

package/src/queryMethods/having.test.ts

@@ -202,7 +202,7 @@ describe('having', () => {
     expectQueryNotMutated(q);
 
     q._having(raw('count(*) = 1'), raw('sum(id) = 2'));
-    expectSql(q.toSql(), expectedSql);
+    expectSql(q.toSql({ clearCache: true }), expectedSql);
   });
 
   describe('havingOr', () => {

package/src/queryMethods/queryMethods.test.ts

@@ -480,7 +480,7 @@ describe('queryMethods', () => {
       expectQueryNotMutated(q);
 
       q._group(raw('id'), raw('name'));
-      expectSql(q.toSql(), expectedSql);
+      expectSql(q.toSql({ clearCache: true }), expectedSql);
     });
   });
 

package/src/queryMethods/queryMethods.ts

@@ -25,6 +25,7 @@ import {
   SortDir,
   Sql,
   toSql,
+  ToSqlOptions,
   TruncateQueryData,
 } from '../sql';
 import {
@@ -182,8 +183,8 @@ export class QueryMethods {
     return cloned;
   }
 
-  toSql(this: Query, values?: unknown[]): Sql {
-    return toSql(this, values);
+  toSql(this: Query, options?: ToSqlOptions): Sql {
+    return toSql(this, options);
   }
 
   distinct<T extends Query>(this: T, ...columns: Expression<T>[]): T {

package/src/queryMethods/then.ts

@@ -63,22 +63,23 @@ const then = async (
   let sql: Sql | undefined;
   let logData: unknown | undefined;
   try {
-    let beforeCallbacks: BeforeCallback<Query>[] | undefined;
-    let afterCallbacks: AfterCallback<Query>[] | undefined;
+    let beforeCallbacks: BeforeCallback[] | undefined;
+    let afterCallbacks: AfterCallback[] | undefined;
     if (q.query.type === 'insert') {
       beforeCallbacks = q.query.beforeInsert;
       afterCallbacks = q.query.afterInsert;
     } else if (q.query.type === 'update') {
       beforeCallbacks = q.query.beforeUpdate;
       afterCallbacks = q.query.afterUpdate;
+    } else if (q.query.type === 'delete') {
+      beforeCallbacks = q.query.beforeDelete;
+      afterCallbacks = q.query.afterDelete;
     }
 
-    if (beforeCallbacks) {
-      await Promise.all(beforeCallbacks.map((cb) => cb(q)));
-    }
-
-    if (q.query.beforeQuery) {
-      await Promise.all(q.query.beforeQuery.map((cb) => cb(q)));
+    if (beforeCallbacks || q.query.beforeQuery) {
+      await Promise.all(
+        getCallbacks(beforeCallbacks, q.query.beforeQuery).map((cb) => cb(q)),
+      );
     }
 
     sql = q.toSql();
@@ -99,14 +100,12 @@ const then = async (
 
     const result = await q.query.handleResult(q, queryResult);
 
-    if (afterCallbacks?.length || q.query.afterQuery?.length) {
-      if (q.query.afterQuery?.length) {
-        await Promise.all(q.query.afterQuery.map((query) => query(q, result)));
-      }
-
-      if (afterCallbacks?.length) {
-        await Promise.all(afterCallbacks.map((query) => query(q, result)));
-      }
+    if (afterCallbacks || q.query.afterQuery) {
+      await Promise.all(
+        getCallbacks(q.query.afterQuery, afterCallbacks).map((query) =>
+          query(q, result),
+        ),
+      );
     }
 
     resolve?.(result);
@@ -224,3 +223,12 @@ const parseValue = (value: unknown, query: Query) => {
   }
   return value;
 };
+
+const getCallbacks = <T extends BeforeCallback[] | AfterCallback[]>(
+  first?: T,
+  second?: T,
+): T => {
+  return (
+    first && second ? [...first, ...second] : first ? first : second
+  ) as T;
+};

package/src/queryMethods/union.test.ts

@@ -45,7 +45,7 @@ import { raw } from '../common';
       );
       q[`_${what}All` as '_unionAll']([raw('SELECT 2')], true);
       expectSql(
-        q.toSql(),
+        q.toSql({ clearCache: true }),
         `
         SELECT "user"."id" FROM "user"
         ${upper}