pqb 0.18.22 → 0.18.24

package/dist/index.d.ts

@@ -94,13 +94,13 @@ type RelationsBase = Record<string, RelationQueryBase>;
 type RelationQueryBase = Query & {
     relationConfig: RelationConfigBase;
 };
-type RelationQuery<Name extends PropertyKey = PropertyKey, Config extends RelationConfigBase = RelationConfigBase, T extends Query = Query, Q = {
+type RelationQuery<Name extends PropertyKey = PropertyKey, Config extends RelationConfigBase = RelationConfigBase, T extends Query = Query, Q extends Query = {
     [K in keyof T | 'relationConfig']: K extends 'meta' ? Omit<T['meta'], 'as'> & {
         as: StringKey<Name>;
         defaults: Record<Config['populate'], true>;
         hasWhere: true;
-    } : K extends 'join' ? <T extends Query>(this: T) => T : K extends CreateMethodsNames ? Config['chainedCreate'] extends true ? T[K] : never : K extends DeleteMethodsNames ? Config['chainedDelete'] extends true ? T[K] : never : K extends keyof T ? T[K] : Config;
-}> = ((params: Config['params']) => Q) & Q;
+    } : K extends 'join' ? <T extends Query>(this: T) => T : K extends CreateMethodsNames ? Config['chainedCreate'] extends true ? T[K] : never : K extends DeleteMethodsNames ? Config['chainedDelete'] extends true ? T[K] : never : K extends keyof T ? T[K] : K extends 'relationConfig' ? Config : never;
+}> = ((params: Config['params']) => Config['one'] extends true ? Config['required'] extends true ? SetQueryReturnsOne<Q> : SetQueryReturnsOneOptional<Q> : Q) & Q;
 
 declare const checkIfASimpleQuery: (q: Query) => boolean;
 type WithItem = [
@@ -3844,7 +3844,7 @@ declare class QueryLog {
 type MergeQuery<T extends Query, Q extends Query, ReturnType extends QueryReturnType = QueryReturnType extends Q['returnType'] ? T['returnType'] : Q['returnType'], Result extends ColumnsShapeBase = T['meta']['hasSelect'] extends true ? Q['meta']['hasSelect'] extends true ? {
     [K in keyof T['result'] | keyof Q['result']]: K extends keyof Q['result'] ? Q['result'][K] : T['result'][K];
 } : T['result'] : Q['result'], Data = GetQueryResult<ReturnType, Result>> = {
-    [K in keyof T]: K extends 'meta' ? MergeObjects<T['meta'], Q['meta']> : K extends 'result' ? Result : K extends 'returnType' ? ReturnType : K extends 'then' ? QueryThen<Data> : K extends 'catch' ? QueryCatch<Data> : K extends 'selectable' ? T['selectable'] & Q['selectable'] : K extends 'windows' ? MergeObjects<T['windows'], Q['windows']> : K extends 'withData' ? MergeObjects<T['withData'], Q['withData']> : T[K];
+    [K in keyof T]: K extends 'meta' ? MergeObjects<T['meta'], Q['meta']> : K extends 'result' ? Result : K extends 'returnType' ? ReturnType : K extends 'then' ? QueryThen<Data> : K extends 'catch' ? QueryCatch<Data> : K extends 'selectable' ? MergeObjects<T['selectable'], Q['selectable']> : K extends 'windows' ? MergeObjects<T['windows'], Q['windows']> : K extends 'withData' ? MergeObjects<T['withData'], Q['withData']> : T[K];
 };
 declare class MergeQueryMethods {
     merge<T extends Query, Q extends Query>(this: T, q: Q): MergeQuery<T, Q>;
@@ -3864,27 +3864,27 @@ declare function maybeWrappedThen(this: Query, resolve?: Resolve, reject?: Rejec
 declare const parseResult: (q: Query, parsers: ColumnsParsers | undefined, returnType: QueryReturnType | undefined, result: QueryResult, isSubQuery?: boolean) => unknown;
 declare const parseRecord: (parsers: ColumnsParsers, row: any) => any;
 
-type SelectArg<T extends Query> = '*' | StringKey<keyof T['selectable']> | SelectAsArg<T>;
+type SelectArg<T extends Query> = '*' | keyof T['selectable'];
 type SelectAsArg<T extends Query> = Record<string, SelectAsValue<T>>;
-type SelectAsValue<T extends Query> = StringKey<keyof T['selectable']> | Expression | ((q: T) => QueryBase) | ((q: T) => Expression) | ((q: T) => QueryBase | Expression);
-type SelectObjectResultTuple = [ColumnsShapeBase, SelectableBase];
-type SelectResult<T extends Query, Args extends SelectArg<T>[], SelectStringsResult extends ColumnsShapeBase = SelectStringArgsResult<T, Args>, StringsKeys extends keyof SelectStringsResult = keyof SelectStringsResult, SelectAsResult extends SelectObjectResultTuple = SpreadSelectObjectArgs<T, Args, [
-    EmptyObject,
-    T['selectable']
-]>, AsKeys extends keyof SelectAsResult[0] = keyof SelectAsResult[0], ResultKeys extends keyof T['result'] = T['meta']['hasSelect'] extends true ? keyof T['result'] : never, ShapeKeys extends keyof T['shape'] = '*' extends Args[number] ? keyof T['shape'] : never, Result extends ColumnsShapeBase = {
-    [K in StringsKeys | AsKeys | ResultKeys | ShapeKeys]: K extends StringsKeys ? SelectStringsResult[K] : K extends AsKeys ? SelectAsResult[0][K] : K extends ResultKeys ? T['result'][K] : K extends ShapeKeys ? T['shape'][K] : never;
-}, Data = GetQueryResult<T['returnType'], Result>> = (T['meta']['hasSelect'] extends true ? unknown : {
-    meta: {
-        hasSelect: true;
-    };
-}) & {
-    [K in keyof T]: K extends 'result' ? Result : K extends 'then' ? QueryThen<Data> : K extends 'catch' ? QueryCatch<Data> : K extends 'selectable' ? SelectAsResult[1] : T[K];
+type SelectAsValue<T extends Query> = StringKey<keyof T['selectable']> | Expression | ((q: SelectSubQueryArg<T>) => QueryBase | Expression);
+type SelectSubQueryArg<T extends Query> = {
+    [K in keyof T]: K extends keyof T['relations'] ? T[K] extends (...args: any) => any ? ReturnType<T[K]> : T[K] : T[K];
+};
+type SelectResult<T extends Query, Columns extends SelectArg<T>[], Result extends ColumnsShapeBase = {
+    [K in ('*' extends Columns[number] ? Exclude<Columns[number], '*'> | keyof T['shape'] : Columns[number]) | PrevResultKeys<T> as K extends keyof T['selectable'] ? T['selectable'][K]['as'] : K]: K extends keyof T['selectable'] ? T['selectable'][K]['column'] : K extends keyof T['result'] ? T['result'][K] : never;
+}, Data = GetQueryResult<T['returnType'], Result>> = {
+    [K in keyof T]: K extends 'meta' ? SetMetaHasSelect<T> : K extends 'result' ? Result : K extends 'then' ? QueryThen<Data> : K extends 'catch' ? QueryCatch<Data> : T[K];
+};
+type SelectResultWithObj<T extends Query, Columns extends SelectArg<T>[], Obj extends SelectAsArg<T>, Result extends ColumnsShapeBase = {
+    [K in ('*' extends Columns[number] ? Exclude<Columns[number], '*'> | keyof T['shape'] : Columns[number]) | keyof Obj | PrevResultKeys<T> as K extends keyof T['selectable'] ? T['selectable'][K]['as'] : K]: K extends keyof T['selectable'] ? T['selectable'][K]['column'] : K extends keyof Obj ? SelectAsValueResult<T, Obj[K]> : K extends keyof T['result'] ? T['result'][K] : never;
+}, Data = GetQueryResult<T['returnType'], Result>> = {
+    [K in keyof T]: K extends 'meta' ? SetMetaHasSelect<T> : K extends 'result' ? Result : K extends 'then' ? QueryThen<Data> : K extends 'catch' ? QueryCatch<Data> : K extends 'selectable' ? SelectAsSelectable<T, Obj> : T[K];
 };
-type SelectStringArgsResult<T extends Query, Args extends SelectArg<T>[]> = {
-    [Arg in Args[number] as Arg extends keyof T['selectable'] ? T['selectable'][Arg]['as'] : never]: Arg extends keyof T['selectable'] ? T['selectable'][Arg]['column'] : never;
+type PrevResultKeys<T extends Query> = T['meta']['hasSelect'] extends true ? keyof T['result'] : never;
+type SetMetaHasSelect<T extends Query> = T['meta']['hasSelect'] extends true ? T['meta'] : {
+    [K in keyof T['meta'] | 'hasSelect']: K extends 'hasSelect' ? true : T['meta'][K];
 };
-type SpreadSelectObjectArgs<T extends Query, Args extends [...unknown[]], Result extends SelectObjectResultTuple> = Args extends [infer L, ...infer R] ? SpreadSelectObjectArgs<T, R, SelectAsResult<T, L, Result>> : Result;
-type SelectAsResult<T extends Query, Arg, Result extends SelectObjectResultTuple, Shape = Result[0], AddSelectable extends SelectableBase = {
+type SelectAsSelectable<T extends Query, Arg extends SelectAsArg<T>> = {
     [K in keyof Arg]: Arg[K] extends ((q: never) => infer R extends QueryBase) ? (x: {
         [C in keyof R['result'] as `${StringKey<K>}.${StringKey<C>}`]: {
             as: C;
@@ -3892,13 +3892,8 @@ type SelectAsResult<T extends Query, Arg, Result extends SelectObjectResultTuple
         };
     }) => void : never;
 }[keyof Arg] extends (x: infer I) => void ? {
-    [K in keyof I]: I[K];
-} : never> = Arg extends SelectAsArg<T> ? [
-    {
-        [K in keyof Shape | keyof Arg]: K extends keyof Arg ? SelectAsValueResult<T, Arg[K]> : K extends keyof Shape ? Shape[K] : never;
-    },
-    Result[1] & AddSelectable
-] : Result;
+    [K in keyof T['selectable'] | keyof I]: K extends keyof I ? I[K] : T['selectable'][K];
+} : never;
 type SelectAsValueResult<T extends Query, Arg extends SelectAsValue<T>> = Arg extends keyof T['selectable'] ? T['selectable'][Arg]['column'] : Arg extends Expression ? Arg['_type'] : Arg extends (q: never) => infer R ? R extends QueryBase ? SelectSubQueryResult<R> : R extends Expression ? R['_type'] : R extends QueryBase | Expression ? SelectSubQueryResult<Exclude<R, Expression>> | Exclude<R, QueryBase>['_type'] : never : never;
 type SelectSubQueryResult<Arg extends QueryBase> = QueryReturnsAll<Arg['returnType']> extends true ? ArrayOfColumnsObjects<Arg['result']> : Arg['returnType'] extends 'valueOrThrow' ? Arg['result']['value'] : Arg['returnType'] extends 'pluck' ? PluckResultColumnType<Arg['result']['pluck']> : Arg extends {
     relationConfig: {
@@ -3914,7 +3909,7 @@ declare class Select {
     /**
      * Takes a list of columns to be selected, and by default, the query builder will select all columns of the table.
      *
-     * Pass an object to select columns with aliases. Keys of the object are column aliases, value can be a column name, sub-query, or raw expression.
+     * The last argument can be an object. Keys of the object are column aliases, value can be a column name, sub-query, or raw SQL expression.
      *
      * ```ts
      * // select columns of the table:
@@ -3967,8 +3962,10 @@ declare class Select {
      *   .where({ 'author.isPopular': true });
      * ```
      */
-    select<T extends Query, K extends SelectArg<T>[]>(this: T, ...args: K): SelectResult<T, K>;
-    _select<T extends Query, K extends SelectArg<T>[]>(this: T, ...args: K): SelectResult<T, K>;
+    select<T extends Query, Columns extends SelectArg<T>[]>(this: T, ...args: Columns): SelectResult<T, Columns>;
+    select<T extends Query, Columns extends SelectArg<T>[], Obj extends SelectAsArg<T>>(this: T, ...args: [...columns: Columns, obj: Obj]): SelectResultWithObj<T, Columns, Obj>;
+    _select<T extends Query, Columns extends SelectArg<T>[]>(this: T, ...args: Columns): SelectResult<T, Columns>;
+    _select<T extends Query, Columns extends SelectArg<T>[], Obj extends SelectAsArg<T>>(this: T, ...args: [...columns: Columns, obj: Obj]): SelectResultWithObj<T, Columns, Obj>;
     /**
      * When querying the table or creating records, all columns are selected by default,
      * but updating and deleting queries are returning affected row counts by default.

package/dist/index.js

@@ -6013,76 +6013,18 @@ const maybeUnNameColumn = (column, isSubQuery) => {
   return isSubQuery && column.data.name ? orchidCore.setColumnData(column, "name", void 0) : column;
 };
 class Select {
-  /**
-   * Takes a list of columns to be selected, and by default, the query builder will select all columns of the table.
-   *
-   * Pass an object to select columns with aliases. Keys of the object are column aliases, value can be a column name, sub-query, or raw expression.
-   *
-   * ```ts
-   * // select columns of the table:
-   * db.table.select('id', 'name', { idAlias: 'id' });
-   *
-   * // accepts columns with table names:
-   * db.table.select('user.id', 'user.name', { nameAlias: 'user.name' });
-   *
-   * // table name may refer to the current table or a joined table:
-   * db.table
-   *   .join(Message, 'authorId', 'id')
-   *   .select('user.name', 'message.text', { textAlias: 'message.text' });
-   *
-   * // select value from the sub-query,
-   * // this sub-query should return a single record and a single column:
-   * db.table.select({
-   *   subQueryResult: Otherdb.table.select('column').take(),
-   * });
-   *
-   * // select raw SQL value, the first argument of `raw` is a column type, it is used for return type of the query
-   * db.table.select({
-   *   raw: db.table.sql((t) => t.integer())`1 + 2`,
-   * });
-   *
-   * // same raw SQL query as above, but raw value is returned from a callback
-   * db.table.select({
-   *   raw: (q) => q.sql((t) => t.integer())`1 + 2`,
-   * });
-   * ```
-   *
-   * When you use the ORM and defined relations, `select` can also accept callbacks with related table queries:
-   *
-   * ```ts
-   * await db.author.select({
-   *   allBooks: (q) => q.books,
-   *   firstBook: (q) => q.books.order({ createdAt: 'ASC' }).take(),
-   *   booksCount: (q) => q.books.count(),
-   * });
-   * ```
-   *
-   * When you're selecting a relation that's connected via `belongsTo` or `hasOne`, it becomes available to use in `order` or in `where`:
-   *
-   * ```ts
-   * // select books with their authors included, order by author name and filter by author column:
-   * await db.books
-   *   .select({
-   *     author: (q) => q.author,
-   *   })
-   *   .order('author.name')
-   *   .where({ 'author.isPopular': true });
-   * ```
-   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   select(...args) {
     return this.clone()._select(...args);
   }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   _select(...args) {
     if (!args.length) {
       return this;
     }
     const as = this.q.as || this.table;
     const selectArgs = args.map((item) => processSelectArg(this, as, item));
-    return pushQueryArray(
-      this,
-      "select",
-      selectArgs
-    );
+    return pushQueryArray(this, "select", selectArgs);
   }
   /**
    * When querying the table or creating records, all columns are selected by default,