pqb 0.10.34 → 0.10.35

package/dist/index.d.ts

@@ -531,7 +531,6 @@ declare type WhereArg<T extends QueryBase> = (Omit<{
         columns: (keyof T['selectable'])[];
         values: unknown[][] | Query | RawExpression;
     }>;
-    EXISTS?: MaybeArray<[JoinFirstArg<T>, ...JoinArgs<T, Query>] | [JoinFirstArg<T>, JoinCallback<T, JoinFirstArg<T>>]>;
 }) | QueryBase | RawExpression | ((q: WhereQueryBuilder<T>) => WhereQueryBuilder);
 declare type WhereInColumn<T extends QueryBase> = keyof T['selectable'] | [keyof T['selectable'], ...(keyof T['selectable'])[]];
 declare type WhereInValues<T extends QueryBase, Column extends WhereInColumn<T>> = Column extends keyof T['selectable'] ? T['selectable'][Column]['column']['type'][] | Query | RawExpression : ({
@@ -593,9 +592,9 @@ declare abstract class Where implements QueryBase {
     orWhereNotIn<T extends Where>(this: T, arg: WhereInArg<T>): WhereResult<T>;
     _orWhereNotIn<T extends Where, Column extends WhereInColumn<T>>(this: T, column: Column, values: WhereInValues<T, Column>): WhereResult<T>;
     _orWhereNotIn<T extends Where>(this: T, arg: WhereInArg<T>): WhereResult<T>;
-    whereExists<T extends Where, Arg extends JoinFirstArg<T>, Args extends JoinArgs<T, Arg>>(this: T, arg: Arg, ...args: Args): WhereResult<T>;
+    whereExists<T extends Where, Arg extends JoinFirstArg<T>>(this: T, arg: Arg, ...args: JoinArgs<T, Arg>): WhereResult<T>;
     whereExists<T extends Where, Arg extends JoinFirstArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): WhereResult<T>;
-    _whereExists<T extends Where, Arg extends JoinFirstArg<T>, Args extends JoinArgs<T, Arg>>(this: T, arg: Arg, ...args: Args): WhereResult<T>;
+    _whereExists<T extends Where, Arg extends JoinFirstArg<T>>(this: T, arg: Arg, ...args: JoinArgs<T, Arg>): WhereResult<T>;
     _whereExists<T extends Where, Arg extends JoinFirstArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): WhereResult<T>;
     orWhereExists<T extends Where, Arg extends JoinFirstArg<T>, Args extends JoinArgs<T, Arg>>(this: T, arg: Arg, ...args: Args): WhereResult<T>;
     orWhereExists<T extends Where, Arg extends JoinFirstArg<T>>(this: T, arg: Arg, cb: JoinCallback<T, Arg>): WhereResult<T>;
@@ -624,16 +623,17 @@ declare class WhereQueryBuilder<Q extends QueryBase = QueryBase> extends Where i
 declare type WithSelectable<T extends QueryBase, W extends keyof T['withData']> = T['withData'][W] extends WithDataItem ? StringKey<keyof T['withData'][W]['shape']> | `${T['withData'][W]['table']}.${StringKey<keyof T['withData'][W]['shape']>}` : never;
 declare type JoinFirstArg<T extends QueryBase> = Query | keyof T['relations'] | keyof T['withData'];
 declare type JoinArgs<T extends QueryBase, Arg extends JoinFirstArg<T>> = Arg extends Query ? JoinQueryArgs<T, Arg> : Arg extends keyof T['relations'] ? EmptyTuple : Arg extends keyof T['withData'] ? JoinWithArgs<T, Arg> : never;
-declare type JoinQueryArgs<T extends QueryBase, Q extends Query, JoinSelectable extends PropertyKey = keyof Q['result'] | `${AliasOrTable<Q>}.${StringKey<keyof Q['result']>}`> = [
-    conditions: Record<JoinSelectable, Selectable<T> | RawExpression> | RawExpression
+declare type JoinSelectable<Q extends Query> = keyof Q['result'] | `${AliasOrTable<Q>}.${StringKey<keyof Q['result']>}`;
+declare type JoinQueryArgs<T extends QueryBase, Q extends Query> = [
+    conditions: Record<JoinSelectable<Q>, Selectable<T> | RawExpression> | RawExpression | true
 ] | [
-    leftColumn: JoinSelectable | RawExpression,
+    leftColumn: JoinSelectable<Q> | RawExpression,
     rightColumn: Selectable<T> | RawExpression
 ] | [
-    leftColumn: JoinSelectable | RawExpression,
+    leftColumn: JoinSelectable<Q> | RawExpression,
     op: string,
     rightColumn: Selectable<T> | RawExpression
-] | [conditions: true];
+];
 declare type JoinWithArgs<T extends QueryBase, W extends keyof T['withData']> = [
     conditions: Record<WithSelectable<T, W>, Selectable<T> | RawExpression> | RawExpression
 ] | [
@@ -1315,8 +1315,10 @@ declare type WindowArgDeclaration<T extends Query = Query> = {
     order?: OrderArg<T>;
 };
 declare type WindowResult<T extends Query, W extends WindowArg<T>> = SetQueryWindows<T, Record<keyof W, true>>;
-declare type OrderArg<T extends Query> = keyof T['selectable'] | {
-    [K in Selectable<T>]?: SortDir;
+declare type OrderArg<T extends Query, Key extends PropertyKey = keyof T['selectable'] | {
+    [K in keyof T['result']]: T['result'][K]['dataType'] extends 'array' | 'object' ? never : K;
+}[keyof T['result']]> = Key | {
+    [K in Key]?: SortDir;
 } | RawExpression;
 interface QueryMethods extends Aggregate, Select, From, Join, With, Union, Json, Create, Update, Delete, Transaction, For, ColumnInfoMethods, Where, Clear, Having, Window, Then, QueryLog, QueryCallbacks, QueryUpsertOrCreate, QueryGet, MergeQueryMethods, RawMethods, CopyMethods {
 }

package/dist/index.js

@@ -173,7 +173,7 @@ const getJoinedColumnName = (data, shape, table, key, isOwnColumn) => {
   return (_c = (isOwnColumn ? shape[key] : void 0) || ((_b = (_a = data.joinedShapes) == null ? void 0 : _a[table]) == null ? void 0 : _b[key])) == null ? void 0 : _c.data.name;
 };
 const revealColumnToSql = (data, shape, column, quotedAs) => {
-  var _a, _b;
+  var _a;
   const index = column.indexOf(".");
   if (index !== -1) {
     const table = column.slice(0, index);
@@ -182,10 +182,10 @@ const revealColumnToSql = (data, shape, column, quotedAs) => {
     return `${quoted}.${q(
       getJoinedColumnName(data, shape, table, key, quoted === quotedAs) || key
     )}`;
-  } else if (quotedAs) {
-    return `${quotedAs}.${q(((_a = shape[column]) == null ? void 0 : _a.data.name) || column)}`;
+  } else if (quotedAs && shape[column]) {
+    return `${quotedAs}.${q(shape[column].data.name || column)}`;
   } else {
-    return q(((_b = shape[column]) == null ? void 0 : _b.data.name) || column);
+    return q(((_a = shape[column]) == null ? void 0 : _a.data.name) || column);
   }
 };
 const revealColumnToSqlWithAs = (data, column, quotedAs) => {
@@ -1683,7 +1683,7 @@ const processJoinItem = (ctx, table, query, item, quotedAs) => {
     let joinAs = quotedFrom || q(first.table);
     const qAs = joinQuery.as ? q(joinQuery.as) : void 0;
     const addAs = qAs && qAs !== joinAs;
-    let joinedShape;
+    const joinedShape = first.shape;
     if (item.isSubQuery) {
       const subQuery = first.toSql({
         values: ctx.values
@@ -1691,9 +1691,7 @@ const processJoinItem = (ctx, table, query, item, quotedAs) => {
       target = `(${subQuery.text}) ${qAs || joinAs}`;
       if (addAs)
         joinAs = qAs;
-      joinedShape = orchidCore.emptyObject;
     } else {
-      joinedShape = first.shape;
       if (addAs) {
         joinAs = qAs;
         target += ` AS ${qAs}`;
@@ -1970,22 +1968,20 @@ const processWhere = (ands, ctx, table, query, data, quotedAs, not) => {
       });
     } else if (key === "EXISTS") {
       const joinItems = Array.isArray(value[0]) ? value : [value];
-      joinItems.forEach((args) => {
-        const q2 = args[0];
-        const { target, conditions } = processJoinItem(
-          ctx,
-          table,
-          query,
-          {
+      joinItems.forEach(
+        (args) => {
+          const { target, conditions } = processJoinItem(
+            ctx,
+            table,
+            query,
             args,
-            isSubQuery: typeof q2 === "object" && getIsJoinSubQuery(q2.query, q2.baseQuery.query)
-          },
-          quotedAs
-        );
-        ands.push(
-          `${prefix}EXISTS (SELECT 1 FROM ${target} WHERE ${conditions} LIMIT 1)`
-        );
-      });
+            quotedAs
+          );
+          ands.push(
+            `${prefix}EXISTS (SELECT 1 FROM ${target} WHERE ${conditions} LIMIT 1)`
+          );
+        }
+      );
     } else if (typeof value === "object" && value !== null) {
       if (orchidCore.isRaw(value)) {
         ands.push(
@@ -5031,6 +5027,25 @@ const addWhereIn = (q, and, arg, values, not) => {
   }
   return q;
 };
+const existsArgs = (args) => {
+  const q = args[0];
+  let isSubQuery;
+  if (typeof q === "object") {
+    isSubQuery = getIsJoinSubQuery(q.query, q.baseQuery.query);
+    if (isSubQuery) {
+      args[0] = q.clone();
+      args[0].shape = getShapeFromSelect(q, true);
+    }
+  } else {
+    isSubQuery = false;
+  }
+  return {
+    EXISTS: {
+      args,
+      isSubQuery
+    }
+  };
+};
 class Where {
   constructor() {
     this.query = {};
@@ -5105,25 +5120,25 @@ class Where {
     return this.clone()._whereExists(arg, ...args);
   }
   _whereExists(...args) {
-    return this._where({ EXISTS: args });
+    return this._where(existsArgs(args));
   }
   orWhereExists(arg, ...args) {
     return this.clone()._orWhereExists(arg, ...args);
   }
   _orWhereExists(...args) {
-    return this._or({ EXISTS: args });
+    return this._or(existsArgs(args));
   }
   whereNotExists(arg, ...args) {
     return this.clone()._whereNotExists(arg, ...args);
   }
   _whereNotExists(...args) {
-    return this._whereNot({ EXISTS: args });
+    return this._whereNot(existsArgs(args));
   }
   orWhereNotExists(arg, ...args) {
     return this.clone()._orWhereNotExists(arg, ...args);
   }
   _orWhereNotExists(...args) {
-    return this._orNot({ EXISTS: args });
+    return this._orNot(existsArgs(args));
   }
 }
 const emptyInternal = {
@@ -5165,6 +5180,10 @@ const _join = (q, type, args) => {
     if (joinKey) {
       shape = getShapeFromSelect(first, isSubQuery);
       parsers = first.query.parsers;
+      if (isSubQuery) {
+        args[0] = first.clone();
+        args[0].shape = shape;
+      }
     }
   } else {
     joinKey = first;