pqb 0.4.4 → 0.4.6

package/package.json

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

package/src/db.ts

@@ -82,6 +82,7 @@ export interface Db<
     length: number,
     name: QueryErrorName,
   ) => QueryError<this>;
+  isSubQuery: false;
   [defaultsKey]: Record<
     {
       [K in keyof Shape]: Shape[K]['hasDefault'] extends true ? K : never;

package/src/query.ts

@@ -70,8 +70,8 @@ export type Query = QueryMethods & {
     length: number,
     name: QueryErrorName,
   ) => QueryError;
-  // eslint-disable-next-line @typescript-eslint/ban-types
-  [defaultsKey]: {};
+  isSubQuery: boolean;
+  [defaultsKey]: EmptyObject;
 };
 
 export type Selectable<T extends QueryBase> = StringKey<keyof T['selectable']>;

package/src/queryMethods/delete.ts

@@ -1,5 +1,7 @@
 import { Query, SetQueryReturnsRowCount } from '../query';
 
+export type DeleteMethodsNames = 'del' | '_del' | 'delete' | '_delete';
+
 type DeleteArgs<T extends Query> = T['hasWhere'] extends true
   ? [forceAll?: boolean]
   : [true];

package/src/queryMethods/select.test.ts

@@ -1,25 +1,16 @@
 import {
   assertType,
-  Chat,
-  chatData,
   expectQueryNotMutated,
   expectSql,
-  Message,
-  messageData,
-  MessageRecord,
-  now,
   Profile,
   profileData,
-  ProfileRecord,
   User,
   userData,
   UserRecord,
   useTestDatabase,
 } from '../test-utils';
 import { raw } from '../common';
