pqb 0.25.1 → 0.26.1

package/dist/index.d.ts

@@ -264,7 +264,7 @@ type OnConflictItem = string | string[] | Expression;
 type OnConflictMergeUpdate = string | string[] | RecordUnknown | Expression;
 
 type BooleanQueryColumn = QueryColumn<boolean, OperatorsBoolean>;
-declare class BooleanColumn$1<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, boolean, Schema['boolean'], OperatorsBoolean> {
+declare class BooleanColumn$1<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, boolean, ReturnType<Schema['boolean']>, OperatorsBoolean> {
     dataType: "boolean";
     operators: OperatorsBoolean;
     constructor(schema: Schema);
@@ -863,6 +863,35 @@ declare class Join {
      *
      * When no matching record is found, it will skip records of the main table.
      *
+     * When joining the same table with the same condition more than once, duplicated joins will be ignored:
+     *
+     * ```ts
+     * // joining a relation
+     * db.post.join('comments').join('comments');
+     *
+     * // joining a table with a condition
+     * db.post
+     *   .join('comments', 'comments.postId', 'post.id')
+     *   .join('comments', 'comments.postId', 'post.id');
+     * ```
+     *
+     * Both queries will produce SQL with only 1 join
+     *
+     * ```sql
+     * SELECT * FROM post JOIN comments ON comments.postId = post.id
+     * ```
+     *
+     * However, this is only possible if the join has no dynamic values:
+     *
+     * ```ts
+     * db.post
+     *   .join('comments', (q) => q.where({ rating: { gt: 5 } }))
+     *   .join('comments', (q) => q.where({ rating: { gt: 5 } }));
+     * ```
+     *
+     * Both joins above have the same `{ gt: 5 }`, but still, the `5` is a dynamic value and in this case joins will be duplicated,
+     * resulting in a database error.
+     *
      * ### join relation
      *
      * When relations are defined between the tables, you can join them by a relation name.
@@ -2081,7 +2110,7 @@ declare class ScopeMethods {
 }
 
 type DateColumnInput = string | number | Date;
-declare abstract class DateBaseColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, string, Schema['stringNumberDate'], OperatorsDate, DateColumnInput, string, Schema['stringSchema']> {
+declare abstract class DateBaseColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, string, ReturnType<Schema['stringNumberDate']>, OperatorsDate, DateColumnInput, string, ReturnType<Schema['stringSchema']>> {
     data: DateColumnData;
     operators: OperatorsDate;
     encodeFn: (input: DateColumnInput) => string | Date;
@@ -2113,7 +2142,7 @@ declare class TimestampTZColumn<Schema extends ColumnSchemaConfig> extends DateT
     baseDataType: "timestamp";
     toCode(t: string): Code;
 }
-declare class TimeColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, string, Schema['stringSchema'], OperatorsTime> {
+declare class TimeColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, string, ReturnType<Schema['stringSchema']>, OperatorsTime> {
     data: DateColumnData & {
         dateTimePrecision?: number;
     };
@@ -2122,7 +2151,7 @@ declare class TimeColumn<Schema extends ColumnSchemaConfig> extends ColumnType<S
     constructor(schema: Schema, dateTimePrecision?: number);
     toCode(t: string): Code;
 }
-declare class IntervalColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, TimeInterval, Schema['timeInterval'], OperatorsDate> {
+declare class IntervalColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, TimeInterval, ReturnType<Schema['timeInterval']>, OperatorsDate> {
     data: ColumnData & {
         fields?: string;
         precision?: number;
@@ -2165,7 +2194,7 @@ declare class JSONColumn<T, Schema extends ColumnTypeSchemaArg> extends ColumnTy
     operators: OperatorsJson;
     toCode(t: string): Code;
 }
-declare class JSONTextColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, string, Schema['stringSchema'], OperatorsText> {
+declare class JSONTextColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, string, ReturnType<Schema['stringSchema']>, OperatorsText> {
     dataType: "json";
     operators: OperatorsText;
     constructor(schema: Schema);
@@ -2173,10 +2202,10 @@ declare class JSONTextColumn<Schema extends ColumnSchemaConfig> extends ColumnTy
 }
 
 type TextColumnData = StringTypeData;
-declare abstract class TextBaseColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, string, Schema['stringSchema'], OperatorsText> {
+declare abstract class TextBaseColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, string, ReturnType<Schema['stringSchema']>, OperatorsText> {
     data: TextColumnData;
     operators: OperatorsText;
-    constructor(schema: Schema, schemaType?: Schema['stringSchema']);
+    constructor(schema: Schema, schemaType?: ReturnType<Schema['stringSchema']>);
 }
 declare abstract class LimitedTextBaseColumn<Schema extends ColumnSchemaConfig> extends TextBaseColumn<Schema> {
     data: TextColumnData & {
@@ -2206,55 +2235,55 @@ declare class TextColumn<Schema extends ColumnSchemaConfig> extends TextBaseColu
     constructor(schema: Schema, min?: number, max?: number);
     toCode(t: string): Code;
 }
-declare class ByteaColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, Buffer, Schema['buffer'], OperatorsText> {
+declare class ByteaColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, Buffer, ReturnType<Schema['buffer']>, OperatorsText> {
     dataType: "bytea";
     operators: OperatorsText;
     constructor(schema: Schema);
     toCode(t: string): Code;
 }
-declare class PointColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, string, Schema['stringSchema'], OperatorsText> {
+declare class PointColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, string, ReturnType<Schema['stringSchema']>, OperatorsText> {
     dataType: "point";
     operators: OperatorsText;
     constructor(schema: Schema);
     toCode(t: string): Code;
 }
-declare class LineColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, string, Schema['stringSchema'], OperatorsText> {
+declare class LineColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, string, ReturnType<Schema['stringSchema']>, OperatorsText> {
     dataType: "line";
     operators: OperatorsText;
     constructor(schema: Schema);
     toCode(t: string): Code;
 }
-declare class LsegColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, string, Schema['stringSchema'], OperatorsText> {
+declare class LsegColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, string, ReturnType<Schema['stringSchema']>, OperatorsText> {
     dataType: "lseg";
     operators: OperatorsText;
     constructor(schema: Schema);
     toCode(t: string): Code;
 }
-declare class BoxColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, string, Schema['stringSchema'], OperatorsText> {
+declare class BoxColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, string, ReturnType<Schema['stringSchema']>, OperatorsText> {
     dataType: "box";
     operators: OperatorsText;
     constructor(schema: Schema);
     toCode(t: string): Code;
 }
-declare class PathColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, string, Schema['stringSchema'], OperatorsText> {
+declare class PathColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, string, ReturnType<Schema['stringSchema']>, OperatorsText> {
     dataType: "path";
     operators: OperatorsText;
     constructor(schema: Schema);
     toCode(t: string): Code;
 }
-declare class PolygonColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, string, Schema['stringSchema'], OperatorsText> {
+declare class PolygonColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, string, ReturnType<Schema['stringSchema']>, OperatorsText> {
     dataType: "polygon";
     operators: OperatorsText;
     constructor(schema: Schema);
     toCode(t: string): Code;
 }
-declare class CircleColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, string, Schema['stringSchema'], OperatorsText> {
+declare class CircleColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, string, ReturnType<Schema['stringSchema']>, OperatorsText> {
     dataType: "circle";
     operators: OperatorsText;
     constructor(schema: Schema);
     toCode(t: string): Code;
 }
-declare class MoneyColumn<Schema extends ColumnSchemaConfig> extends NumberBaseColumn<Schema, Schema['stringSchema']> {
+declare class MoneyColumn<Schema extends ColumnSchemaConfig> extends NumberBaseColumn<Schema, ReturnType<Schema['stringSchema']>> {
     dataType: "money";
     constructor(schema: Schema);
     toCode(t: string): Code;
@@ -2262,25 +2291,25 @@ declare class MoneyColumn<Schema extends ColumnSchemaConfig> extends NumberBaseC
         hideFromCode: boolean;
     };
 }
-declare class CidrColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, string, Schema['stringSchema'], OperatorsText> {
+declare class CidrColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, string, ReturnType<Schema['stringSchema']>, OperatorsText> {
     dataType: "cidr";
     operators: OperatorsText;
     constructor(schema: Schema);
     toCode(t: string): Code;
 }
-declare class InetColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, string, Schema['stringSchema'], OperatorsText> {
+declare class InetColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, string, ReturnType<Schema['stringSchema']>, OperatorsText> {
     dataType: "inet";
     operators: OperatorsText;
     constructor(schema: Schema);
     toCode(t: string): Code;
 }
-declare class MacAddrColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, string, Schema['stringSchema'], OperatorsText> {
+declare class MacAddrColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, string, ReturnType<Schema['stringSchema']>, OperatorsText> {
     dataType: "macaddr";
     operators: OperatorsText;
     constructor(schema: Schema);
     toCode(t: string): Code;
 }
-declare class MacAddr8Column<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, string, Schema['stringSchema'], OperatorsText> {
+declare class MacAddr8Column<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, string, ReturnType<Schema['stringSchema']>, OperatorsText> {
     dataType: "macaddr8";
     operators: OperatorsText;
     constructor(schema: Schema);
@@ -2307,7 +2336,7 @@ declare class BitVaryingColumn<Schema extends ColumnSchemaConfig> extends Column
     toSQL(): string;
 }
 type TsVectorGeneratedColumns = string[] | Record<string, SearchWeight>;
-declare class TsVectorColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, string, Schema['stringSchema'], OperatorsText> {
+declare class TsVectorColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, string, ReturnType<Schema['stringSchema']>, OperatorsText> {
     defaultLanguage: string;
     dataType: "tsvector";
     operators: OperatorsText;
@@ -2339,13 +2368,13 @@ declare class TsVectorColumn<Schema extends ColumnSchemaConfig> extends ColumnTy
      */
     generated<T extends PickColumnData>(this: T, ...args: StaticSQLArgs | [language: string, columns: TsVectorGeneratedColumns] | [columns: TsVectorGeneratedColumns]): T;
 }
-declare class TsQueryColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, string, Schema['stringSchema'], OperatorsText> {
+declare class TsQueryColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, string, ReturnType<Schema['stringSchema']>, OperatorsText> {
     dataType: "tsquery";
     operators: OperatorsText;
     constructor(schema: Schema);
     toCode(t: string): Code;
 }
-declare class UUIDColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, string, Schema['uuid'], OperatorsText> {
+declare class UUIDColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, string, ReturnType<Schema['uuid']>, OperatorsText> {
     dataType: "uuid";
     operators: OperatorsText;
     constructor(schema: Schema);
@@ -2357,7 +2386,7 @@ declare class UUIDColumn<Schema extends ColumnSchemaConfig> extends ColumnType<S
     };
     toCode(t: string): Code;
 }
-declare class XMLColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, string, Schema['stringSchema'], OperatorsText> {
+declare class XMLColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, string, ReturnType<Schema['stringSchema']>, OperatorsText> {
     dataType: "xml";
     operators: OperatorsText;
     constructor(schema: Schema);
@@ -2373,7 +2402,7 @@ declare class CitextColumn<Schema extends ColumnSchemaConfig> extends TextBaseCo
     toCode(t: string): Code;
 }
 
-declare class CustomTypeColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, unknown, Schema['unknown'], typeof Operators.any> {
+declare class CustomTypeColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, unknown, ReturnType<Schema['unknown']>, typeof Operators.any> {
     dataType: string;
     operators: OperatorsAny;
     constructor(schema: Schema, dataType: string);
@@ -2530,16 +2559,16 @@ declare abstract class NumberBaseColumn<Schema extends ColumnSchemaConfig, Schem
     data: NumberColumnData;
     operators: OperatorsNumber;
 }
-declare abstract class IntegerBaseColumn<Schema extends ColumnSchemaConfig> extends NumberBaseColumn<Schema, Schema['int']> {
+declare abstract class IntegerBaseColumn<Schema extends ColumnSchemaConfig> extends NumberBaseColumn<Schema, ReturnType<Schema['int']>> {
     data: NumberColumnData;
     constructor(schema: Schema);
 }
-declare abstract class NumberAsStringBaseColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, string, Schema['stringSchema'], OperatorsNumber> {
+declare abstract class NumberAsStringBaseColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, string, ReturnType<Schema['stringSchema']>, OperatorsNumber> {
     operators: OperatorsNumber;
     data: ColumnData;
     constructor(schema: Schema);
 }
-declare class DecimalColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, string, Schema['stringSchema'], OperatorsNumber> {
+declare class DecimalColumn<Schema extends ColumnSchemaConfig> extends ColumnType<Schema, string, ReturnType<Schema['stringSchema']>, OperatorsNumber> {
     data: ColumnData & {
         numericPrecision?: number;
         numericScale?: number;
@@ -2568,7 +2597,7 @@ declare class BigIntColumn<Schema extends ColumnSchemaConfig> extends NumberAsSt
     toCode(t: string): Code;
     identity<T extends ColumnType>(this: T, options?: TableData.Identity): IdentityColumn<T>;
 }
-declare class RealColumn<Schema extends ColumnSchemaConfig> extends NumberBaseColumn<Schema, Schema['number']> {
+declare class RealColumn<Schema extends ColumnSchemaConfig> extends NumberBaseColumn<Schema, ReturnType<Schema['number']>> {
     dataType: "real";
     parseItem: typeof parseFloat;
     constructor(schema: Schema);
@@ -2840,7 +2869,7 @@ interface DbResult<ColumnTypes> extends Db<string, Record<string, never>, EmptyO
     close: Adapter['close'];
 }
 /**
- * For the case of using the query builder as a standalone tool, use `createDb` from `pqb` package.
+ * For the case of using the query builder as a standalone tool, use `createDb`.
  *
  * As `Orchid ORM` focuses on ORM usage, docs examples mostly demonstrates how to work with ORM-defined tables,
  * but everything that's not related to table relations should also work with `pqb` query builder on its own.
@@ -2850,6 +2879,10 @@ interface DbResult<ColumnTypes> extends Db<string, Record<string, never>, EmptyO
  * ```ts
  * import { createDb } from 'orchid-orm';
  *
+ * import { zodSchemaConfig } from 'orchid-orm-schema-to-zod';
+ * // or
+ * import { SchemaConfig } from 'orchid-orm-valibot';
+ *
  * const db = createDb({
  *   // db connection options
  *   databaseURL: process.env.DATABASE_URL,
@@ -2861,6 +2894,11 @@ interface DbResult<ColumnTypes> extends Db<string, Record<string, never>, EmptyO
  *   // override default SQL for timestamp, see `nowSQL` above
  *   nowSQL: `now() AT TIME ZONE 'UTC'`,
  *
+ *   // optional, but recommended: makes zod schemas for your tables
+ *   schemaConfig: zodSchemaConfig,
+ *   // or
+ *   schemaConfig: valibotSchemaConfig,
+ *
  *   // override column types:
  *   columnTypes: (t) => ({
  *     // by default timestamp is returned as a string, override to a number
@@ -6966,7 +7004,7 @@ interface ColumnsShapeToObjectArray<Shape extends QueryColumns> {
     operators: OperatorsAny;
 }
 
-declare abstract class VirtualColumn<Schema extends ColumnSchemaConfig, InputSchema extends Schema['type'] = Schema['never']> extends ColumnType<Schema, unknown, InputSchema, OperatorsAny> {
+declare abstract class VirtualColumn<Schema extends ColumnSchemaConfig, InputSchema extends Schema['type'] = ReturnType<Schema['never']>> extends ColumnType<Schema, unknown, InputSchema, OperatorsAny> {
     dataType: string;
     operators: OperatorsAny;
     constructor(schema: Schema, inputSchema?: InputSchema);