pqb 0.3.2 → 0.3.3

package/src/queryMethods/select.ts

@@ -4,7 +4,9 @@ import {
   ColumnsParsers,
   Query,
   QueryBase,
+  QueryReturnsAll,
   QuerySelectAll,
+  queryTypeWithLimitOne,
 } from '../query';
 import {
   ArrayOfColumnsObjects,
@@ -75,7 +77,7 @@ type SelectResult<
 
 type SelectSubQueryResult<
   Arg extends Query & { [isRequiredRelationKey]?: boolean },
-> = Arg['returnType'] extends 'all'
+> = QueryReturnsAll<Arg['returnType']> extends true
   ? ArrayOfColumnsObjects<Arg['result']>
   : Arg['returnType'] extends 'valueOrThrow'
   ? Arg['result']['value']
@@ -107,7 +109,7 @@ export const addParserForSelectItem = <T extends Query>(
     const rel = arg(q);
     const parsers = getQueryParsers(rel);
     if (parsers) {
-      if (rel.query.take) {
+      if (queryTypeWithLimitOne[rel.query.returnType]) {
         addParserToQuery(q.query, key, (item) => parseRecord(parsers, item));
       } else {
         addParserToQuery(q.query, key, (items) =>

package/src/queryMethods/then.ts

@@ -49,7 +49,7 @@ export const handleResult: CommonQueryData['handleResult'] = async (
   q,
   result: QueryResult,
 ) => {
-  return parseResult(q, q.query.returnType, result);
+  return parseResult(q, q.query.returnType || 'all', result);
 };
 
 const then = async (
@@ -89,7 +89,7 @@ const then = async (
     }
 
     const queryResult = await q.query.adapter[
-      queryMethodByReturnType[q.query.returnType] as 'query'
+      queryMethodByReturnType[q.query.returnType || 'all'] as 'query'
     ](sql);
 
     if (q.query.log) {
@@ -119,7 +119,7 @@ const then = async (
 
 export const parseResult = (
   q: Query,
-  returnType: QueryReturnType,
+  returnType: QueryReturnType | undefined = 'all',
   result: QueryResult,
 ): unknown => {
   switch (returnType) {

package/src/queryMethods/update.ts

@@ -1,4 +1,4 @@
-import { Query, SetQueryReturnsRowCount } from '../query';
+import { Query, QueryReturnsAll, SetQueryReturnsRowCount } from '../query';
 import { pushQueryArray, pushQueryValue } from '../queryDataUtils';
 import { isRaw, RawExpression, StringKey } from '../common';
 import {
@@ -43,7 +43,7 @@ type UpdateBelongsToData<T extends Query, Rel extends BelongsToRelation> =
   | {
       create: InsertData<Rel['nestedCreateQuery']>;
     }
-  | (T['returnType'] extends 'all'
+  | (QueryReturnsAll<T['returnType']> extends true
       ? never
       : {
           upsert: {
@@ -56,7 +56,7 @@ type UpdateHasOneData<T extends Query, Rel extends HasOneRelation> =
   | { disconnect: boolean }
   | { delete: boolean }
   | { update: UpdateData<Rel['model']> }
-  | (T['returnType'] extends 'all'
+  | (QueryReturnsAll<T['returnType']> extends true
       ? never
       :
           | { set: WhereArg<Rel['model']> }
@@ -77,7 +77,7 @@ type UpdateHasManyData<T extends Query, Rel extends HasManyRelation> = {
     where: MaybeArray<WhereArg<Rel['model']>>;
     data: UpdateData<Rel['model']>;
   };
-} & (T['returnType'] extends 'all'
+} & (QueryReturnsAll<T['returnType']> extends true
   ? EmptyObject
   : {
       set?: MaybeArray<WhereArg<Rel['model']>>;
@@ -107,9 +107,9 @@ type UpdateRawArgs<T extends Query, ForceAll extends boolean> = (
   ? [update: RawExpression]
   : [update: RawExpression, forceAll: true];
 
-type UpdateResult<T extends Query> = T['hasSelect'] extends false
-  ? SetQueryReturnsRowCount<T>
-  : T;
+type UpdateResult<T extends Query> = T['hasSelect'] extends true
+  ? T
+  : SetQueryReturnsRowCount<T>;
 
 type ChangeCountArg<T extends Query> =
   | keyof T['shape']
@@ -179,7 +179,7 @@ export class Update {
     const prependRelations: Record<string, Record<string, unknown>> = {};
     const appendRelations: Record<string, Record<string, unknown>> = {};
 
-    const originalReturnType = query.returnType;
+    const originalReturnType = query.returnType || 'all';
 
     for (const key in data) {
       if (relations[key]) {
@@ -287,6 +287,11 @@ export class Update {
         appendRelationKeys.map((relationName) => {
           return (q: Query, result: Record<string, unknown>[]) => {
             const all = resultOfTypeAll || result;
+
+            if (q.query.returnType !== originalReturnType) {
+              q.query.returnType = originalReturnType;
+            }
+
             return (
               relations[relationName].nestedUpdate as HasOneNestedUpdate
             )?.(q, all, appendRelations[relationName] as NestedUpdateOneItem);

package/src/sql/fromAndAs.ts

@@ -1,7 +1,7 @@
 import { getRaw, isRaw } from '../common';
 import { quoteSchemaAndTable } from './common';
 import { QueryBase } from '../query';
-import { queryKeysOfNotSimpleQuery, SelectQueryData } from './types';
+import { checkIfASimpleQuery, SelectQueryData } from './types';
 import { ToSqlCtx } from './toSql';
 
 export const pushFromAndAs = (
@@ -38,9 +38,8 @@ const getFrom = (
       }
 
       const q = query.from.query;
-      const keys = Object.keys(q) as (keyof SelectQueryData)[];
       // if query contains more than just schema return (SELECT ...)
-      if (keys.some((key) => queryKeysOfNotSimpleQuery.includes(key))) {
+      if (!checkIfASimpleQuery(q)) {
         const sql = query.from.toSql({ values });
         return `(${sql.text})`;
       }

package/src/sql/select.ts

@@ -142,7 +142,7 @@ const pushSubQuerySql = (
   values: unknown[],
   list: string[],
 ) => {
-  const { returnType } = query.query;
+  const { returnType = 'all' } = query.query;
   switch (returnType) {
     case 'all':
     case 'one':
@@ -160,7 +160,6 @@ const pushSubQuerySql = (
       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"), '[]')`));
-      delete query.query.take;
       break;
     }
     case 'rows':

package/src/sql/toSql.ts

@@ -1,5 +1,5 @@
 import { getRaw, isRaw } from '../common';
-import { Query } from '../query';
+import { Query, queryTypeWithLimitOne } from '../query';
 import { addValue, q, qc } from './common';
 import { JoinItem, QueryData, Sql } from './types';
 import { pushDistinctSql } from './distinct';
@@ -156,8 +156,9 @@ const makeSql = (model: Query, { values = [] }: ToSqlOptions = {}): Sql => {
     pushOrderBySql(ctx, quotedAs, query.order);
   }
 
-  if (query.take || query.limit !== undefined) {
-    sql.push(`LIMIT ${addValue(values, query.take ? 1 : query.limit)}`);
+  const limit = queryTypeWithLimitOne[query.returnType] ? 1 : query.limit;
+  if (limit) {
+    sql.push(`LIMIT ${addValue(values, limit)}`);
   }
 
   if (query.offset) {

package/src/sql/types.ts

@@ -21,8 +21,13 @@ export type Sql = {
 };
 
 // used in `from` logic to decide if convert query to sql or just write table name
-export const queryKeysOfNotSimpleQuery: (keyof SelectQueryData)[] = [
-  'take',
+export const checkIfASimpleQuery = (q: QueryData) => {
+  if (q.returnType && q.returnType !== 'all') return false;
+  const keys = Object.keys(q) as (keyof SelectQueryData)[];
+  return !keys.some((key) => queryKeysOfNotSimpleQuery.includes(key));
+};
+
+const queryKeysOfNotSimpleQuery: (keyof SelectQueryData)[] = [
   'with',
   'as',
   'from',
@@ -51,7 +56,6 @@ export type CommonQueryData = {
   inTransaction?: boolean;
   wrapInTransaction?: boolean;
   throwOnNotFound?: boolean;
-  take?: boolean;
   with?: WithItem[];
   withShapes?: Record<string, ColumnsShape>;
   schema?: string;

package/src/sql/window.ts

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

package/src/sql/with.ts

@@ -7,26 +7,31 @@ export const pushWithSql = (
   ctx: ToSqlCtx,
   withData: Exclude<QueryData['with'], undefined>,
 ) => {
-  withData.forEach((withItem) => {
-    const [name, options, query] = withItem;
+  if (!withData.length) return;
 
-    let inner: string;
-    if (isRaw(query)) {
-      inner = getRaw(query, ctx.values);
-    } else {
-      inner = query.toSql({ values: ctx.values }).text;
-    }
+  ctx.sql.push(
+    'WITH',
+    withData
+      .map((withItem) => {
+        const [name, options, query] = withItem;
 
-    ctx.sql.push(
-      `WITH ${options.recursive ? 'RECURSIVE ' : ''}${q(name)}${
-        options.columns ? `(${options.columns.map(q).join(', ')})` : ''
-      } AS ${
-        options.materialized
-          ? 'MATERIALIZED '
-          : options.notMaterialized
-          ? 'NOT MATERIALIZED '
-          : ''
-      }(${inner})`,
-    );
-  });
+        let inner: string;
+        if (isRaw(query)) {
+          inner = getRaw(query, ctx.values);
+        } else {
+          inner = query.toSql({ values: ctx.values }).text;
+        }
+
+        return `${options.recursive ? 'RECURSIVE ' : ''}${q(name)}${
+          options.columns ? `(${options.columns.map(q).join(', ')})` : ''
+        } AS ${
+          options.materialized
+            ? 'MATERIALIZED '
+            : options.notMaterialized
+            ? 'NOT MATERIALIZED '
+            : ''
+        }(${inner})`;
+      })
+      .join(', '),
+  );
 };

package/src/utils.ts

@@ -38,24 +38,6 @@ export type UnionToOvlds<U> = UnionToIntersection<
   U extends any ? (f: U) => void : never
 >;
 
-type PopPropertyKeyUnion<U> = UnionToOvlds<U> extends (
-  a: infer A extends PropertyKey,
-) => void
-  ? A
-  : never;
-
-type IsUnion<T> = [T] extends [UnionToIntersection<T>] ? false : true;
-
-export type PropertyKeyUnionToArray<
-  T,
-  A extends PropertyKey[] = [],
-> = IsUnion<T> extends true
-  ? PropertyKeyUnionToArray<
-      Exclude<T, PopPropertyKeyUnion<T>>,
-      [PopPropertyKeyUnion<T>, ...A]
-    >
-  : [T, ...A];
-
 type OptionalPropertyNames<T> = {
   // eslint-disable-next-line @typescript-eslint/ban-types
   [K in keyof T]-?: {} extends { [P in K]: T[K] } ? K : never;