pqb 0.3.0 → 0.3.2

package/src/queryMethods/update.test.ts

@@ -37,12 +37,12 @@ describe('update', () => {
     const count = 2;
     const users = await User.select('id').insertMany([userData, userData]);
 
-    const query = User.or(...users).update(raw(`name = 'name'`));
+    const query = User.or(...users).updateRaw(raw(`name = 'name'`));
     expectSql(
       query.toSql(),
       `
         UPDATE "user"
-        SET name = 'name'
+        SET name = 'name', "updatedAt" = now()
         WHERE "user"."id" = $1 OR "user"."id" = $2
       `,
       [users[0].id, users[1].id],
@@ -69,7 +69,8 @@ describe('update', () => {
       `
         UPDATE "user"
         SET "name" = $1,
-            "password" = $2
+            "password" = $2,
+            "updatedAt" = now()
         WHERE "user"."id" = $3
       `,
       [update.name, update.password, id],
@@ -99,7 +100,8 @@ describe('update', () => {
       `
         UPDATE "user"
         SET "name" = $1,
-            "password" = $2
+            "password" = $2,
+            "updatedAt" = now()
         WHERE "user"."id" = $3
         RETURNING "user"."id"
       `,
@@ -126,7 +128,8 @@ describe('update', () => {
       `
         UPDATE "user"
         SET "name" = $1,
-            "password" = $2
+            "password" = $2,
+            "updatedAt" = now()
         WHERE "user"."id" = $3
         RETURNING "user"."id", "user"."name"
       `,
@@ -151,7 +154,8 @@ describe('update', () => {
       `
         UPDATE "user"
         SET "name" = $1,
-            "password" = $2
+            "password" = $2,
+            "updatedAt" = now()
         WHERE "user"."id" = $3
         RETURNING *
       `,
@@ -183,7 +187,8 @@ describe('update', () => {
       `
         UPDATE "user"
         SET "name" = $1,
-            "password" = $2
+            "password" = $2,
+            "updatedAt" = now()
         WHERE "user"."id" IN ($3, $4)
         RETURNING "user"."id", "user"."name"
       `,
@@ -215,7 +220,8 @@ describe('update', () => {
       `
         UPDATE "user"
         SET "name" = $1,
-            "password" = $2
+            "password" = $2,
+            "updatedAt" = now()
         WHERE "user"."id" IN ($3, $4)
         RETURNING *
       `,
@@ -243,7 +249,8 @@ describe('update', () => {
       `
         UPDATE "user"
         SET "name" = $1,
-            "data" = $2
+            "data" = $2,
+            "updatedAt" = now()
         WHERE "user"."id" = $3
       `,
       ['new name', null, 1],
@@ -261,7 +268,7 @@ describe('update', () => {
       query.toSql(),
       `
         UPDATE "user"
-        SET "name" = 'raw sql'
+        SET "name" = 'raw sql', "updatedAt" = now()
         WHERE "user"."id" = $1
       `,
       [1],
@@ -285,7 +292,8 @@ describe('update', () => {
       `
         UPDATE "user"
         SET "name" = $1,
-            "password" = $2
+            "password" = $2,
+            "updatedAt" = now()
         WHERE "user"."id" = $3
         RETURNING *
       `,
@@ -337,7 +345,8 @@ describe('update', () => {
         query.toSql(),
         `
           UPDATE "user"
-          SET "age" = "age" + $1
+          SET "age" = "age" + $1,
+              "updatedAt" = now()
         `,
         [1],
       );
@@ -349,7 +358,8 @@ describe('update', () => {
         query.toSql(),
         `
           UPDATE "user"
-          SET "age" = "age" + $1
+          SET "age" = "age" + $1,
+              "updatedAt" = now()
         `,
         [3],
       );
@@ -361,7 +371,8 @@ describe('update', () => {
         query.toSql(),
         `
           UPDATE "user"
-          SET "age" = "age" + $1
+          SET "age" = "age" + $1,
+              "updatedAt" = now()
           RETURNING "user"."id"
         `,
         [3],
@@ -379,7 +390,8 @@ describe('update', () => {
         query.toSql(),
         `
           UPDATE "user"
-          SET "age" = "age" - $1
+          SET "age" = "age" - $1,
+              "updatedAt" = now()
         `,
         [1],
       );
@@ -391,7 +403,8 @@ describe('update', () => {
         query.toSql(),
         `
           UPDATE "user"
-          SET "age" = "age" - $1
+          SET "age" = "age" - $1,
+              "updatedAt" = now()
         `,
         [3],
       );
@@ -403,7 +416,8 @@ describe('update', () => {
         query.toSql(),
         `
           UPDATE "user"
-          SET "age" = "age" - $1
+          SET "age" = "age" - $1,
+              "updatedAt" = now()
           RETURNING "user"."id"
         `,
         [3],
@@ -430,7 +444,8 @@ describe('update', () => {
           SET "name" = $1,
               "id" = "id" + $2,
               "password" = $3,
-              "age" = "age" - $4
+              "age" = "age" - $4,
+              "updatedAt" = now()
           WHERE "user"."id" = $5
           RETURNING "user"."id"
         `,

package/src/queryMethods/update.ts

@@ -31,7 +31,9 @@ export type UpdateData<T extends Query> = {
         ? UpdateHasAndBelongsToManyData<T['relations'][K]>
         : never;
     }
-  : EmptyObject);
+  : EmptyObject) & {
+    __raw?: never; // forbid RawExpression argument
+  };
 
 type UpdateBelongsToData<T extends Query, Rel extends BelongsToRelation> =
   | { disconnect: boolean }
@@ -96,8 +98,14 @@ type UpdateHasAndBelongsToManyData<Rel extends HasAndBelongsToManyRelation> = {
 type UpdateArgs<T extends Query, ForceAll extends boolean> = (
   T['hasWhere'] extends true ? true : ForceAll
 ) extends true
-  ? [update: RawExpression | UpdateData<T>, forceAll?: ForceAll]
-  : [update: RawExpression | UpdateData<T>, forceAll: 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 UpdateResult<T extends Query> = T['hasSelect'] extends false
   ? SetQueryReturnsRowCount<T>
@@ -124,12 +132,27 @@ const applyCountChange = <T extends Query>(
     map = { [data as string]: { op, arg: 1 } };
   }
 
-  pushQueryValue(self, 'data', map);
+  pushQueryValue(self, 'updateData', map);
   return self as unknown as UpdateResult<T>;
 };
 
 const checkIfUpdateIsEmpty = (q: UpdateQueryData) => {
-  return !q.data?.some((item) => isRaw(item) || Object.keys(item).length);
+  return !q.updateData?.some((item) => isRaw(item) || Object.keys(item).length);
+};
+
+const update = <T extends Query>(q: T, forceAll: boolean): 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';
+  }
+
+  return q as unknown as UpdateResult<T>;
 };
 
 export class Update {
@@ -141,161 +164,158 @@ export class Update {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     return q._update(...(args as any));
   }
-
   _update<T extends Query, ForceAll extends boolean = false>(
     this: T,
     ...args: UpdateArgs<T, ForceAll>
   ): UpdateResult<T> {
-    const [data, forceAll] = args as unknown as [
-      Record<string, unknown>,
-      boolean | undefined,
-    ];
     const { query } = this;
-    query.type = 'update';
+    const data = args[0];
 
-    if (!query.and?.length && !query.or?.length && !forceAll) {
-      throw new Error(
-        'No where conditions or forceAll flag provided to update',
-      );
-    }
+    const set: Record<string, unknown> = { ...data };
+    pushQueryValue(this, 'updateData', set);
+
+    const relations = this.relations as Record<string, Relation>;
+
+    const prependRelations: Record<string, Record<string, unknown>> = {};
+    const appendRelations: Record<string, Record<string, unknown>> = {};
+
+    const originalReturnType = query.returnType;
 
-    if (isRaw(data)) {
-      pushQueryValue(this, 'data', data);
-    } else {
-      const update: Record<string, unknown> = { ...data };
-      pushQueryValue(this, 'data', update);
-
-      const relations = this.relations as Record<string, Relation>;
-
-      const prependRelations: Record<string, Record<string, unknown>> = {};
-      const appendRelations: Record<string, Record<string, unknown>> = {};
-
-      const originalReturnType = this.query.returnType;
-
-      for (const key in data) {
-        if (relations[key]) {
-          delete update[key];
-          if (relations[key].type === 'belongsTo') {
-            prependRelations[key] = data[key] as Record<string, unknown>;
-          } else {
-            if (!query.select?.includes('*')) {
-              const primaryKey = relations[key].primaryKey;
-              if (!query.select?.includes(primaryKey)) {
-                this._select(primaryKey as StringKey<keyof T['selectable']>);
-              }
+    for (const key in data) {
+      if (relations[key]) {
+        delete set[key];
+        if (relations[key].type === 'belongsTo') {
+          prependRelations[key] = data[key] as Record<string, unknown>;
+        } else {
+          if (!query.select?.includes('*')) {
+            const primaryKey = relations[key].primaryKey;
+            if (!query.select?.includes(primaryKey)) {
+              this._select(primaryKey as StringKey<keyof T['selectable']>);
             }
-            appendRelations[key] = data[key] as Record<string, unknown>;
           }
+          appendRelations[key] = data[key] as Record<string, unknown>;
         }
       }
+    }
 
-      const state: {
-        updateLater?: Record<string, unknown>;
-        updateLaterPromises?: Promise<void>[];
-      } = {};
+    const state: {
+      updateLater?: Record<string, unknown>;
+      updateLaterPromises?: Promise<void>[];
+    } = {};
 
-      const prependRelationKeys = Object.keys(prependRelations);
-      let willSetKeys = false;
-      if (prependRelationKeys.length) {
-        willSetKeys = prependRelationKeys.some((relationName) => {
-          const data = prependRelations[relationName] as NestedUpdateOneItem;
+    const prependRelationKeys = Object.keys(prependRelations);
+    let willSetKeys = false;
+    if (prependRelationKeys.length) {
+      willSetKeys = prependRelationKeys.some((relationName) => {
+        const data = prependRelations[relationName] as NestedUpdateOneItem;
 
-          return (
-            relations[relationName] as {
-              nestedUpdate: BelongsToNestedUpdate;
-            }
-          ).nestedUpdate(this, update, data, state);
-        });
-      }
-
-      if (!willSetKeys && checkIfUpdateIsEmpty(this.query as UpdateQueryData)) {
-        delete this.query.type;
-      }
+        return (
+          relations[relationName] as {
+            nestedUpdate: BelongsToNestedUpdate;
+          }
+        ).nestedUpdate(this, set, data, state);
+      });
+    }
 
-      const appendRelationKeys = Object.keys(appendRelations);
+    if (!willSetKeys && checkIfUpdateIsEmpty(query as UpdateQueryData)) {
+      delete query.type;
+    }
 
-      let resultOfTypeAll: Record<string, unknown>[] | undefined;
+    const appendRelationKeys = Object.keys(appendRelations);
 
-      if (
-        state?.updateLater ||
-        (appendRelationKeys.length && originalReturnType !== 'all')
-      ) {
-        this.query.returnType = 'all';
+    let resultOfTypeAll: Record<string, unknown>[] | undefined;
 
-        if (state?.updateLater) {
-          this.schema.primaryKeys.forEach((key: string) => {
-            if (!query.select?.includes('*') && !query.select?.includes(key)) {
-              this._select(key as StringKey<keyof T['selectable']>);
-            }
-          });
-        }
+    if (
+      state?.updateLater ||
+      (appendRelationKeys.length && originalReturnType !== 'all')
+    ) {
+      query.returnType = 'all';
 
-        const { handleResult } = this.query;
-        this.query.handleResult = async (q, queryResult) => {
-          resultOfTypeAll = (await handleResult(q, queryResult)) as Record<
-            string,
-            unknown
-          >[];
-
-          if (state?.updateLater) {
-            await Promise.all(state.updateLaterPromises as Promise<void>[]);
-
-            const t = this.__model.clone().transacting(q);
-            const keys = this.schema.primaryKeys as string[];
-            (
-              t._whereIn as unknown as (
-                keys: string[],
-                values: unknown[][],
-              ) => Query
-            )(
-              keys,
-              resultOfTypeAll.map((item) => keys.map((key) => item[key])),
-            );
-
-            await (t as WhereResult<Query>)._update(state.updateLater);
-
-            resultOfTypeAll.forEach((item) =>
-              Object.assign(item, state.updateLater),
-            );
+      if (state?.updateLater) {
+        this.schema.primaryKeys.forEach((key: string) => {
+          if (!query.select?.includes('*') && !query.select?.includes(key)) {
+            this._select(key as StringKey<keyof T['selectable']>);
           }
+        });
+      }
 
-          if (queryMethodByReturnType[originalReturnType] === 'arrays') {
-            queryResult.rows.forEach(
-              (row, i) =>
-                ((queryResult.rows as unknown as unknown[][])[i] =
-                  Object.values(row)),
-            );
-          }
+      const { handleResult } = query;
+      query.handleResult = async (q, queryResult) => {
+        resultOfTypeAll = (await handleResult(q, queryResult)) as Record<
+          string,
+          unknown
+        >[];
 
-          return parseResult(q, originalReturnType, queryResult);
-        };
-      }
+        if (state?.updateLater) {
+          await Promise.all(state.updateLaterPromises as Promise<void>[]);
+
+          const t = this.__model.clone().transacting(q);
+          const keys = this.schema.primaryKeys as string[];
+          (
+            t._whereIn as unknown as (
+              keys: string[],
+              values: unknown[][],
+            ) => Query
+          )(
+            keys,
+            resultOfTypeAll.map((item) => keys.map((key) => item[key])),
+          );
+
+          await (t as WhereResult<Query>)._update(state.updateLater);
+
+          resultOfTypeAll.forEach((item) =>
+            Object.assign(item, state.updateLater),
+          );
+        }
 
-      if (appendRelationKeys.length) {
-        pushQueryArray(
-          this,
-          'afterQuery',
-          appendRelationKeys.map((relationName) => {
-            return (q: Query, result: Record<string, unknown>[]) => {
-              const all = resultOfTypeAll || result;
-              return (
-                relations[relationName].nestedUpdate as HasOneNestedUpdate
-              )?.(q, all, appendRelations[relationName] as NestedUpdateOneItem);
-            };
-          }),
-        );
-      }
+        if (queryMethodByReturnType[originalReturnType] === 'arrays') {
+          queryResult.rows.forEach(
+            (row, i) =>
+              ((queryResult.rows as unknown as unknown[][])[i] =
+                Object.values(row)),
+          );
+        }
 
-      if (prependRelationKeys.length || appendRelationKeys.length) {
-        query.wrapInTransaction = true;
-      }
+        return parseResult(q, originalReturnType, queryResult);
+      };
     }
 
-    if (!query.select) {
-      this.query.returnType = 'rowCount';
+    if (appendRelationKeys.length) {
+      pushQueryArray(
+        this,
+        'afterQuery',
+        appendRelationKeys.map((relationName) => {
+          return (q: Query, result: Record<string, unknown>[]) => {
+            const all = resultOfTypeAll || result;
+            return (
+              relations[relationName].nestedUpdate as HasOneNestedUpdate
+            )?.(q, all, appendRelations[relationName] as NestedUpdateOneItem);
+          };
+        }),
+      );
+    }
+
+    if (prependRelationKeys.length || appendRelationKeys.length) {
+      query.wrapInTransaction = true;
     }
 
-    return this as unknown as UpdateResult<T>;
+    return update(this, (args as [unknown, boolean])[1]);
+  }
+
+  updateRaw<T extends Query, ForceAll extends boolean = false>(
+    this: T,
+    ...args: UpdateRawArgs<T, ForceAll>
+  ): UpdateResult<T> {
+    const q = this.clone() as T;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return q._updateRaw(...(args as any));
+  }
+  _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]);
   }
 
   updateOrThrow<T extends Query, ForceAll extends boolean = false>(

package/src/queryMethods/window.test.ts

@@ -60,7 +60,7 @@ describe('window functions', () => {
         partitionBy: 'name',
         order: { createdAt: 'DESC' },
       });
-      expectSql(q.toSql(), expectedSql);
+      expectSql(q.toSql({ clearCache: true }), expectedSql);
     });
   });
 });

package/src/sql/fromAndAs.ts

@@ -33,7 +33,7 @@ const getFrom = (
       }
 
       if (!query.from.table) {
-        const sql = query.from.toSql(values);
+        const sql = query.from.toSql({ values });
         return `(${sql.text})`;
       }
 
@@ -41,7 +41,7 @@ const getFrom = (
       const keys = Object.keys(q) as (keyof SelectQueryData)[];
       // if query contains more than just schema return (SELECT ...)
       if (keys.some((key) => queryKeysOfNotSimpleQuery.includes(key))) {
-        const sql = query.from.toSql(values);
+        const sql = query.from.toSql({ values });
         return `(${sql.text})`;
       }
 

package/src/sql/select.ts

@@ -173,7 +173,7 @@ const pushSubQuerySql = (
       throw new UnhandledTypeError(returnType);
   }
 
-  let subQuerySql = `(${query.toSql(values).text})`;
+  let subQuerySql = `(${query.toSql({ values }).text})`;
   const { coalesceValue } = query.query;
   if (coalesceValue !== undefined) {
     const value =

package/src/sql/toSql.ts

@@ -25,7 +25,22 @@ export type ToSqlCtx = {
   values: unknown[];
 };
 
-export const toSql = (model: Query, values: unknown[] = []): Sql => {
+export type toSqlCacheKey = typeof toSqlCacheKey;
+export const toSqlCacheKey = Symbol('toSqlCache');
+
+export type ToSqlOptions = {
+  clearCache?: boolean;
+  values?: unknown[];
+};
+
+export const toSql = (model: Query, options?: ToSqlOptions): Sql => {
+  return (
+    (!options?.clearCache && model.query[toSqlCacheKey]) ||
+    (model.query[toSqlCacheKey] = makeSql(model, options))
+  );
+};
+
+const makeSql = (model: Query, { values = [] }: ToSqlOptions = {}): Sql => {
   const query = model.query;
   const sql: string[] = [];
   const ctx: ToSqlCtx = {
@@ -130,7 +145,7 @@ export const toSql = (model: Query, values: unknown[] = []): Sql => {
       if (isRaw(item.arg)) {
         itemSql = getRaw(item.arg, values);
       } else {
-        const argSql = item.arg.toSql(values);
+        const argSql = item.arg.toSql({ values });
         itemSql = argSql.text;
       }
       sql.push(`${item.kind} ${item.wrap ? `(${itemSql})` : itemSql}`);

package/src/sql/types.ts

@@ -13,6 +13,7 @@ import { Adapter, QueryResult } from '../adapter';
 import { MaybeArray } from '../utils';
 import { QueryLogger, QueryLogObject } from '../queryMethods/log';
 import { AfterCallback, BeforeCallback } from '../queryMethods/callbacks';
+import { toSqlCacheKey } from './toSql';
 
 export type Sql = {
   text: string;
@@ -63,10 +64,11 @@ export type CommonQueryData = {
   parsers?: ColumnsParsers;
   notFoundDefault?: unknown;
   defaults?: Record<string, unknown>;
-  beforeQuery?: BeforeCallback<Query>[];
-  afterQuery?: AfterCallback<Query>[];
+  beforeQuery?: BeforeCallback[];
+  afterQuery?: AfterCallback[];
   log?: QueryLogObject;
   logger: QueryLogger;
+  [toSqlCacheKey]?: Sql;
 };
 
 export type SelectQueryData = CommonQueryData & {
@@ -107,24 +109,37 @@ export type InsertQueryData = CommonQueryData & {
         expr?: OnConflictItem;
         update?: OnConflictMergeUpdate;
       };
-  beforeInsert?: BeforeCallback<Query>[];
-  afterInsert?: AfterCallback<Query>[];
+  beforeInsert?: BeforeCallback[];
+  afterInsert?: AfterCallback[];
 };
 
+export type UpdateQueryDataObject = Record<
+  string,
+  RawExpression | { op: string; arg: unknown } | unknown
+>;
+
+export type UpdatedAtDataInjector = (
+  data: UpdateQueryDataItem[],
+) => UpdateQueryDataItem | void;
+
+export type UpdateQueryDataItem =
+  | UpdateQueryDataObject
+  | RawExpression
+  | UpdatedAtDataInjector;
+
 export type UpdateQueryData = CommonQueryData & {
   type: 'update';
-  data: (
-    | Record<string, RawExpression | { op: string; arg: unknown } | unknown>
-    | RawExpression
-  )[];
-  beforeUpdate?: BeforeCallback<Query>[];
-  afterUpdate?: AfterCallback<Query>[];
+  updateData: UpdateQueryDataItem[];
+  beforeUpdate?: BeforeCallback[];
+  afterUpdate?: AfterCallback[];
 };
 
 export type DeleteQueryData = CommonQueryData & {
   type: 'delete';
   join?: JoinItem[];
   joinedParsers?: Record<string, ColumnsParsers>;
+  beforeDelete?: BeforeCallback[];
+  afterDelete?: AfterCallback[];
 };
 
 export type TruncateQueryData = CommonQueryData & {