pqb 0.67.7 → 0.68.0

package/dist/index.d.ts

@@ -604,6 +604,17 @@ interface AfterCommitStandaloneHook {
 declare const makeConnectRetryConfig: (config: AdapterConfigConnectRetryParam) => AdapterConfigConnectRetry;
 declare const wrapAdapterFnWithConnectRetry: <Fn extends (...args: any[]) => any>(connectRetryConfig: AdapterConfigConnectRetry, fn: Fn) => Fn;
 declare const getDriverErrorCode: (err: object) => unknown;
+interface SqlJoinExpression<T extends Column.Pick.QueryColumn> extends Expression<T>, ExpressionTypeMethod {}
+declare class SqlJoinExpression<T extends Column.Pick.QueryColumn = Column.Pick.QueryColumn> extends Expression<T> {
+  items: readonly unknown[];
+  separator?: RawSqlBase | undefined;
+  result: {
+    value: T;
+  };
+  q: ExpressionData;
+  constructor(items: readonly unknown[], separator?: RawSqlBase | undefined);
+  makeSQL(ctx: ToSqlValues, quotedAs?: string): string;
+}
 /**
  * Expression for a SQL identifier reference.
  * Used to safely quote identifiers in raw SQL queries.
@@ -5242,6 +5253,8 @@ declare class Db<Table extends string | undefined = undefined, Shape extends Col
   then: QueryThenShallowSimplifyArr<ColumnsShape.DefaultOutput<Shape>>;
   windows: EmptyObject;
   relations: EmptyObject;
+  relationsDataForCreate: EmptyObject;
+  relationsDataForCreateOptional: EmptyObject;
   relationQueries: EmptyObject;
   withData: EmptyObject;
   error: new (message: string, length: number, name: QueryErrorName) => QueryError<this>;
@@ -5322,6 +5335,7 @@ interface DbTableConstructor<ColumnTypes> {
 interface DbSqlMethod<ColumnTypes> {
   <T>(...args: StaticSQLArgs): RawSql<Column.Pick.QueryColumnOfType<T>, ColumnTypes>;
   <T>(...args: [DynamicSQLArg<Column.Pick.QueryColumnOfType<T>>]): DynamicRawSQL<Column.Pick.QueryColumnOfType<T>, ColumnTypes>;
+  join<T = unknown>(items: readonly unknown[], separator?: RawSqlBase): SqlJoinExpression<Column.Pick.QueryColumnOfType<T>>;
   ref(name: string): SqlRefExpression;
   unsafe(sql: string | number | boolean): UnsafeSqlExpression;
 }
@@ -5531,6 +5545,37 @@ declare function raw<T = never>(...args: StaticSQLArgs): RawSql<Column.Pick.Quer
 declare function raw<T = never>(...args: [DynamicSQLArg<Column.Pick.QueryColumnOfType<T>>]): DynamicRawSQL<Column.Pick.QueryColumnOfType<T>>;
 interface SqlFn {
   <T, Args extends TemplateLiteralArgs | [sql: string] | [values: RecordUnknown, sql?: string]>(this: T, ...args: Args): Args extends [RecordUnknown] ? (...sql: TemplateLiteralArgs) => RawSql<Column.Pick.QueryColumn, T> : RawSql<Column.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): SqlJoinExpression<Column.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.
@@ -7803,13 +7848,14 @@ declare class QueryCreateFrom {
    */
   insertForEachFrom<T extends CreateSelf>(this: T, query: IsQuery): InsertManyFromResult<T>;
 }
-interface CreateSelf extends PickQueryHasSelect, PickQueryDefaults, PickQueryResult, PickQueryRelations, PickQueryWithData, PickQueryReturnType, PickQueryShape, PickQueryUniqueProperties, PickQueryInputType, Query.Pick.IsNotReadOnly {}
+interface CreateSelf extends PickQueryHasSelect, PickQueryDefaults, PickQueryResult, PickQueryRelations, PickQueryRelationsDataForCreate, PickQueryRelationsDataForCreateOptional, PickQueryWithData, PickQueryReturnType, PickQueryShape, PickQueryUniqueProperties, PickQueryInputType, Query.Pick.IsNotReadOnly {}
 type CreateData<T extends CreateSelf> = EmptyObject extends T['relations'] ? CreateDataWithDefaults<T, keyof T['__defaults']> : CreateRelationsData<T>;
 type CreateDataWithDefaults<T extends CreateSelf, 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, 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, K extends keyof T['__inputType']> = T['__inputType'][K] | ((q: T) => QueryOrExpression<T['__inputType'][K]>);
-type CreateRelationsData<T extends CreateSelf> = CreateDataWithDefaultsForRelations<T, keyof T['__defaults'], T['relations'][keyof T['relations']]['omitForeignKeyInCreate']> & CreateRelationsDataOmittingFKeys<T, T['relations'][keyof T['relations']]['dataForCreate']>;
-type CreateRelationsDataOmittingFKeys<T extends CreateSelf, 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> = CreateDataWithDefaultsForRelations<T, keyof T['__defaults'], T['relations'][keyof T['relations']]['omitForeignKeyInCreate']> & CreateRelationsDataOmittingFKeys<T, T['relationsDataForCreate']> & T['relationsDataForCreateOptional'];
+type CreateRelationsDataOmittingFKeys<T extends CreateSelf, Data> = EmptyObject extends Data ? EmptyObject : { [K in keyof Data]: CreateRelationDataOmittingFKeys<T, Data[K]> }[keyof Data] extends ((u: infer Obj) => void) ? Obj : never;
+type CreateRelationDataOmittingFKeys<T extends CreateSelf, 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, 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>>;
@@ -10612,6 +10658,8 @@ interface Query extends IsQuery, PickQueryTable, PickQueryShape, PickQuerySelect
   catch: QueryCatch;
   windows: EmptyObject;
   relations: RelationsBase;