-import { columnTypes, DateColumn } from '../columnSchema';
-import { addQueryOn } from './join';
-import { RelationQuery, relationQueryKey } from '../relations';
+import { DateColumn } from '../columnSchema';
 
 const insertUserAndProfile = async () => {
   const id = await User.get('id').create(userData);
@@ -115,201 +106,6 @@ describe('selectMethods', () => {
       expectQueryNotMutated(q);
     });
 
-    describe('select relation', () => {
-      const profileQuery = Profile.takeOptional();
-      const profileRelationQuery = addQueryOn(
-        profileQuery,
-        User,
-        profileQuery,
-        'userId',
-        'id',
-      );
-      profileRelationQuery.query[relationQueryKey] = 'profile';
-
-      const profileRelation = new Proxy(() => undefined, {
-        get(_, key) {
-          return (
-            profileRelationQuery as unknown as Record<string | symbol, unknown>
-          )[key];
-        },
-      }) as unknown as RelationQuery<
-        'profile',
-        Record<string, unknown>,
-        never,
-        typeof profileQuery
-      >;
-
-      it('should select relation which returns one record', () => {
-        const q = User.all();
-
-        const query = q.select('id', {
-          profile: () => profileRelation.where({ bio: 'bio' }),
-        });
-
-        assertType<
-          Awaited<typeof query>,
-          { id: number; profile: typeof Profile['type'] | null }[]
-        >();
-
-        expectSql(
-          query.toSql(),
-          `
-            SELECT
-              "user"."id",
-              (
-                SELECT row_to_json("t".*)
-                FROM (
-                  SELECT *
-                  FROM "profile"
-                  WHERE "profile"."userId" = "user"."id"
-                    AND "profile"."bio" = $1
-                  LIMIT $2
-                ) AS "t"
-              ) AS "profile"
-            FROM "user"
-          `,
-          ['bio', 1],
-        );
-
-        expectQueryNotMutated(q);
-      });
-
-      it('should have proper type for required relation', () => {
-        const q = User.all();
-
-        const query = q.select('id', {
-          profile: () =>
-            profileRelation as unknown as RelationQuery<
-              'profile',
-              Record<string, unknown>,
-              never,
-              typeof profileRelationQuery,
-              true
-            >,
-        });
-
-        assertType<
-          Awaited<typeof query>,
-          { id: number; profile: typeof Profile['type'] }[]
-        >();
-      });
-
-      it('should parse columns in single relation record result', async () => {
-        const userId = await User.get('id').create(userData);
-        const now = new Date();
-        await Profile.create({ userId, updatedAt: now, createdAt: now });
-
-        const [record] = await User.select('id', {
-          profile: () => profileRelation,
-        });
-
-        assertType<
-          typeof record,
-          { id: number; profile: ProfileRecord | null }
-        >();
-
-        expect(record.profile).toMatchObject({
-          updatedAt: now,
-          createdAt: now,
-        });
-      });
-
-      const messagesQuery = Message.as('messages');
-      const messageRelationQuery = addQueryOn(
-        messagesQuery,
-        User,
-        messagesQuery,
-        'authorId',
-        'id',
-      );
-      messageRelationQuery.query[relationQueryKey] = 'messages';
-
-      const messageRelation = new Proxy(() => undefined, {
-        get(_, key) {
-          return (
-            messageRelationQuery as unknown as Record<string | symbol, unknown>
-          )[key];
-        },
-      }) as unknown as RelationQuery<
-        'messages',
-        Record<string, unknown>,
-        never,
-        typeof messageRelationQuery
-      >;
-
-      it('should select relation which returns many records', () => {
-        const q = User.all();
-
-        const query = q.select('id', {
-          messages: () => messageRelation.where({ text: 'text' }),
-        });
-
-        assertType<
-          Awaited<typeof query>,
-          { id: number; messages: typeof Message['type'][] }[]
-        >();
-
-        expectSql(
-          query.toSql(),
-          `
-            SELECT
-              "user"."id",
-              (
-                SELECT COALESCE(json_agg(row_to_json("t".*)), '[]')
-                FROM (
-                  SELECT *
-                  FROM "message" AS "messages"
-                  WHERE "messages"."authorId" = "user"."id"
-                    AND "messages"."text" = $1
-                ) AS "t"
-              ) AS "messages"
-            FROM "user"
-          `,
-          ['text'],
-        );
-
-        expectQueryNotMutated(q);
-      });
-
-      it('should parse columns in multiple relation records result', async () => {
-        const { id: authorId } = await User.select('id').create(userData);
-        const { id: chatId } = await Chat.select('id').create(chatData);
-        await Message.create({
-          authorId,
-          chatId,
-          ...messageData,
-          createdAt: now,
-          updatedAt: now,
-        });
-
-        const [record] = await User.select('id', {
-          messages: () => messageRelation,
-        });
-
-        assertType<typeof record, { id: number; messages: MessageRecord[] }>();
-
-        expect(record.messages[0]).toMatchObject({
-          updatedAt: now,
-          createdAt: now,
-        });
-      });
-
-      it('should have proper type for conditional sub queries', async () => {
-        const condition = true;
-
-        const query = User.select('id', {
-          hasProfile: condition
-            ? () => profileRelation.exists()
-            : raw(columnTypes.boolean(), 'true'),
-        });
-
-        assertType<
-          Awaited<typeof query>,
-          { id: number; hasProfile: boolean }[]
-        >();
-      });
-    });
-
     describe('parse columns', () => {
       beforeEach(insertUserAndProfile);
 

package/src/queryMethods/select.ts

@@ -106,7 +106,9 @@ export const addParserForSelectItem = <T extends Query>(
     addParserForRawExpression(q, key, arg);
     return arg;
   } else if (typeof arg === 'function') {
+    q.isSubQuery = true;
     const rel = arg(q);
+    q.isSubQuery = false;
     const parsers = getQueryParsers(rel);
     if (parsers) {
       if (queryTypeWithLimitOne[rel.query.returnType]) {

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>;
@@ -179,8 +184,15 @@ export const relationQueryKey = Symbol('relationQuery');
 export type isRequiredRelationKey = typeof isRequiredRelationKey;
 export const isRequiredRelationKey = Symbol('isRequiredRelation');
 
+export type RelationQueryData = {
+  relationName: string;
+  sourceQuery: Query;
+  relationQuery: Query;
+  joinQuery(fromQuery: Query, toQuery: Query): Query;
+};
+
 export type RelationQueryBase = Query & {
-  [relationQueryKey]: string;
+  [relationQueryKey]: RelationQueryData;
   [isRequiredRelationKey]: boolean;
 };
 
@@ -192,7 +204,7 @@ type PrepareRelationQuery<
 > = Omit<T, 'tableAlias'> & {
   tableAlias: RelationName extends string ? RelationName : never;
   [isRequiredRelationKey]: Required;
-  [relationQueryKey]: string;
+  [relationQueryKey]: RelationQueryData;
 } & { [defaultsKey]: Record<Populate, true> };
 
 export type RelationQuery<
@@ -202,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/delete.ts

@@ -4,6 +4,7 @@ import { pushWhereStatementSql } from './where';
 import { pushReturningSql } from './insert';
 import { processJoinItem } from './join';
 import { ToSqlCtx } from './toSql';
+import { q } from './common';
 
 export const pushDeleteSql = (
   ctx: ToSqlCtx,
@@ -11,7 +12,12 @@ export const pushDeleteSql = (
   query: DeleteQueryData,
   quotedAs: string,
 ) => {
-  ctx.sql.push(`DELETE FROM ${quotedAs}`);
+  const from = q(model.table as string);
+  ctx.sql.push(`DELETE FROM ${from}`);
+
+  if (from !== quotedAs) {
+    ctx.sql.push(`AS ${quotedAs}`);
+  }
 
   let conditions: string | undefined;
   if (query.join?.length) {

package/src/sql/select.ts

@@ -12,6 +12,7 @@ import { PormInternalError, UnhandledTypeError } from '../errors';
 import { StringColumn } from '../columnSchema';
 import { quote } from '../quote';
 import { ToSqlCtx } from './toSql';
+import { relationQueryKey } from '../relations';
 
 const jsonColumnOrMethodToSql = (
   column: string | JsonItem,
@@ -143,6 +144,12 @@ const pushSubQuerySql = (
   list: string[],
 ) => {
   const { returnType = 'all' } = query.query;
+
+  const rel = query.query[relationQueryKey];
+  if (rel) {
+    query = rel.joinQuery(rel.sourceQuery, query);
+  }
+
   switch (returnType) {
     case 'all':
     case 'one':

package/src/sql/toSql.ts

@@ -84,7 +84,7 @@ const makeSql = (model: Query, { values = [] }: ToSqlOptions = {}): Sql => {
     }
 
     if (query.type === 'delete') {
-      pushDeleteSql(ctx, model, query, q(model.table));
+      pushDeleteSql(ctx, model, query, quotedAs);
       return { text: sql.join(' '), values };
     }
   }

package/src/sql/types.ts

@@ -8,7 +8,11 @@ import {
 } from '../query';
 import { Expression, RawExpression } from '../common';
 import { ColumnsShape, ColumnType } from '../columnSchema';
-import { RelationQuery, relationQueryKey } from '../relations';
+import {
+  RelationQuery,
+  RelationQueryData,
+  relationQueryKey,
+} from '../relations';
 import { Adapter, QueryResult } from '../adapter';
 import { MaybeArray } from '../utils';
 import { QueryLogger, QueryLogObject } from '../queryMethods/log';
@@ -52,7 +56,7 @@ export type CommonQueryData = {
   adapter: Adapter;
   handleResult(q: Query, result: QueryResult): Promise<unknown>;
   returnType: QueryReturnType;
-  [relationQueryKey]?: string;
+  [relationQueryKey]?: RelationQueryData;
   inTransaction?: boolean;
   wrapInTransaction?: boolean;
   throwOnNotFound?: boolean;