pqb 0.5.0 → 0.5.2

package/package.json

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

package/src/columnSchema/columnType.test.ts

@@ -165,15 +165,18 @@ describe('column base', () => {
       columnTypes.timestamp().parse(Date.parse).as(columnTypes.integer());
     });
 
-    it('should return same column with overridden type', () => {
+    it('should return same column with `as` property in data', () => {
       const timestamp = columnTypes
         .timestamp()
         .encode((input: number) => new Date(input))
         .parse(Date.parse);
 
-      const column = timestamp.as(columnTypes.integer());
+      const integer = columnTypes.integer();
 
-      expect(column).toBe(timestamp);
+      const column = timestamp.as(integer);
+
+      expect(column.dataType).toBe(timestamp.dataType);
+      expect(column.data.as).toBe(integer);
     });
 
     it('should parse correctly', async () => {

package/src/queryMethods/create.ts

@@ -219,14 +219,23 @@ const processCreateItem = (
           item[key] as Record<string, unknown>,
         ]);
       } else {
+        const value = item[key] as NestedInsertItem;
+        if (
+          (!value.create ||
+            (Array.isArray(value.create) && value.create.length === 0)) &&
+          (!value.connect ||
+            (Array.isArray(value.connect) && value.connect.length === 0)) &&
+          (!value.connectOrCreate ||
+            (Array.isArray(value.connectOrCreate) &&
+              value.connectOrCreate.length === 0))
+        )
+          return;
+
         ctx.requiredReturning[ctx.relations[key].primaryKey] = true;
 
         if (!ctx.appendRelations[key]) ctx.appendRelations[key] = [];
 
-        ctx.appendRelations[key].push([
-          rowIndex,
-          item[key] as NestedInsertItem,
-        ]);
+        ctx.appendRelations[key].push([rowIndex, value]);
       }
     } else if (
       columnsMap[key] === undefined &&

package/src/queryMethods/json.ts

@@ -7,7 +7,7 @@ import {
 import { pushQueryValue } from '../queryDataUtils';
 import { ColumnType, StringColumn } from '../columnSchema';
 import { JsonItem } from '../sql';
-import { StringKey } from '../common';
+import { raw, StringKey } from '../common';
 
 type JsonColumnName<T extends Pick<Query, 'selectable'>> = StringKey<
   {
@@ -55,7 +55,7 @@ export class Json {
   ): SetQueryReturnsValueOptional<T, StringColumn> {
     const q = this._wrap(this.__model.clone()) as T;
     q._getOptional(
-      this.raw<Query, StringColumn>(
+      raw(
         queryTypeWithLimitOne[this.query.returnType]
           ? `row_to_json("t".*)`
           : `COALESCE(json_agg(row_to_json("t".*)), '[]')`,

package/src/queryMethods/queryMethods.ts

@@ -304,15 +304,9 @@ export class QueryMethods {
   _wrap<T extends Query, Q extends Query, As extends string = 't'>(
     this: T,
     query: Q,
-    as?: As,
+    as: As = 't' as As,
   ): SetQueryTableAlias<Q, As> {
-    const sql = this.toSql();
-
-    return query
-      .as(as ?? 't')
-      ._from(
-        this.raw(`(${sql.text})`, ...sql.values),
-      ) as unknown as SetQueryTableAlias<Q, As>;
+    return query.as(as)._from(this, as) as unknown as SetQueryTableAlias<Q, As>;
   }
 
   order<T extends Query>(this: T, ...args: OrderArg<T>[]): T {

package/src/queryMethods/select.test.ts

@@ -261,7 +261,7 @@ describe('selectMethods', () => {
           SELECT
             (
               SELECT COALESCE(json_agg(row_to_json("t".*)), '[]')
-              FROM (SELECT * FROM "user") AS "t"
+              FROM "user" AS "t"
             ) AS "subquery"
           FROM "user"
         `,

package/src/queryMethods/update.ts

@@ -8,6 +8,7 @@ import {
   HasManyRelation,
   HasOneNestedUpdate,
   HasOneRelation,
+  NestedUpdateItem,
   NestedUpdateOneItem,
   Relation,
 } from '../relations';
@@ -192,6 +193,24 @@ export class Update {
         if (relations[key].type === 'belongsTo') {
           prependRelations[key] = data[key] as Record<string, unknown>;
         } else {
+          const value = data[key] as NestedUpdateItem;
+
+          if (
+            !value.set &&
+            !('upsert' in value) &&
+            (!value.disconnect ||
+              (Array.isArray(value.disconnect) &&
+                value.disconnect.length === 0)) &&
+            (!value.delete ||
+              (Array.isArray(value.delete) && value.delete.length === 0)) &&
+            (!value.update ||
+              (Array.isArray(value.update.where) &&
+                value.update.where.length === 0)) &&
+            (!value.create ||
+              (Array.isArray(value.create) && value.create.length === 0))
+          )
+            continue;
+
           if (!query.select?.includes('*')) {
             const primaryKey = relations[key].primaryKey;
             if (!query.select?.includes(primaryKey)) {

package/src/sql/fromAndAs.ts

@@ -1,7 +1,7 @@
 import { quoteSchemaAndTable } from './common';
 import { QueryBase } from '../query';
 import { checkIfASimpleQuery, SelectQueryData } from './types';
-import { ToSqlCtx } from './toSql';
+import { makeSql, ToSqlCtx } from './toSql';
 import { getRaw, isRaw } from '../common';
 
 export const pushFromAndAs = (
@@ -33,14 +33,14 @@ const getFrom = (
       }
 
       if (!query.from.table) {
-        const sql = query.from.toSql({ values });
+        const sql = makeSql(query.from, { values });
         return `(${sql.text})`;
       }
 
       const q = query.from.query;
       // if query contains more than just schema return (SELECT ...)
       if (!checkIfASimpleQuery(q)) {
-        const sql = query.from.toSql({ values });
+        const sql = makeSql(query.from, { values });
         return `(${sql.text})`;
       }
 

package/src/sql/insert.ts

@@ -3,7 +3,7 @@ import { addValue, q } from './common';
 import { pushWhereStatementSql } from './where';
 import { QueryBase } from '../query';
 import { selectToSql } from './select';
-import { ToSqlCtx } from './toSql';
+import { makeSql, ToSqlCtx } from './toSql';
 import { pushQueryValue } from '../queryDataUtils';
 import { getRaw, isRaw, raw } from '../common';
 
@@ -26,7 +26,7 @@ export const pushInsertSql = (
       isRaw(query.values) ? query.values : raw(encodeRow(ctx, query.values[0])),
     );
 
-    ctx.sql.push(q.toSql({ values: ctx.values }).text);
+    ctx.sql.push(makeSql(q, { values: ctx.values }).text);
   } else {
     ctx.sql.push(
       `VALUES ${

package/src/sql/select.ts

@@ -10,7 +10,7 @@ import { addValue, q, quoteFullColumn } from './common';
 import { aggregateToSql } from './aggregate';
 import { PormInternalError, UnhandledTypeError } from '../errors';
 import { quote } from '../quote';
-import { ToSqlCtx } from './toSql';
+import { makeSql, ToSqlCtx } from './toSql';
 import { relationQueryKey } from '../relations';
 
 const jsonColumnOrMethodToSql = (
@@ -178,7 +178,7 @@ const pushSubQuerySql = (
       throw new UnhandledTypeError(returnType);
   }
 
-  let subQuerySql = `(${query.toSql({ values }).text})`;
+  let subQuerySql = `(${makeSql(query, { values }).text})`;
   const { coalesceValue } = query.query;
   if (coalesceValue !== undefined) {
     const value =

package/src/sql/toSql.ts

@@ -40,7 +40,10 @@ export const toSql = (model: Query, options?: ToSqlOptions): Sql => {
   );
 };
 
-const makeSql = (model: Query, { values = [] }: ToSqlOptions = {}): Sql => {
+export const makeSql = (
+  model: Query,
+  { values = [] }: ToSqlOptions = {},
+): Sql => {
   const query = model.query;
   const sql: string[] = [];
   const ctx: ToSqlCtx = {
@@ -145,7 +148,7 @@ const makeSql = (model: Query, { values = [] }: ToSqlOptions = {}): Sql => {
       if (isRaw(item.arg)) {
         itemSql = getRaw(item.arg, values);
       } else {
-        const argSql = item.arg.toSql({ values });
+        const argSql = makeSql(item.arg, { values });
         itemSql = argSql.text;
       }
       sql.push(`${item.kind} ${item.wrap ? `(${itemSql})` : itemSql}`);

package/src/sql/where.ts

@@ -11,7 +11,7 @@ import {
 import { addValue, q, qc, quoteFullColumn } from './common';
 import { getQueryAs, MaybeArray, toArray } from '../utils';
 import { processJoinItem } from './join';
-import { ToSqlCtx } from './toSql';
+import { makeSql, ToSqlCtx } from './toSql';
 import { getRaw, isRaw, RawExpression } from '../common';
 
 export const pushWhereStatementSql = (
@@ -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 = makeSql(arg.values, { values });
     value = `(${sql.text})`;
   }
 

package/src/sql/with.ts

@@ -1,6 +1,6 @@
 import { QueryData } from './types';
 import { q } from './common';
-import { ToSqlCtx } from './toSql';
+import { makeSql, ToSqlCtx } from './toSql';
 import { getRaw, isRaw } from '../common';
 
 export const pushWithSql = (
@@ -19,7 +19,7 @@ export const pushWithSql = (
         if (isRaw(query)) {
           inner = getRaw(query, ctx.values);
         } else {
-          inner = query.toSql({ values: ctx.values }).text;
+          inner = makeSql(query, { values: ctx.values }).text;
         }
 
         return `${options.recursive ? 'RECURSIVE ' : ''}${q(name)}${