+  relationsDataForCreate: RelationsDataForCreateBase;
+  relationsDataForCreateOptional: RelationsDataForCreateOptionalBase;
   relationQueries: IsQueries;
   error: new (message: string, length: number, name: QueryErrorName) => QueryError;
   __readOnly: true | undefined;
@@ -10711,7 +10759,6 @@ interface RelationConfigBase extends IsQuery {
   queryRelated(params: unknown): unknown;
   modifyRelatedQuery?(relatedQuery: IsQuery): (query: IsQuery) => void;
   omitForeignKeyInCreate: PropertyKey;
-  dataForCreate: unknown;
   dataForUpdate: unknown;
   dataForUpdateOne: unknown;
   primaryKeys: string[];
@@ -10721,7 +10768,13 @@ interface RelationConfigDataForCreate {
   nested: RecordUnknown;
 }
 interface RelationsBase {
-  [K: string]: RelationConfigBase;
+  [relationName: string]: RelationConfigBase;
+}
+interface RelationsDataForCreateBase {
+  [relationName: string]: unknown;
+}
+interface RelationsDataForCreateOptionalBase {
+  [relationName: string]: unknown;
 }
 type RelationQueryMaybeSingle<T extends RelationConfigBase> = T['returnsOne'] extends true ? T['required'] extends true ? QueryManyTake<T['query']> : QueryManyTakeOptional<T['query']> : T['query'];
 interface PickQueryTable {
@@ -10811,6 +10864,12 @@ interface PickQueryWindows {
 interface PickQueryRelations {
   relations: RelationsBase;
 }
+interface PickQueryRelationsDataForCreate {
+  relationsDataForCreate: RelationsDataForCreateBase;
+}
+interface PickQueryRelationsDataForCreateOptional {
+  relationsDataForCreateOptional: RelationsDataForCreateOptionalBase;
+}
 interface PickQueryColumTypes {
   columnTypes: unknown;
 }

package/dist/index.js

@@ -338,6 +338,29 @@ const templateLiteralSQLToCode = (sql) => {
 	code += parts[i];
 	return code + "`";
 };
+var SqlJoinExpression = class extends Expression {
+	constructor(items, separator) {
+		super();
+		this.items = items;
+		this.separator = separator;
+		this.result = { value: emptyObject };
+		this.q = { expr: this };
+	}
+	makeSQL(ctx, quotedAs) {
+		let sql = "";
+		for (let i = 0; i < this.items.length; i++) {
+			if (i > 0) sql += this.separator ? this.separator.toSQL(ctx, quotedAs) : ", ";
+			const item = this.items[i];
+			if (item instanceof Expression) sql += item.toSQL(ctx, quotedAs);
+			else {
+				ctx.values.push(item);
+				sql += `$${ctx.values.length}`;
+			}
+		}
+		return sql;
+	}
+};
+SqlJoinExpression.prototype.type = ExpressionTypeMethod.prototype.type;
 /**
 * Expression for a SQL identifier reference.
 * Used to safely quote identifiers in raw SQL queries.
@@ -458,6 +481,7 @@ const sqlFn = ((...args) => {
 	return (...args) => new RawSql(args, arg);
 });
 sqlFn.ref = (name) => new SqlRefExpression(name);
+sqlFn.join = (items, separator) => new SqlJoinExpression(items, separator);
 sqlFn.unsafe = (sql) => new UnsafeSqlExpression(sql);
 var UnsafeSqlExpression = class extends Expression {
 	constructor(sql) {
@@ -1872,9 +1896,11 @@ const ordinalText = {
 };
 const encodeJsonPath = (ctx, path) => addValue(ctx.values, `{${Array.isArray(path) ? path.join(", ") : path}}`);
 const jsonPathQueryOp = (key, [path, options], ctx) => `jsonb_path_query_first(${key}, ${addValue(ctx.values, path)}${options?.vars ? `, ${addValue(ctx.values, JSON.stringify(options.vars))}${options.silent ? ", true" : ""}` : options?.silent ? ", NULL, true" : ""})`;
+const shouldEncodeJson = (ctx) => ctx.q.adapter.driverAdapter.schemaConfig?.jsonEncodedByDriver === false;
 const quoteJsonValue = (arg, ctx, quotedAs, IN) => {
 	if (arg && typeof arg === "object") {
-		if (IN && Array.isArray(arg)) return `(${arg.map((value) => addValue(ctx.values, JSON.stringify(value)) + "::jsonb").join(", ")})`;
+		if (IN && Array.isArray(arg)) return `(${arg.map((value) => shouldEncodeJson(ctx) ? addValue(ctx.values, JSON.stringify(value)) : addValue(ctx.values, value)).join(", ")})`;
+		if (Array.isArray(arg)) return shouldEncodeJson(ctx) ? addValue(ctx.values, JSON.stringify(arg)) : addValue(ctx.values, arg);
 		if (isExpression(arg)) return "to_jsonb(" + arg.toSQL(ctx, quotedAs) + ")";
 		if ("toSQL" in arg) return `to_jsonb((${moveMutativeQueryToCte$1(ctx, arg)}))`;
 	}
@@ -14260,6 +14286,7 @@ function _createDbSqlMethod(columnTypes) {
 		return sql;
 	});
 	fn.ref = sqlFn.ref;
+	fn.join = sqlFn.join;
 	fn.unsafe = sqlFn.unsafe;
 	return fn;
 }