pqb 0.4.5 → 0.4.7

package/src/queryMethods/where.test.ts

@@ -1,5 +1,4 @@
-import { expectSql, Message, User } from '../test-utils';
-import { raw } from '../common';
+import { db, expectSql, Message, User } from '../test-utils';
 import { Sql } from '../sql';
 import { Query } from '../query';
 import { pushQueryOn } from './join';
@@ -107,7 +106,7 @@ export const testWhere = (
 
     it('should handle condition with operator and raw', () => {
       expectSql(
-        buildSql((q) => q.where({ id: { in: raw('(1, 2, 3)') } })),
+        buildSql((q) => q.where({ id: { in: db.raw('(1, 2, 3)') } })),
         `
             ${startSql}
             "user"."id" IN (1, 2, 3)
@@ -117,7 +116,7 @@ export const testWhere = (
 
     it('should accept raw sql', () => {
       expectSql(
-        buildSql((q) => q.where({ id: raw('1 + 2') })),
+        buildSql((q) => q.where({ id: db.raw('1 + 2') })),
         `
             ${startSql} "user"."id" = 1 + 2
           `,
@@ -195,8 +194,10 @@ export const testWhere = (
     it('should handle condition with operator and raw', () => {
       expectSql(
         [
-          buildSql((q) => q.where({ NOT: { id: { in: raw('(1, 2, 3)') } } })),
-          buildSql((q) => q.whereNot({ id: { in: raw('(1, 2, 3)') } })),
+          buildSql((q) =>
+            q.where({ NOT: { id: { in: db.raw('(1, 2, 3)') } } }),
+          ),
+          buildSql((q) => q.whereNot({ id: { in: db.raw('(1, 2, 3)') } })),
         ],
         `
             ${startSql}
@@ -208,8 +209,8 @@ export const testWhere = (
     it('should accept raw sql', () => {
       expectSql(
         [
-          buildSql((q) => q.where({ NOT: { id: raw('1 + 2') } })),
-          buildSql((q) => q.whereNot({ id: raw('1 + 2') })),
+          buildSql((q) => q.where({ NOT: { id: db.raw('1 + 2') } })),
+          buildSql((q) => q.whereNot({ id: db.raw('1 + 2') })),
         ],
         `
             ${startSql} NOT "user"."id" = 1 + 2
@@ -284,9 +285,13 @@ export const testWhere = (
       expectSql(
         [
           buildSql((q) =>
-            q.where({ OR: [{ id: raw('1 + 2') }, { name: raw('2 + 3') }] }),
+            q.where({
+              OR: [{ id: db.raw('1 + 2') }, { name: db.raw('2 + 3') }],
+            }),
+          ),
+          buildSql((q) =>
+            q.or({ id: db.raw('1 + 2') }, { name: db.raw('2 + 3') }),
           ),
-          buildSql((q) => q.or({ id: raw('1 + 2') }, { name: raw('2 + 3') })),
         ],
         `
             ${startSql}
@@ -347,13 +352,13 @@ export const testWhere = (
           buildSql((q) =>
             q.where({
               OR: [
-                { NOT: { id: raw('1 + 2') } },
-                { NOT: { name: raw('2 + 3') } },
+                { NOT: { id: db.raw('1 + 2') } },
+                { NOT: { name: db.raw('2 + 3') } },
               ],
             }),
           ),
           buildSql((q) =>
-            q.orNot({ id: raw('1 + 2') }, { name: raw('2 + 3') }),
+            q.orNot({ id: db.raw('1 + 2') }, { name: db.raw('2 + 3') }),
           ),
         ],
         `
@@ -412,9 +417,9 @@ export const testWhere = (
       expectSql(
         [
           buildSql((q) =>
-            q.where({ IN: { columns: ['id'], values: raw('(1, 2, 3)') } }),
+            q.where({ IN: { columns: ['id'], values: db.raw('(1, 2, 3)') } }),
           ),
-          buildSql((q) => q.whereIn('id', raw('(1, 2, 3)'))),
+          buildSql((q) => q.whereIn('id', db.raw('(1, 2, 3)'))),
         ],
         `
             ${startSql}
@@ -427,15 +432,15 @@ export const testWhere = (
           buildSql((q) =>
             q.where({
               IN: [
-                { columns: ['id'], values: raw('(1, 2, 3)') },
-                { columns: ['name'], values: raw(`('a', 'b', 'c')`) },
+                { columns: ['id'], values: db.raw('(1, 2, 3)') },
+                { columns: ['name'], values: db.raw(`('a', 'b', 'c')`) },
               ],
             }),
           ),
           buildSql((q) =>
             q.whereIn({
-              id: raw('(1, 2, 3)'),
-              name: raw(`('a', 'b', 'c')`),
+              id: db.raw('(1, 2, 3)'),
+              name: db.raw(`('a', 'b', 'c')`),
             }),
           ),
         ],
@@ -526,12 +531,12 @@ export const testWhere = (
               q.where({
                 IN: {
                   columns: ['id', 'name'],
-                  values: raw(`((1, 'a'), (2, 'b'))`),
+                  values: db.raw(`((1, 'a'), (2, 'b'))`),
                 },
               }),
             ),
             buildSql((q) =>
-              q.whereIn(['id', 'name'], raw(`((1, 'a'), (2, 'b'))`)),
+              q.whereIn(['id', 'name'], db.raw(`((1, 'a'), (2, 'b'))`)),
             ),
           ],
           `
@@ -624,12 +629,12 @@ export const testWhere = (
             q.where({
               OR: [
                 { id: 1 },
-                { IN: { columns: ['id'], values: raw('(1, 2, 3)') } },
+                { IN: { columns: ['id'], values: db.raw('(1, 2, 3)') } },
               ],
             }),
           ),
           buildSql((q) =>
-            q.where({ id: 1 }).orWhereIn({ id: raw('(1, 2, 3)') }),
+            q.where({ id: 1 }).orWhereIn({ id: db.raw('(1, 2, 3)') }),
           ),
         ],
         `
@@ -647,8 +652,8 @@ export const testWhere = (
                 { id: 1 },
                 {
                   IN: [
-                    { columns: ['id'], values: raw('(1, 2, 3)') },
-                    { columns: ['name'], values: raw(`('a', 'b', 'c')`) },
+                    { columns: ['id'], values: db.raw('(1, 2, 3)') },
+                    { columns: ['name'], values: db.raw(`('a', 'b', 'c')`) },
                   ],
                 },
               ],
@@ -656,8 +661,8 @@ export const testWhere = (
           ),
           buildSql((q) =>
             q.where({ id: 1 }).orWhereIn({
-              id: raw('(1, 2, 3)'),
-              name: raw(`('a', 'b', 'c')`),
+              id: db.raw('(1, 2, 3)'),
+              name: db.raw(`('a', 'b', 'c')`),
             }),
           ),
         ],
@@ -775,7 +780,7 @@ export const testWhere = (
                   {
                     IN: {
                       columns: ['id', 'name'],
-                      values: raw(`((1, 'a'), (2, 'b'))`),
+                      values: db.raw(`((1, 'a'), (2, 'b'))`),
                     },
                   },
                 ],
@@ -784,7 +789,7 @@ export const testWhere = (
             buildSql((q) =>
               q
                 .where({ id: 1 })
-                .orWhereIn(['id', 'name'], raw(`((1, 'a'), (2, 'b'))`)),
+                .orWhereIn(['id', 'name'], db.raw(`((1, 'a'), (2, 'b'))`)),
             ),
           ],
           `
@@ -882,12 +887,12 @@ export const testWhere = (
         [
           buildSql((q) =>
             q.where({
-              NOT: { IN: { columns: ['id'], values: raw('(1, 2, 3)') } },
+              NOT: { IN: { columns: ['id'], values: db.raw('(1, 2, 3)') } },
             }),
           ),
           buildSql((q) =>
             q.whereNotIn({
-              id: raw('(1, 2, 3)'),
+              id: db.raw('(1, 2, 3)'),
             }),
           ),
         ],
@@ -903,16 +908,16 @@ export const testWhere = (
             q.where({
               NOT: {
                 IN: [
-                  { columns: ['id'], values: raw('(1, 2, 3)') },
-                  { columns: ['name'], values: raw(`('a', 'b', 'c')`) },
+                  { columns: ['id'], values: db.raw('(1, 2, 3)') },
+                  { columns: ['name'], values: db.raw(`('a', 'b', 'c')`) },
                 ],
               },
             }),
           ),
           buildSql((q) =>
             q.whereNotIn({
-              id: raw('(1, 2, 3)'),
-              name: raw(`('a', 'b', 'c')`),
+              id: db.raw('(1, 2, 3)'),
+              name: db.raw(`('a', 'b', 'c')`),
             }),
           ),
         ],
@@ -1014,13 +1019,13 @@ export const testWhere = (
                 NOT: {
                   IN: {
                     columns: ['id', 'name'],
-                    values: raw(`((1, 'a'), (2, 'b'))`),
+                    values: db.raw(`((1, 'a'), (2, 'b'))`),
                   },
                 },
               }),
             ),
             buildSql((q) =>
-              q.whereNotIn(['id', 'name'], raw(`((1, 'a'), (2, 'b'))`)),
+              q.whereNotIn(['id', 'name'], db.raw(`((1, 'a'), (2, 'b'))`)),
             ),
           ],
           `
@@ -1125,14 +1130,14 @@ export const testWhere = (
               OR: [
                 { id: 1 },
                 {
-                  NOT: { IN: { columns: ['id'], values: raw('(1, 2, 3)') } },
+                  NOT: { IN: { columns: ['id'], values: db.raw('(1, 2, 3)') } },
                 },
               ],
             }),
           ),
           buildSql((q) =>
             q.where({ id: 1 }).orWhereNotIn({
-              id: raw('(1, 2, 3)'),
+              id: db.raw('(1, 2, 3)'),
             }),
           ),
         ],
@@ -1152,8 +1157,8 @@ export const testWhere = (
                 {
                   NOT: {
                     IN: [
-                      { columns: ['id'], values: raw('(1, 2, 3)') },
-                      { columns: ['name'], values: raw(`('a', 'b', 'c')`) },
+                      { columns: ['id'], values: db.raw('(1, 2, 3)') },
+                      { columns: ['name'], values: db.raw(`('a', 'b', 'c')`) },
                     ],
                   },
                 },
@@ -1162,8 +1167,8 @@ export const testWhere = (
           ),
           buildSql((q) =>
             q.where({ id: 1 }).orWhereNotIn({
-              id: raw('(1, 2, 3)'),
-              name: raw(`('a', 'b', 'c')`),
+              id: db.raw('(1, 2, 3)'),
+              name: db.raw(`('a', 'b', 'c')`),
             }),
           ),
         ],
@@ -1288,7 +1293,7 @@ export const testWhere = (
                     NOT: {
                       IN: {
                         columns: ['id', 'name'],
-                        values: raw(`((1, 'a'), (2, 'b'))`),
+                        values: db.raw(`((1, 'a'), (2, 'b'))`),
                       },
                     },
                   },
@@ -1298,7 +1303,7 @@ export const testWhere = (
             buildSql((q) =>
               q
                 .where({ id: 1 })
-                .orWhereNotIn(['id', 'name'], raw(`((1, 'a'), (2, 'b'))`)),
+                .orWhereNotIn(['id', 'name'], db.raw(`((1, 'a'), (2, 'b'))`)),
             ),
           ],
           `
@@ -1446,15 +1451,19 @@ export const testJoin = (
 
   it('should accept raw and raw', () => {
     expectSql(
-      q[join](Message, raw('"message"."authorId"'), raw('"user"."id"')).toSql(),
+      q[join](
+        Message,
+        db.raw('"message"."authorId"'),
+        db.raw('"user"."id"'),
+      ).toSql(),
       sql(`"message"`, `"message"."authorId" = "user"."id"`),
       values,
     );
     expectSql(
       q[join](
         Message.as('as'),
-        raw('"as"."authorId"'),
-        raw('"user"."id"'),
+        db.raw('"as"."authorId"'),
+        db.raw('"user"."id"'),
       ).toSql(),
       sql(`"message" AS "as"`, `"as"."authorId" = "user"."id"`),
       values,
@@ -1466,9 +1475,9 @@ export const testJoin = (
     expectSql(
       q[join](
         Message,
-        raw('"message"."authorId"'),
+        db.raw('"message"."authorId"'),
         '=',
-        raw('"user"."id"'),
+        db.raw('"user"."id"'),
       ).toSql(),
       sql(`"message"`, `"message"."authorId" = "user"."id"`),
       values,
@@ -1476,9 +1485,9 @@ export const testJoin = (
     expectSql(
       q[join](
         Message.as('as'),
-        raw('"as"."authorId"'),
+        db.raw('"as"."authorId"'),
         '=',
-        raw('"user"."id"'),
+        db.raw('"user"."id"'),
       ).toSql(),
       sql(`"message" AS "as"`, `"as"."authorId" = "user"."id"`),
       values,
@@ -1502,12 +1511,12 @@ export const testJoin = (
 
   it('should accept object of columns with raw value', () => {
     expectSql(
-      q[join](Message, { authorId: raw('"user"."id"') }).toSql(),
+      q[join](Message, { authorId: db.raw('"user"."id"') }).toSql(),
       sql(`"message"`, `"message"."authorId" = "user"."id"`),
       values,
     );
     expectSql(
-      q[join](Message.as('as'), { authorId: raw('"user"."id"') }).toSql(),
+      q[join](Message.as('as'), { authorId: db.raw('"user"."id"') }).toSql(),
       sql(`"message" AS "as"`, `"as"."authorId" = "user"."id"`),
       values,
     );
@@ -1516,12 +1525,12 @@ export const testJoin = (
 
   it('should accept raw sql', () => {
     expectSql(
-      q[join](Message, raw('"authorId" = "user".id')).toSql(),
+      q[join](Message, db.raw('"authorId" = "user".id')).toSql(),
       sql(`"message"`, `"authorId" = "user".id`),
       values,
     );
     expectSql(
-      q[join](Message.as('as'), raw('"authorId" = "user".id')).toSql(),
+      q[join](Message.as('as'), db.raw('"authorId" = "user".id')).toSql(),
       sql(`"message" AS "as"`, `"authorId" = "user".id`),
       values,
     );

package/src/queryMethods/where.ts

@@ -1,11 +1,11 @@
 import { Query, QueryBase, SelectableBase, WithDataBase } from '../query';
 import { ColumnOperators, QueryData } from '../sql';
 import { pushQueryArray, pushQueryValue } from '../queryDataUtils';
-import { RawExpression } from '../common';
 import { getClonedQueryData, MaybeArray } from '../utils';
 import { JoinArgs, JoinCallback, JoinCallbackArg } from './join';
 import { RelationsBase } from '../relations';
 import { ColumnsShape } from '../columnSchema';
+import { RawExpression } from '../common';
 
 export type WhereArg<T extends QueryBase> =
   | (Omit<

package/src/queryMethods/with.test.ts

@@ -1,7 +1,6 @@
 import { WithOptions } from '../sql';
-import { expectQueryNotMutated, expectSql, User } from '../test-utils';
-import { columnTypes, NumberColumn } from '../columnSchema';
-import { raw } from '../common';
+import { db, expectQueryNotMutated, expectSql, User } from '../test-utils';
+import { columnTypes } from '../columnSchema';
 
 describe('with', () => {
   const options: (
@@ -51,7 +50,7 @@ describe('with', () => {
       const args: Parameters<typeof q.with> = [
         'withAlias',
         columnShape,
-        raw(`(VALUES (1, 'two')) t(one, two)`),
+        db.raw(`(VALUES (1, 'two')) t(one, two)`),
       ];
 
       if (options) {
@@ -106,7 +105,7 @@ describe('with', () => {
     options.forEach((options) => {
       const args: Parameters<typeof q.with> = [
         'withAlias',
-        (qb) => qb.select({ one: raw<NumberColumn>('1') }),
+        (qb) => qb.select({ one: db.raw((t) => t.integer(), '1') }),
       ];
 
       if (options) {
@@ -147,7 +146,7 @@ describe('with', () => {
 
     const received3 = q
       .with('withAlias', User.all())
-      .join('withAlias', raw(`"withAlias"."id" = "user"."id"`))
+      .join('withAlias', db.raw(`"withAlias"."id" = "user"."id"`))
       .select('withAlias.id')
       .toSql();
 

package/src/relations.ts

@@ -1,6 +1,11 @@
 import { defaultsKey, Query, QueryBase, QueryWithTable } from './query';
-import { WhereArg, UpdateData, CreateMethodsNames } from './queryMethods';
-import { MaybeArray } from './utils';
+import {
+  WhereArg,
+  UpdateData,
+  CreateMethodsNames,
+  DeleteMethodsNames,
+} from './queryMethods';
+import { EmptyObject, MaybeArray } from './utils';
 
 export type NestedInsertOneItem = {
   create?: Record<string, unknown>;
@@ -209,9 +214,15 @@ export type RelationQuery<
   T extends Query = Query,
   Required extends boolean = boolean,
   ChainedCreate extends boolean = false,
-  Q extends RelationQueryBase = ChainedCreate extends true
+  ChainedDelete extends boolean = false,
+  Q extends RelationQueryBase = (ChainedCreate extends true
     ? PrepareRelationQuery<T, Name, Required, Populate>
     : PrepareRelationQuery<T, Name, Required, Populate> & {
         [K in CreateMethodsNames]: never;
-      },
+      }) &
+    (ChainedDelete extends true
+      ? EmptyObject
+      : {
+          [K in DeleteMethodsNames]: never;
+        }),
 > = ((params: Params) => Q) & Q;

package/src/sql/common.ts

@@ -1,4 +1,3 @@
-// quote table or column
 import { Query } from '../query';
 import { Expression, getRaw, isRaw } from '../common';
 

package/src/sql/fromAndAs.ts

@@ -1,8 +1,8 @@
-import { getRaw, isRaw } from '../common';
 import { quoteSchemaAndTable } from './common';
 import { QueryBase } from '../query';
 import { checkIfASimpleQuery, SelectQueryData } from './types';
 import { ToSqlCtx } from './toSql';
+import { getRaw, isRaw } from '../common';
 
 export const pushFromAndAs = (
   ctx: ToSqlCtx,

package/src/sql/insert.ts

@@ -1,11 +1,11 @@
 import { InsertQueryData, QueryData } from './types';
 import { addValue, q } from './common';
-import { getRaw, isRaw, raw } from '../common';
 import { pushWhereStatementSql } from './where';
 import { QueryBase } from '../query';
 import { selectToSql } from './select';
 import { ToSqlCtx } from './toSql';
 import { pushQueryValue } from '../queryDataUtils';
+import { getRaw, isRaw, raw } from '../common';
 
 export const pushInsertSql = (
   ctx: ToSqlCtx,

package/src/sql/join.ts

@@ -1,10 +1,10 @@
 import { q, quoteFullColumn, quoteSchemaAndTable } from './common';
-import { getRaw, isRaw, RawExpression } from '../common';
 import { JoinItem, QueryData } from './types';
 import { QueryBase, QueryWithTable } from '../query';
 import { whereToSql } from './where';
 import { Relation } from '../relations';
 import { ToSqlCtx } from './toSql';
+import { getRaw, isRaw, RawExpression } from '../common';
 
 type ItemOf3Or4Length =
   | [

package/src/sql/orderBy.ts

@@ -1,7 +1,7 @@
 import { OrderItem, SelectQueryData } from './types';
-import { getRaw, isRaw } from '../common';
 import { qc } from './common';
 import { ToSqlCtx } from './toSql';
+import { getRaw, isRaw } from '../common';
 
 export const pushOrderBySql = (
   ctx: ToSqlCtx,

package/src/sql/select.ts

@@ -9,7 +9,6 @@ import { Query, QueryBase } from '../query';
 import { addValue, q, quoteFullColumn } from './common';
 import { aggregateToSql } from './aggregate';
 import { PormInternalError, UnhandledTypeError } from '../errors';
-import { StringColumn } from '../columnSchema';
 import { quote } from '../quote';
 import { ToSqlCtx } from './toSql';
 import { relationQueryKey } from '../relations';
@@ -166,7 +165,7 @@ const pushSubQuerySql = (
       select.length = 0;
       select[0] = { selectAs: { c: first } } as SelectItem;
       query = query._wrap(query.__model.clone()) as unknown as typeof query;
-      query._getOptional(raw<StringColumn>(`COALESCE(json_agg("c"), '[]')`));
+      query._getOptional(raw(`COALESCE(json_agg("c"), '[]')`));
       break;
     }
     case 'rows':

package/src/sql/toSql.ts

@@ -1,4 +1,3 @@
-import { getRaw, isRaw } from '../common';
 import { Query, queryTypeWithLimitOne } from '../query';
 import { addValue, q, qc } from './common';
 import { JoinItem, QueryData, Sql } from './types';
@@ -17,6 +16,7 @@ import { pushTruncateSql } from './truncate';
 import { pushColumnInfoSql } from './columnInfo';
 import { pushOrderBySql } from './orderBy';
 import { OnQueryBuilder, WhereQueryBuilder } from '../queryMethods';
+import { getRaw, isRaw } from '../common';
 
 export type ToSqlCtx = {
   whereQueryBuilder: typeof WhereQueryBuilder;

package/src/sql/update.ts

@@ -5,11 +5,11 @@ import {
   UpdateQueryDataObject,
 } from './types';
 import { addValue, q, quoteSchemaAndTable } from './common';
-import { getRaw, isRaw } from '../common';
 import { pushReturningSql } from './insert';
 import { pushWhereStatementSql } from './where';
 import { ToSqlCtx } from './toSql';
 import { pushOrNewArray } from '../utils';
+import { getRaw, isRaw } from '../common';
 
 export const pushUpdateSql = (
   ctx: ToSqlCtx,

package/src/sql/where.ts

@@ -9,10 +9,10 @@ import {
   WhereOnJoinItem,
 } from './types';
 import { addValue, q, qc, quoteFullColumn } from './common';
-import { getRaw, isRaw, RawExpression } from '../common';
 import { getQueryAs, MaybeArray, toArray } from '../utils';
 import { processJoinItem } from './join';
 import { ToSqlCtx } from './toSql';
+import { getRaw, isRaw, RawExpression } from '../common';
 
 export const pushWhereStatementSql = (
   ctx: ToSqlCtx,

package/src/sql/window.ts

@@ -1,11 +1,10 @@
-import { Query } from '../query';
 import { WindowDeclaration } from './types';
-import { getRaw, isRaw, RawExpression } from '../common';
 import { expressionToSql, q } from './common';
 import { orderByToSql } from './orderBy';
+import { getRaw, isRaw, RawExpression } from '../common';
 
-export const windowToSql = <T extends Query>(
-  window: keyof T['windows'] | WindowDeclaration | RawExpression,
+export const windowToSql = (
+  window: string | WindowDeclaration | RawExpression,
   values: unknown[],
   quotedAs?: string,
 ) => {

package/src/sql/with.ts

@@ -1,7 +1,7 @@
 import { QueryData } from './types';
 import { q } from './common';
-import { isRaw, getRaw } from '../common';
 import { ToSqlCtx } from './toSql';
+import { getRaw, isRaw } from '../common';
 
 export const pushWithSql = (
   ctx: ToSqlCtx,