pqb 0.3.0 → 0.3.2

package/src/sql/update.ts

@@ -1,10 +1,15 @@
 import { QueryBase } from '../query';
-import { UpdateQueryData } from './types';
+import {
+  UpdateQueryData,
+  UpdateQueryDataItem,
+  UpdateQueryDataObject,
+} from './types';
 import { addValue, q, quoteSchemaAndTable } from './common';
-import { getRaw, isRaw, RawExpression } from '../common';
+import { getRaw, isRaw } from '../common';
 import { pushReturningSql } from './insert';
 import { pushWhereStatementSql } from './where';
 import { ToSqlCtx } from './toSql';
+import { pushOrNewArray } from '../utils';
 
 export const pushUpdateSql = (
   ctx: ToSqlCtx,
@@ -22,8 +27,24 @@ export const pushUpdateSql = (
   ctx.sql.push('SET');
 
   const set: string[] = [];
-  query.data.forEach((item) => {
-    if (isRaw(item)) {
+  processData(ctx, set, query.updateData);
+  ctx.sql.push(set.join(', '));
+
+  pushWhereStatementSql(ctx, model, query, quotedAs);
+  pushReturningSql(ctx, model, query, quotedAs);
+};
+
+const processData = (
+  ctx: ToSqlCtx,
+  set: string[],
+  data: UpdateQueryDataItem[],
+) => {
+  let append: UpdateQueryDataItem[] | undefined;
+  data.forEach((item) => {
+    if (typeof item === 'function') {
+      const result = item(data);
+      if (result) append = pushOrNewArray(append, result);
+    } else if (isRaw(item)) {
       set.push(getRaw(item, ctx.values));
     } else {
       for (const key in item) {
@@ -34,16 +55,14 @@ export const pushUpdateSql = (
       }
     }
   });
-  ctx.sql.push(set.join(', '));
 
-  pushWhereStatementSql(ctx, model, query, quotedAs);
-  pushReturningSql(ctx, model, query, quotedAs);
+  if (append) processData(ctx, set, append);
 };
 
 const processValue = (
   values: unknown[],
   key: string,
-  value: Exclude<UpdateQueryData['data'][number], RawExpression>[string],
+  value: UpdateQueryDataObject[string],
 ) => {
   if (value && typeof value === 'object') {
     if (isRaw(value)) {

package/src/sql/where.ts

@@ -252,7 +252,7 @@ const pushIn = (
   } else if (isRaw(arg.values)) {
     value = getRaw(arg.values, values);
   } else {
-    const sql = arg.values.toSql(values);
+    const sql = arg.values.toSql({ values });
     value = `(${sql.text})`;
   }
 

package/src/sql/with.ts

@@ -14,7 +14,7 @@ export const pushWithSql = (
     if (isRaw(query)) {
       inner = getRaw(query, ctx.values);
     } else {
-      inner = query.toSql(ctx.values).text;
+      inner = query.toSql({ values: ctx.values }).text;
     }
 
     ctx.sql.push(

package/src/utils.test.ts

@@ -1,5 +1,15 @@
 import { assertType } from './test-utils';
-import { MaybeArray, SetOptional, SomeIsTrue } from './utils';
+import {
+  GetTypeOrRaw,
+  GetTypesOrRaw,
+  makeRegexToFindInSql,
+  MaybeArray,
+  pushOrNewArray,
+  pushOrNewArrayToObject,
+  SetOptional,
+  SomeIsTrue,
+} from './utils';
+import { RawExpression } from './common';
 
 describe('utils', () => {
   describe('SomeIsTrue', () => {
@@ -22,7 +32,7 @@ describe('utils', () => {
     });
   });
 
-  describe('setOptional', () => {
+  describe('SetOptional', () => {
     it('should make specified keys optional', () => {
       assertType<
         SetOptional<{ a: number; b: string; c: boolean }, 'b' | 'c'>,
@@ -34,4 +44,68 @@ describe('utils', () => {
       >();
     });
   });
+
+  describe('GetTypesOrRaw', () => {
+    it('should add each element to union with RawExpression', () => {
+      assertType<
+        GetTypesOrRaw<[number, string]>,
+        [number | RawExpression, string | RawExpression]
+      >();
+    });
+  });
+
+  describe('GetTypeOrRaw', () => {
+    it('should add type to union with RawExpression', () => {
+      assertType<GetTypeOrRaw<number>, number | RawExpression>();
+    });
+  });
+
+  describe('makeRegexToFindWordInSql', () => {
+    it('should return a proper regex', () => {
+      const regex = makeRegexToFindInSql('\\bupdatedAt\\b');
+
+      expect('koupdatedAtko'.match(regex)).toBe(null);
+      expect('updatedAtko'.match(regex)).toBe(null);
+      expect('koupdatedAt'.match(regex)).toBe(null);
+      expect('updatedAt'.match(regex)).toEqual(['updatedAt']);
+      expect(' updatedAt '.match(regex)).toEqual(['updatedAt']);
+      expect("'updatedAt'".match(regex)).toEqual(null);
+    });
+  });
+
+  describe('pushOrNewArrayToObject', () => {
+    it('should define new array with value when object has no array by provided key', () => {
+      const obj: { ko?: number[] } = {};
+
+      pushOrNewArrayToObject(obj, 'ko', 123);
+
+      expect(obj).toEqual({
+        ko: [123],
+      });
+    });
+
+    it('should push value to array when obj has array by provided key', () => {
+      const obj = { ko: [] as number[] };
+
+      pushOrNewArrayToObject(obj, 'ko', 123);
+
+      expect(obj).toEqual({
+        ko: [123],
+      });
+    });
+  });
+
+  describe('pushOrNewArray', () => {
+    it('should return new array with value when array is not provided', () => {
+      const arr: number[] | undefined = undefined;
+
+      expect(pushOrNewArray(arr, 123)).toEqual([123]);
+    });
+
+    it('should push value to array when array is provided', () => {
+      const arr: number[] | undefined = [];
+
+      expect(pushOrNewArray(arr, 123)).toEqual([123]);
+    });
+  });
 });

package/src/utils.ts

@@ -1,5 +1,5 @@
 import { RawExpression } from './common';
-import { QueryData } from './sql';
+import { QueryData, toSqlCacheKey } from './sql';
 
 export type SomeIsTrue<T extends unknown[]> = T extends [
   infer Head,
@@ -124,7 +124,7 @@ export const joinTruthy = (...strings: (string | false | undefined)[]) => {
 };
 
 export const getClonedQueryData = (query: QueryData): QueryData => {
-  const cloned = { ...query };
+  const cloned = { ...query, [toSqlCacheKey]: undefined };
 
   for (const key in query) {
     if (Array.isArray(query[key as keyof QueryData])) {
@@ -150,3 +150,33 @@ export const noop = () => {};
 
 export type EmptyObject = typeof emptyObject;
 export const emptyObject = {};
+
+export const makeRegexToFindInSql = (value: string) => {
+  return new RegExp(`${value}(?=(?:[^']*'[^']*')*[^']*$)`, 'g');
+};
+
+export const pushOrNewArrayToObject = <
+  Obj extends EmptyObject,
+  Key extends keyof Obj,
+>(
+  obj: Obj,
+  key: Key,
+  value: Exclude<Obj[Key], undefined> extends unknown[]
+    ? Exclude<Obj[Key], undefined>[number]
+    : never,
+) => {
+  if (obj[key]) (obj[key] as unknown as unknown[]).push(value);
+  else (obj[key] as unknown as unknown[]) = [value];
+};
+
+export const pushOrNewArray = <Arr extends unknown[]>(
+  arr: Arr | undefined,
+  value: Arr[number],
+): Arr => {
+  if (arr) {
+    arr.push(value);
+    return arr;
+  } else {
+    return [value] as Arr;
+  }
+};