pqb 0.67.7 → 0.68.1

package/dist/internal.d.ts

@@ -14,7 +14,6 @@ interface RelationConfigBase$1 extends IsQuery$1 {
   queryRelated(params: unknown): unknown;
   modifyRelatedQuery?(relatedQuery: IsQuery$1): (query: IsQuery$1) => void;
   omitForeignKeyInCreate: PropertyKey;
-  dataForCreate: unknown;
   dataForUpdate: unknown;
   dataForUpdateOne: unknown;
   primaryKeys: string[];
@@ -24,7 +23,13 @@ interface RelationConfigDataForCreate {
   nested: RecordUnknown$1;
 }
 interface RelationsBase$1 {
-  [K: string]: RelationConfigBase$1;
+  [relationName: string]: RelationConfigBase$1;
+}
+interface RelationsDataForCreateBase {
+  [relationName: string]: unknown;
+}
+interface RelationsDataForCreateOptionalBase {
+  [relationName: string]: unknown;
 }
 type RelationQueryMaybeSingle<T extends RelationConfigBase$1> = T['returnsOne'] extends true ? T['required'] extends true ? QueryManyTake$1<T['query']> : QueryManyTakeOptional$1<T['query']> : T['query'];
 interface SubQueryForSql extends ToSQLQuery {
@@ -34,6 +39,17 @@ interface HasBeforeAndBeforeSet {
   before?: QueryBeforeHook$1[];
   beforeSet?: QueryData$1['beforeSet'];
 }
+interface SqlJoinExpression<T extends Column$1.Pick.QueryColumn> extends Expression$1<T>, ExpressionTypeMethod {}
+declare class SqlJoinExpression<T extends Column$1.Pick.QueryColumn = Column$1.Pick.QueryColumn> extends Expression$1<T> {
+  items: readonly unknown[];
+  separator?: RawSqlBase$1 | undefined;
+  result: {
+    value: T;
+  };
+  q: ExpressionData$1;
+  constructor(items: readonly unknown[], separator?: RawSqlBase$1 | undefined);
+  makeSQL(ctx: ToSqlValues$1, quotedAs?: string): string;
+}
 /**
  * Expression for a SQL identifier reference.
  * Used to safely quote identifiers in raw SQL queries.
@@ -2071,6 +2087,37 @@ declare class DynamicRawSQL$1<T extends Column$1.Pick.QueryColumn, ColumnTypes =
 }
 interface SqlFn$1 {
   <T, Args extends TemplateLiteralArgs$1 | [sql: string] | [values: RecordUnknown$1, sql?: string]>(this: T, ...args: Args): Args extends [RecordUnknown$1] ? (...sql: TemplateLiteralArgs$1) => RawSql$1<Column$1.Pick.QueryColumn, T> : RawSql$1<Column$1.Pick.QueryColumn, T>;
+  /**
+   * `sql.join` builds a SQL list from values and expressions.
+   * Plain values are bound as query parameters, while SQL expressions render as SQL.
+   *
+   * Use it for SQL constructs such as `ARRAY[...]`, `IN (...)`, function arguments,
+   * or tuple lists. The default separator is `, `. Provide a SQL expression as the
+   * custom separator when a different separator is needed.
+   *
+   * ```ts
+   * await db.user.whereSql`"id" IN (${sql.join([1, 2, 3])})`;
+   * ```
+   *
+   * ```ts
+   * await db.user.whereSql`
+   *   (${sql.join([sql.ref('name'), sql.ref('age')])}) IN (${sql.join(
+   *     users.map((user) => sql`(${user.name}, ${user.age})`),
+   *   )})
+   * `;
+   * ```
+   *
+   * ```ts
+   * await db.user.select({
+   *   displayName: (q) =>
+   *     sql<string>`concat(${sql.join(
+   *       [q.column('firstName'), q.column('lastName')],
+   *       sql` || ' ' || `,
+   *     )})`,
+   * });
+   * ```
+   */
+  join<T = unknown>(items: readonly unknown[], separator?: RawSqlBase$1): SqlJoinExpression<Column$1.Pick.QueryColumnOfType<T>>;
   /**
    * `sql.ref` quotes a SQL identifier such as a table name, column name, or schema name.
    * Use it when you need to dynamically reference an identifier in raw SQL.
@@ -4992,6 +5039,8 @@ interface Base$1<Value> {
   __hasSelect: true;
   equals: Operator<Value | IsQuery$1 | Expression$1, BooleanQueryColumn>;
   not: Operator<Value | IsQuery$1 | Expression$1, BooleanQueryColumn>;
+  isDistinctFrom: Operator<Value | IsQuery$1 | Expression$1, BooleanQueryColumn>;
+  isNotDistinctFrom: Operator<Value | IsQuery$1 | Expression$1, BooleanQueryColumn>;
   in: Operator<Value[] | IsQuery$1 | Expression$1, BooleanQueryColumn>;
   notIn: Operator<Value[] | IsQuery$1 | Expression$1, BooleanQueryColumn>;
 }
@@ -5361,6 +5410,12 @@ interface PickQueryWindows {
 interface PickQueryRelations$1 {
   relations: RelationsBase$1;
 }
+interface PickQueryRelationsDataForCreate {
+  relationsDataForCreate: RelationsDataForCreateBase;
+}
+interface PickQueryRelationsDataForCreateOptional {
+  relationsDataForCreateOptional: RelationsDataForCreateOptionalBase;
+}
 interface PickQueryColumTypes {
   columnTypes: unknown;
 }
@@ -5969,13 +6024,14 @@ declare class QueryCreateFrom {
    */
   insertForEachFrom<T extends CreateSelf$1>(this: T, query: IsQuery$1): InsertManyFromResult<T>;
 }
-interface CreateSelf$1 extends PickQueryHasSelect, PickQueryDefaults, PickQueryResult, PickQueryRelations$1, PickQueryWithData, PickQueryReturnType, PickQueryShape$1, PickQueryUniqueProperties, PickQueryInputType$1, Query.Pick.IsNotReadOnly {}
+interface CreateSelf$1 extends PickQueryHasSelect, PickQueryDefaults, PickQueryResult, PickQueryRelations$1, PickQueryRelationsDataForCreate, PickQueryRelationsDataForCreateOptional, PickQueryWithData, PickQueryReturnType, PickQueryShape$1, PickQueryUniqueProperties, PickQueryInputType$1, Query.Pick.IsNotReadOnly {}
 type CreateData$1<T extends CreateSelf$1> = EmptyObject$1 extends T['relations'] ? CreateDataWithDefaults<T, keyof T['__defaults']> : CreateRelationsData<T>;
 type CreateDataWithDefaults<T extends CreateSelf$1, Defaults extends PropertyKey> = { [K in keyof T['__inputType'] as K extends Defaults ? never : K]: K extends Defaults ? never : CreateColumn<T, K> } & { [K in Defaults]?: K extends keyof T['__inputType'] ? CreateColumn<T, K> : never };
 type CreateDataWithDefaultsForRelations<T extends CreateSelf$1, Defaults extends keyof T['__inputType'], OmitFKeys extends PropertyKey> = { [K in keyof T['__inputType'] as K extends Defaults | OmitFKeys ? never : K]: K extends Defaults | OmitFKeys ? never : CreateColumn<T, K> } & { [K in Defaults as K extends OmitFKeys ? never : K]?: CreateColumn<T, K> };
 type CreateColumn<T extends CreateSelf$1, K extends keyof T['__inputType']> = T['__inputType'][K] | ((q: T) => QueryOrExpression$1<T['__inputType'][K]>);
-type CreateRelationsData<T extends CreateSelf$1> = CreateDataWithDefaultsForRelations<T, keyof T['__defaults'], T['relations'][keyof T['relations']]['omitForeignKeyInCreate']> & CreateRelationsDataOmittingFKeys<T, T['relations'][keyof T['relations']]['dataForCreate']>;
-type CreateRelationsDataOmittingFKeys<T extends CreateSelf$1, Union> = (Union extends RelationConfigDataForCreate ? (u: Union['columns'] extends keyof T['__defaults'] ? Pick<CreateDataWithDefaults<T, keyof T['__defaults']>, Union['columns']> & Partial<Union['nested']> : (Pick<{ [P in keyof T['__inputType']]: CreateColumn<T, P> }, Union['columns'] & keyof T['__inputType']> & { [K in keyof Union['nested']]?: never }) | Union['nested']) => void : (u: Union) => void) extends ((u: infer Obj) => void) ? Obj : never;
+type CreateRelationsData<T extends CreateSelf$1> = CreateDataWithDefaultsForRelations<T, keyof T['__defaults'], T['relations'][keyof T['relations']]['omitForeignKeyInCreate']> & CreateRelationsDataOmittingFKeys<T, T['relationsDataForCreate']> & T['relationsDataForCreateOptional'];
+type CreateRelationsDataOmittingFKeys<T extends CreateSelf$1, Data> = EmptyObject$1 extends Data ? EmptyObject$1 : { [K in keyof Data]: CreateRelationDataOmittingFKeys<T, Data[K]> }[keyof Data] extends ((u: infer Obj) => void) ? Obj : never;
+type CreateRelationDataOmittingFKeys<T extends CreateSelf$1, Union> = (u: Union extends RelationConfigDataForCreate ? Union['columns'] extends keyof T['__defaults'] ? Pick<CreateDataWithDefaults<T, keyof T['__defaults']>, Union['columns']> & Partial<Union['nested']> : (Pick<{ [P in keyof T['__inputType']]: CreateColumn<T, P> }, Union['columns'] & keyof T['__inputType']> & { [K in keyof Union['nested']]?: never }) | Union['nested'] : Union) => void;
 type CreateResult<T extends CreateSelf$1, Data> = T extends {
   isCount: true;
 } ? T : T['returnType'] extends undefined | 'all' ? SetQueryReturnsOneResult<T, NarrowCreateResult<T, Data>> : T['returnType'] extends 'pluck' ? SetQueryReturnsColumnResult<T, NarrowCreateResult<T, Data>> : SetQueryResult<T, NarrowCreateResult<T, Data>>;
@@ -7196,7 +7252,7 @@ declare namespace Column$1 {
         unique: Name;
       };
     };
