pqb 0.0.7 → 0.0.9

package/package.json

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

package/src/columnSchema/columnsSchema.ts

@@ -38,6 +38,10 @@ export class ArrayOfColumnsObjects<
   }
 }
 
+export abstract class PluckResultColumnType<
+  C extends ColumnType,
+> extends ColumnType<C['type'][], typeof Operators.any> {}
+
 type UnionKeyofToOvlds<S, U> = UnionToIntersection<
   U extends keyof S ? (f: U) => void : never
 >;

package/src/errors.ts

@@ -1,7 +1,17 @@
-export class NotFoundError extends Error {
+export class PormError extends Error {}
+
+export class NotFoundError extends PormError {
   constructor(message = 'Record is not found') {
     super(message);
   }
 }
 
-export class MoreThanOneRowError extends Error {}
+export class MoreThanOneRowError extends PormError {}
+
+export class PormInternalError extends Error {}
+
+export class UnhandledTypeError extends PormInternalError {
+  constructor(value: never) {
+    super(`Unhandled type: ${JSON.stringify(value)} received`);
+  }
+}

package/src/queryMethods/select.ts

@@ -10,6 +10,7 @@ import {
   ArrayOfColumnsObjects,
   ColumnsObject,
   NullableColumn,
+  PluckResultColumnType,
 } from '../columnSchema';
 import { getQueryParsers, isRaw, RawExpression } from '../common';
 import { pushQueryArray } from '../queryDataUtils';
@@ -59,6 +60,8 @@ type SelectResult<
         ? ArrayOfColumnsObjects<Arg['result']>
         : Arg['returnType'] extends 'valueOrThrow'
         ? Arg['result']['value']
+        : Arg['returnType'] extends 'pluck'
+        ? PluckResultColumnType<Arg['result']['pluck']>
         : Arg[isRequiredRelationKey] extends true
         ? ColumnsObject<Arg['result']>
         : NullableColumn<ColumnsObject<Arg['result']>>

package/src/queryMethods/where.test.ts

@@ -1546,7 +1546,11 @@ export const testJoin = (
   describe('relation', () => {
     const withRelation = q as Query & {
       relations: {
-        message: { key: 'message'; query: typeof Message; joinQuery: Query };
+        message: {
+          key: 'message';
+          query: typeof Message;
+          joinQuery(fromQuery: Query, toQuery: Query): Query;
+        };
       };
     };
 
@@ -1554,7 +1558,15 @@ export const testJoin = (
       message: {
         key: 'message',
         query: Message,
-        joinQuery: pushQueryOn(Message.clone(), Message, q, 'authorId', 'id'),
+        joinQuery(fromQuery, toQuery) {
+          return pushQueryOn(
+            toQuery.clone(),
+            toQuery,
+            fromQuery,
+            'authorId',
+            'id',
+          );
+        },
       },
     };
 

package/src/queryMethods/where.ts

@@ -440,6 +440,9 @@ export class WhereQueryBuilder<Q extends QueryBase = QueryBase>
   constructor(public table: Q['table'], public tableAlias: Q['tableAlias']) {
     super();
     this.__model = this as unknown as Query;
+    if (tableAlias) {
+      this.query.as = tableAlias;
+    }
   }
 
   clone<T extends this>(this: T): T {

package/src/relations.ts

@@ -92,7 +92,7 @@ export type BaseRelation = {
   key: string;
   model: QueryWithTable;
   query: QueryWithTable;
-  joinQuery: Query;
+  joinQuery(fromQuery: Query, toQuery: Query): Query;
   nestedCreateQuery: Query;
   nestedInsert?:
     | BelongsToNestedInsert

package/src/sql/aggregate.ts

@@ -7,10 +7,7 @@ import { whereToSql } from './where';
 import { Query } from '../query';
 
 export const aggregateToSql = (
-  model: Pick<
-    Query,
-    'whereQueryBuilder' | 'onQueryBuilder' | 'as' | 'shape' | 'relations'
-  >,
+  model: Query,
   values: unknown[],
   item: AggregateItem,
   quotedAs?: string,

package/src/sql/having.ts

@@ -15,10 +15,7 @@ const aggregateOptionNames: (keyof AggregateItemOptions)[] = [
 
 export const pushHavingSql = (
   sql: string[],
-  model: Pick<
-    Query,
-    'whereQueryBuilder' | 'onQueryBuilder' | 'as' | 'shape' | 'relations'
-  >,
+  model: Query,
   query: SelectQueryData,
   values: unknown[],
   quotedAs?: string,
@@ -28,10 +25,7 @@ export const pushHavingSql = (
 };
 
 export const havingToSql = (
-  model: Pick<
-    Query,
-    'whereQueryBuilder' | 'onQueryBuilder' | 'as' | 'shape' | 'relations'
-  >,
+  model: Query,
   query: SelectQueryData,
   values: unknown[],
   quotedAs?: string,

package/src/sql/insert.ts

@@ -8,10 +8,7 @@ import { selectToSql } from './select';
 export const pushInsertSql = (
   sql: string[],
   values: unknown[],
-  model: Pick<
-    Query,
-    'whereQueryBuilder' | 'onQueryBuilder' | 'as' | 'shape' | 'relations'
-  >,
+  model: Query,
   query: InsertQueryData,
   quotedAs: string,
 ) => {
@@ -88,10 +85,7 @@ export const pushInsertSql = (
 
 export const pushReturningSql = (
   sql: string[],
-  model: Pick<
-    Query,
-    'whereQueryBuilder' | 'onQueryBuilder' | 'as' | 'shape' | 'relations'
-  >,
+  model: Query,
   query: QueryData,
   values: unknown[],
   quotedAs: string,

package/src/sql/join.ts

@@ -19,10 +19,7 @@ type ItemOf3Or4Length =
     ];
 
 export const processJoinItem = (
-  model: Pick<
-    Query,
-    'whereQueryBuilder' | 'onQueryBuilder' | 'table' | 'shape' | 'relations'
-  >,
+  model: Query,
   query: Pick<QueryData, 'as'>,
   values: unknown[],
   args: JoinItem['args'],
@@ -31,33 +28,40 @@ export const processJoinItem = (
   const [first] = args;
   if (typeof first === 'string') {
     if (first in model.relations) {
-      const { key, joinQuery } = (model.relations as Record<string, Relation>)[
-        first
-      ];
+      const {
+        key,
+        query: toQuery,
+        joinQuery,
+      } = (model.relations as Record<string, Relation>)[first];
+
+      const joinedQuery = joinQuery(model, toQuery);
+      const joinedQueryData = joinedQuery.query;
 
       const table = (
-        typeof joinQuery.query.from === 'string'
-          ? joinQuery.query.from
-          : joinQuery.table
+        typeof joinedQueryData.from === 'string'
+          ? joinedQueryData.from
+          : joinedQuery.table
       ) as string;
 
-      let target = quoteSchemaAndTable(joinQuery.query.schema, table);
+      let target = quoteSchemaAndTable(joinedQueryData.schema, table);
 
-      const as = joinQuery.query.as || key;
+      const as = joinedQueryData.as || key;
       if (as !== table) {
         target += ` AS ${q(as as string)}`;
       }
 
       const queryData = {
+        as: joinedQuery.query.as,
         and: [],
         or: [],
       } as {
+        as?: string;
         and: Exclude<QueryData['and'], undefined>;
         or: Exclude<QueryData['or'], undefined>;
       };
 
-      if (joinQuery.query.and) queryData.and.push(...joinQuery.query.and);
-      if (joinQuery.query.or) queryData.or.push(...joinQuery.query.or);
+      if (joinedQueryData.and) queryData.and.push(...joinedQueryData.and);
+      if (joinedQueryData.or) queryData.or.push(...joinedQueryData.or);
 
       const arg = (args[1] as ((q: unknown) => QueryBase) | undefined)?.(
         new model.onQueryBuilder({ table: model.table, query }, args[0]),
@@ -70,7 +74,7 @@ export const processJoinItem = (
 
       const joinAs = q(as as string);
       const onConditions = whereToSql(
-        joinQuery,
+        joinedQuery,
         queryData,
         values,
         quotedAs,

package/src/sql/select.ts

@@ -1,10 +1,11 @@
 import { JsonItem, SelectFunctionItem, SelectQueryData } from './types';
-import { Expression, getRaw, isRaw } from '../common';
+import { Expression, getRaw, isRaw, raw } from '../common';
 import { Query } from '../query';
 import { addValue, q, quoteFullColumn } from './common';
 import { aggregateToSql } from './aggregate';
 import { getQueryAs } from '../utils';
 import { RelationQuery, relationQueryKey } from '../relations';
+import { PormInternalError, UnhandledTypeError } from '../errors';
 
 const jsonColumnOrMethodToSql = (
   column: string | JsonItem,
@@ -62,10 +63,7 @@ const jsonToSql = (
 
 export const pushSelectSql = (
   sql: string[],
-  model: Pick<
-    Query,
-    'whereQueryBuilder' | 'onQueryBuilder' | 'as' | 'shape' | 'relations'
-  >,
+  model: Query,
   query: Pick<SelectQueryData, 'select' | 'join'>,
   values: unknown[],
   quotedAs?: string,
@@ -74,10 +72,7 @@ export const pushSelectSql = (
 };
 
 export const selectToSql = (
-  model: Pick<
-    Query,
-    'whereQueryBuilder' | 'onQueryBuilder' | 'as' | 'shape' | 'relations'
-  >,
+  model: Query,
   query: Pick<SelectQueryData, 'select' | 'join'>,
   values: unknown[],
   quotedAs?: string,
@@ -99,12 +94,38 @@ export const selectToSql = (
         relationQuery._as(relationQuery.query[relationQueryKey] as string);
 
         const { returnType } = relationQuery.query;
-        if (
-          returnType === 'all' ||
-          returnType === 'one' ||
-          returnType === 'oneOrThrow'
-        ) {
-          relationQuery = relationQuery._json() as unknown as RelationQuery;
+        switch (returnType) {
+          case 'all':
+          case 'one':
+          case 'oneOrThrow':
+            relationQuery =
+              relationQuery._json() as unknown as typeof relationQuery;
+            break;
+          case 'pluck': {
+            const first = relationQuery.query.select?.[0];
+            if (!first)
+              throw new PormInternalError(`Nothing was selected for pluck`);
+
+            const selection = selectToSql(
+              relationQuery.__model,
+              relationQuery.query,
+              values,
+              q(getQueryAs(relationQuery)),
+            );
+
+            relationQuery.query.select = [
+              raw(`COALESCE(json_agg(${selection}), '[]')`),
+            ];
+            break;
+          }
+          case 'rows':
+          case 'value':
+          case 'valueOrThrow':
+          case 'rowCount':
+          case 'void':
+            break;
+          default:
+            throw new UnhandledTypeError(returnType);
         }
 
         list.push(`(${relationQuery.toSql(values).text}) AS ${as}`);

package/src/sql/types.ts

@@ -277,13 +277,17 @@ export type WhereJsonPathEqualsItem = [
 ];
 
 export type WhereOnItem = {
-  joinFrom: { table?: string; query: { as?: string } } | string;
-  joinTo: { table?: string; query: { as?: string } } | string;
+  joinFrom: WhereOnJoinItem;
+  joinTo: WhereOnJoinItem;
   on:
     | [leftFullColumn: string, rightFullColumn: string]
     | [leftFullColumn: string, op: string, rightFullColumn: string];
 };
 
+export type WhereOnJoinItem =
+  | { table?: string; query: { as?: string } }
+  | string;
+
 export type AggregateItemOptions = {
   as?: string;
   distinct?: boolean;

package/src/sql/where.ts

@@ -6,6 +6,7 @@ import {
   WhereItem,
   WhereJsonPathEqualsItem,
   WhereOnItem,
+  WhereOnJoinItem,
 } from './types';
 import { addValue, q, qc, quoteFullColumn } from './common';
 import { EMPTY_OBJECT, getRaw, isRaw, RawExpression } from '../common';
@@ -14,10 +15,7 @@ import { processJoinItem } from './join';
 
 export const pushWhereSql = (
   sql: string[],
-  model: Pick<
-    Query,
-    'whereQueryBuilder' | 'onQueryBuilder' | 'as' | 'shape' | 'relations'
-  >,
+  model: Query,
   query: Pick<QueryData, 'as' | 'and' | 'or'>,
   values: unknown[],
   quotedAs?: string,
@@ -36,10 +34,7 @@ export const pushWhereSql = (
 };
 
 export const whereToSql = (
-  model: Pick<
-    Query,
-    'whereQueryBuilder' | 'onQueryBuilder' | 'table' | 'shape' | 'relations'
-  >,
+  model: Query,
   query: Pick<QueryData, 'as' | 'and' | 'or'>,
   values: unknown[],
   quotedAs?: string,
@@ -234,15 +229,10 @@ const whereHandlers: Record<
       const item = value as WhereOnItem;
       const leftColumn = quoteFullColumn(
         item.on[0],
-        typeof item.joinTo === 'string'
-          ? q(item.joinTo)
-          : q(getQueryAs(item.joinTo)),
+        getJoinItemSource(item.joinTo),
       );
 
-      const joinTo =
-        typeof item.joinFrom === 'string'
-          ? item.joinFrom
-          : q(getQueryAs(item.joinFrom));
+      const joinTo = getJoinItemSource(item.joinFrom);
 
       const [op, rightColumn] =
         item.on.length === 2
@@ -275,6 +265,10 @@ const whereHandlers: Record<
   },
 };
 
+const getJoinItemSource = (joinItem: WhereOnJoinItem) => {
+  return typeof joinItem === 'string' ? q(joinItem) : q(getQueryAs(joinItem));
+};
+
 const pushIn = (
   ands: string[],
   prefix: string,