-    export type Nullable<T extends Column$1.Pick.ForNullable, InputSchema, OutputSchema, QuerySchema> = { [K in keyof T]: K extends '__type' ? T['__type'] | null : K extends '__inputType' ? T['__inputType'] | null : K extends 'inputSchema' ? InputSchema : K extends '__outputType' ? T['__outputType'] | (unknown extends T['__nullType'] ? null : T['__nullType']) : K extends 'outputSchema' ? OutputSchema : K extends '__queryType' ? T['__queryType'] | null : K extends 'querySchema' ? QuerySchema : K extends 'data' ? T['data'] & DataNullable : K extends 'operators' ? { [K in keyof T['operators']]: K extends 'equals' | 'not' ? Operator<T | null> : T['operators'][K] } : T[K] };
+    export type Nullable<T extends Column$1.Pick.ForNullable, InputSchema, OutputSchema, QuerySchema> = { [K in keyof T]: K extends '__type' ? T['__type'] | null : K extends '__inputType' ? T['__inputType'] | null : K extends 'inputSchema' ? InputSchema : K extends '__outputType' ? T['__outputType'] | (unknown extends T['__nullType'] ? null : T['__nullType']) : K extends 'outputSchema' ? OutputSchema : K extends '__queryType' ? T['__queryType'] | null : K extends 'querySchema' ? QuerySchema : K extends 'data' ? T['data'] & DataNullable : K extends 'operators' ? { [K in keyof T['operators']]: K extends 'equals' | 'not' | 'isDistinctFrom' | 'isNotDistinctFrom' ? Operator<T | null> : T['operators'][K] } : T[K] };
     export type QueryColumnToNullable<C> = { [K in keyof C]: K extends '__outputType' | '__queryType' ? C[K] | null : C[K] };
     export type QueryColumnToOptional<C> = { [K in keyof C]: K extends '__outputType' ? C[K] | undefined : C[K] };
     interface DataNullable {
@@ -7206,6 +7262,8 @@ declare namespace Column$1 {
     export interface OperatorsNullable<T> {
       equals: Operator<T | null>;
       not: Operator<T | null>;
+      isDistinctFrom: Operator<T | null>;
+      isNotDistinctFrom: Operator<T | null>;
     }
     export type Encode<T, InputSchema, Input> = { [K in keyof T]: K extends '__inputType' ? Input : K extends 'inputSchema' ? InputSchema : T[K] };
     export type Parse<T extends Pick.ForParse, OutputSchema, Output> = { [K in keyof T]: K extends '__outputType' ? null extends T['__type'] ? (Output extends null ? never : Output) | (unknown extends T['__nullType'] ? null : T['__nullType']) : Output : K extends 'outputSchema' ? null extends T['__type'] ? OutputSchema | T['nullSchema'] : OutputSchema : T[K] };
@@ -9378,6 +9436,8 @@ interface Query extends IsQuery$1, PickQueryTable, PickQueryShape$1, PickQuerySe
   catch: QueryCatch;
   windows: EmptyObject$1;
   relations: RelationsBase$1;
+  relationsDataForCreate: RelationsDataForCreateBase;
+  relationsDataForCreateOptional: RelationsDataForCreateOptionalBase;
   relationQueries: IsQueries;
   error: new (message: string, length: number, name: QueryErrorName) => QueryError;
   __readOnly: true | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pqb",
-  "version": "0.67.7",
+  "version": "0.68.1",
   "description": "Postgres query builder",
   "keywords": [
     "pg",