drizzle-kit 0.28.0 → 0.28.1-08d2486

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (5) hide show
  1. package/README.md +7 -7
  2. package/api.js +1015 -714
  3. package/api.mjs +1015 -714
  4. package/bin.cjs +680 -85
  5. package/package.json +1 -1
package/api.js CHANGED
@@ -21121,7 +21121,7 @@ var version;
21121
21121
  var init_version = __esm({
21122
21122
  "../drizzle-orm/dist/version.js"() {
21123
21123
  "use strict";
21124
- version = "0.36.1";
21124
+ version = "0.36.4";
21125
21125
  }
21126
21126
  });
21127
21127
 
@@ -21407,7 +21407,11 @@ var init_sql = __esm({
21407
21407
  if (_config.invokeSource === "indexes") {
21408
21408
  return { sql: escapeName(columnName), params: [] };
21409
21409
  }
21410
- return { sql: escapeName(chunk.table[Table2.Symbol.Name]) + "." + escapeName(columnName), params: [] };
21410
+ const schemaName = chunk.table[Table2.Symbol.Schema];
21411
+ return {
21412
+ sql: chunk.table[IsAlias] || schemaName === void 0 ? escapeName(chunk.table[Table2.Symbol.Name]) + "." + escapeName(columnName) : escapeName(schemaName) + "." + escapeName(chunk.table[Table2.Symbol.Name]) + "." + escapeName(columnName),
21413
+ params: []
21414
+ };
21411
21415
  }
21412
21416
  if (is(chunk, View3)) {
21413
21417
  const schemaName = chunk[ViewBaseConfig].schema;
@@ -22140,7 +22144,7 @@ function haveSameKeys(left, right) {
22140
22144
  }
22141
22145
  function mapUpdateSet(table4, values) {
22142
22146
  const entries = Object.entries(values).filter(([, value]) => value !== void 0).map(([key, value]) => {
22143
- if (is(value, SQL)) {
22147
+ if (is(value, SQL) || is(value, Column2)) {
22144
22148
  return [key, value];
22145
22149
  } else {
22146
22150
  return [key, new Param(value, table4[Table2.Symbol.Columns][key])];
@@ -24579,9 +24583,10 @@ var init_delete = __esm({
24579
24583
  constructor(table4, session, dialect4, withList) {
24580
24584
  super();
24581
24585
  __publicField(this, "config");
24586
+ __publicField(this, "authToken");
24582
24587
  __publicField(this, "execute", (placeholderValues) => {
24583
24588
  return tracer.startActiveSpan("drizzle.operation", () => {
24584
- return this._prepare().execute(placeholderValues);
24589
+ return this._prepare().execute(placeholderValues, this.authToken);
24585
24590
  });
24586
24591
  });
24587
24592
  this.session = session;
@@ -24642,167 +24647,16 @@ var init_delete = __esm({
24642
24647
  prepare(name2) {
24643
24648
  return this._prepare(name2);
24644
24649
  }
24645
- $dynamic() {
24646
- return this;
24647
- }
24648
- };
24649
- __publicField(PgDeleteBase, _a124, "PgDelete");
24650
- }
24651
- });
24652
-
24653
- // ../drizzle-orm/dist/pg-core/query-builders/insert.js
24654
- var _a125, PgInsertBuilder, _a126, _b98, PgInsertBase;
24655
- var init_insert = __esm({
24656
- "../drizzle-orm/dist/pg-core/query-builders/insert.js"() {
24657
- "use strict";
24658
- init_entity();
24659
- init_query_promise();
24660
- init_sql();
24661
- init_table();
24662
- init_tracing();
24663
- init_utils2();
24664
- _a125 = entityKind;
24665
- PgInsertBuilder = class {
24666
- constructor(table4, session, dialect4, withList) {
24667
- this.table = table4;
24668
- this.session = session;
24669
- this.dialect = dialect4;
24670
- this.withList = withList;
24671
- }
24672
- values(values) {
24673
- values = Array.isArray(values) ? values : [values];
24674
- if (values.length === 0) {
24675
- throw new Error("values() must be called with at least one value");
24676
- }
24677
- const mappedValues = values.map((entry) => {
24678
- const result = {};
24679
- const cols = this.table[Table2.Symbol.Columns];
24680
- for (const colKey of Object.keys(entry)) {
24681
- const colValue = entry[colKey];
24682
- result[colKey] = is(colValue, SQL) ? colValue : new Param(colValue, cols[colKey]);
24683
- }
24684
- return result;
24685
- });
24686
- return new PgInsertBase(this.table, mappedValues, this.session, this.dialect, this.withList);
24687
- }
24688
- };
24689
- __publicField(PgInsertBuilder, _a125, "PgInsertBuilder");
24690
- PgInsertBase = class extends (_b98 = QueryPromise, _a126 = entityKind, _b98) {
24691
- constructor(table4, values, session, dialect4, withList) {
24692
- super();
24693
- __publicField(this, "config");
24694
- __publicField(this, "execute", (placeholderValues) => {
24695
- return tracer.startActiveSpan("drizzle.operation", () => {
24696
- return this._prepare().execute(placeholderValues);
24697
- });
24698
- });
24699
- this.session = session;
24700
- this.dialect = dialect4;
24701
- this.config = { table: table4, values, withList };
24702
- }
24703
- returning(fields = this.config.table[Table2.Symbol.Columns]) {
24704
- this.config.returning = orderSelectedFields(fields);
24705
- return this;
24706
- }
24707
- /**
24708
- * Adds an `on conflict do nothing` clause to the query.
24709
- *
24710
- * Calling this method simply avoids inserting a row as its alternative action.
24711
- *
24712
- * See docs: {@link https://orm.drizzle.team/docs/insert#on-conflict-do-nothing}
24713
- *
24714
- * @param config The `target` and `where` clauses.
24715
- *
24716
- * @example
24717
- * ```ts
24718
- * // Insert one row and cancel the insert if there's a conflict
24719
- * await db.insert(cars)
24720
- * .values({ id: 1, brand: 'BMW' })
24721
- * .onConflictDoNothing();
24722
- *
24723
- * // Explicitly specify conflict target
24724
- * await db.insert(cars)
24725
- * .values({ id: 1, brand: 'BMW' })
24726
- * .onConflictDoNothing({ target: cars.id });
24727
- * ```
24728
- */
24729
- onConflictDoNothing(config = {}) {
24730
- if (config.target === void 0) {
24731
- this.config.onConflict = sql`do nothing`;
24732
- } else {
24733
- let targetColumn = "";
24734
- targetColumn = Array.isArray(config.target) ? config.target.map((it) => this.dialect.escapeName(this.dialect.casing.getColumnCasing(it))).join(",") : this.dialect.escapeName(this.dialect.casing.getColumnCasing(config.target));
24735
- const whereSql = config.where ? sql` where ${config.where}` : void 0;
24736
- this.config.onConflict = sql`(${sql.raw(targetColumn)})${whereSql} do nothing`;
24737
- }
24738
- return this;
24739
- }
24740
- /**
24741
- * Adds an `on conflict do update` clause to the query.
24742
- *
24743
- * Calling this method will update the existing row that conflicts with the row proposed for insertion as its alternative action.
24744
- *
24745
- * See docs: {@link https://orm.drizzle.team/docs/insert#upserts-and-conflicts}
24746
- *
24747
- * @param config The `target`, `set` and `where` clauses.
24748
- *
24749
- * @example
24750
- * ```ts
24751
- * // Update the row if there's a conflict
24752
- * await db.insert(cars)
24753
- * .values({ id: 1, brand: 'BMW' })
24754
- * .onConflictDoUpdate({
24755
- * target: cars.id,
24756
- * set: { brand: 'Porsche' }
24757
- * });
24758
- *
24759
- * // Upsert with 'where' clause
24760
- * await db.insert(cars)
24761
- * .values({ id: 1, brand: 'BMW' })
24762
- * .onConflictDoUpdate({
24763
- * target: cars.id,
24764
- * set: { brand: 'newBMW' },
24765
- * targetWhere: sql`${cars.createdAt} > '2023-01-01'::date`,
24766
- * });
24767
- * ```
24768
- */
24769
- onConflictDoUpdate(config) {
24770
- if (config.where && (config.targetWhere || config.setWhere)) {
24771
- throw new Error(
24772
- 'You cannot use both "where" and "targetWhere"/"setWhere" at the same time - "where" is deprecated, use "targetWhere" or "setWhere" instead.'
24773
- );
24774
- }
24775
- const whereSql = config.where ? sql` where ${config.where}` : void 0;
24776
- const targetWhereSql = config.targetWhere ? sql` where ${config.targetWhere}` : void 0;
24777
- const setWhereSql = config.setWhere ? sql` where ${config.setWhere}` : void 0;
24778
- const setSql = this.dialect.buildUpdateSet(this.config.table, mapUpdateSet(this.config.table, config.set));
24779
- let targetColumn = "";
24780
- targetColumn = Array.isArray(config.target) ? config.target.map((it) => this.dialect.escapeName(this.dialect.casing.getColumnCasing(it))).join(",") : this.dialect.escapeName(this.dialect.casing.getColumnCasing(config.target));
24781
- this.config.onConflict = sql`(${sql.raw(targetColumn)})${targetWhereSql} do update set ${setSql}${whereSql}${setWhereSql}`;
24782
- return this;
24783
- }
24784
- /** @internal */
24785
- getSQL() {
24786
- return this.dialect.buildInsertQuery(this.config);
24787
- }
24788
- toSQL() {
24789
- const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
24790
- return rest;
24791
- }
24792
24650
  /** @internal */
24793
- _prepare(name2) {
24794
- return tracer.startActiveSpan("drizzle.prepareQuery", () => {
24795
- return this.session.prepareQuery(this.dialect.sqlToQuery(this.getSQL()), this.config.returning, name2, true);
24796
- });
24797
- }
24798
- prepare(name2) {
24799
- return this._prepare(name2);
24651
+ setToken(token) {
24652
+ this.authToken = token;
24653
+ return this;
24800
24654
  }
24801
24655
  $dynamic() {
24802
24656
  return this;
24803
24657
  }
24804
24658
  };
24805
- __publicField(PgInsertBase, _a126, "PgInsert");
24659
+ __publicField(PgDeleteBase, _a124, "PgDelete");
24806
24660
  }
24807
24661
  });
24808
24662
 
@@ -24821,13 +24675,13 @@ function toCamelCase(input) {
24821
24675
  function noopCase(input) {
24822
24676
  return input;
24823
24677
  }
24824
- var _a127, CasingCache;
24678
+ var _a125, CasingCache;
24825
24679
  var init_casing = __esm({
24826
24680
  "../drizzle-orm/dist/casing.js"() {
24827
24681
  "use strict";
24828
24682
  init_entity();
24829
24683
  init_table();
24830
- _a127 = entityKind;
24684
+ _a125 = entityKind;
24831
24685
  CasingCache = class {
24832
24686
  constructor(casing2) {
24833
24687
  /** @internal */
@@ -24864,25 +24718,25 @@ var init_casing = __esm({
24864
24718
  this.cachedTables = {};
24865
24719
  }
24866
24720
  };
24867
- __publicField(CasingCache, _a127, "CasingCache");
24721
+ __publicField(CasingCache, _a125, "CasingCache");
24868
24722
  }
24869
24723
  });
24870
24724
 
24871
24725
  // ../drizzle-orm/dist/pg-core/view-base.js
24872
- var _a128, _b99, PgViewBase;
24726
+ var _a126, _b98, PgViewBase;
24873
24727
  var init_view_base = __esm({
24874
24728
  "../drizzle-orm/dist/pg-core/view-base.js"() {
24875
24729
  "use strict";
24876
24730
  init_entity();
24877
24731
  init_sql();
24878
- PgViewBase = class extends (_b99 = View3, _a128 = entityKind, _b99) {
24732
+ PgViewBase = class extends (_b98 = View3, _a126 = entityKind, _b98) {
24879
24733
  };
24880
- __publicField(PgViewBase, _a128, "PgViewBase");
24734
+ __publicField(PgViewBase, _a126, "PgViewBase");
24881
24735
  }
24882
24736
  });
24883
24737
 
24884
24738
  // ../drizzle-orm/dist/pg-core/dialect.js
24885
- var _a129, PgDialect;
24739
+ var _a127, PgDialect;
24886
24740
  var init_dialect = __esm({
24887
24741
  "../drizzle-orm/dist/pg-core/dialect.js"() {
24888
24742
  "use strict";
@@ -24901,7 +24755,7 @@ var init_dialect = __esm({
24901
24755
  init_utils2();
24902
24756
  init_view_common();
24903
24757
  init_view_base();
24904
- _a129 = entityKind;
24758
+ _a127 = entityKind;
24905
24759
  PgDialect = class {
24906
24760
  constructor(config) {
24907
24761
  /** @internal */
@@ -24981,12 +24835,19 @@ var init_dialect = __esm({
24981
24835
  return [res];
24982
24836
  }));
24983
24837
  }
24984
- buildUpdateQuery({ table: table4, set, where, returning, withList }) {
24838
+ buildUpdateQuery({ table: table4, set, where, returning, withList, from, joins }) {
24985
24839
  const withSql = this.buildWithCTE(withList);
24840
+ const tableName = table4[PgTable.Symbol.Name];
24841
+ const tableSchema = table4[PgTable.Symbol.Schema];
24842
+ const origTableName = table4[PgTable.Symbol.OriginalName];
24843
+ const alias = tableName === origTableName ? void 0 : tableName;
24844
+ const tableSql = sql`${tableSchema ? sql`${sql.identifier(tableSchema)}.` : void 0}${sql.identifier(origTableName)}${alias && sql` ${sql.identifier(alias)}`}`;
24986
24845
  const setSql = this.buildUpdateSet(table4, set);
24987
- const returningSql = returning ? sql` returning ${this.buildSelection(returning, { isSingleTable: true })}` : void 0;
24846
+ const fromSql = from && sql.join([sql.raw(" from "), this.buildFromTable(from)]);
24847
+ const joinsSql = this.buildJoins(joins);
24848
+ const returningSql = returning ? sql` returning ${this.buildSelection(returning, { isSingleTable: !from })}` : void 0;
24988
24849
  const whereSql = where ? sql` where ${where}` : void 0;
24989
- return sql`${withSql}update ${table4} set ${setSql}${whereSql}${returningSql}`;
24850
+ return sql`${withSql}update ${tableSql} set ${setSql}${fromSql}${joinsSql}${whereSql}${returningSql}`;
24990
24851
  }
24991
24852
  /**
24992
24853
  * Builds selection SQL with provided fields/expressions
@@ -25038,6 +24899,54 @@ var init_dialect = __esm({
25038
24899
  });
25039
24900
  return sql.join(chunks);
25040
24901
  }
24902
+ buildJoins(joins) {
24903
+ if (!joins || joins.length === 0) {
24904
+ return void 0;
24905
+ }
24906
+ const joinsArray = [];
24907
+ for (const [index4, joinMeta] of joins.entries()) {
24908
+ if (index4 === 0) {
24909
+ joinsArray.push(sql` `);
24910
+ }
24911
+ const table4 = joinMeta.table;
24912
+ const lateralSql = joinMeta.lateral ? sql` lateral` : void 0;
24913
+ if (is(table4, PgTable)) {
24914
+ const tableName = table4[PgTable.Symbol.Name];
24915
+ const tableSchema = table4[PgTable.Symbol.Schema];
24916
+ const origTableName = table4[PgTable.Symbol.OriginalName];
24917
+ const alias = tableName === origTableName ? void 0 : joinMeta.alias;
24918
+ joinsArray.push(
24919
+ sql`${sql.raw(joinMeta.joinType)} join${lateralSql} ${tableSchema ? sql`${sql.identifier(tableSchema)}.` : void 0}${sql.identifier(origTableName)}${alias && sql` ${sql.identifier(alias)}`} on ${joinMeta.on}`
24920
+ );
24921
+ } else if (is(table4, View3)) {
24922
+ const viewName = table4[ViewBaseConfig].name;
24923
+ const viewSchema = table4[ViewBaseConfig].schema;
24924
+ const origViewName = table4[ViewBaseConfig].originalName;
24925
+ const alias = viewName === origViewName ? void 0 : joinMeta.alias;
24926
+ joinsArray.push(
24927
+ sql`${sql.raw(joinMeta.joinType)} join${lateralSql} ${viewSchema ? sql`${sql.identifier(viewSchema)}.` : void 0}${sql.identifier(origViewName)}${alias && sql` ${sql.identifier(alias)}`} on ${joinMeta.on}`
24928
+ );
24929
+ } else {
24930
+ joinsArray.push(
24931
+ sql`${sql.raw(joinMeta.joinType)} join${lateralSql} ${table4} on ${joinMeta.on}`
24932
+ );
24933
+ }
24934
+ if (index4 < joins.length - 1) {
24935
+ joinsArray.push(sql` `);
24936
+ }
24937
+ }
24938
+ return sql.join(joinsArray);
24939
+ }
24940
+ buildFromTable(table4) {
24941
+ if (is(table4, Table2) && table4[Table2.Symbol.OriginalName] !== table4[Table2.Symbol.Name]) {
24942
+ let fullName = sql`${sql.identifier(table4[Table2.Symbol.OriginalName])}`;
24943
+ if (table4[Table2.Symbol.Schema]) {
24944
+ fullName = sql`${sql.identifier(table4[Table2.Symbol.Schema])}.${fullName}`;
24945
+ }
24946
+ return sql`${fullName} ${sql.identifier(table4[Table2.Symbol.Name])}`;
24947
+ }
24948
+ return table4;
24949
+ }
25041
24950
  buildSelectQuery({
25042
24951
  withList,
25043
24952
  fields,
@@ -25072,51 +24981,8 @@ var init_dialect = __esm({
25072
24981
  distinctSql = distinct === true ? sql` distinct` : sql` distinct on (${sql.join(distinct.on, sql`, `)})`;
25073
24982
  }
25074
24983
  const selection = this.buildSelection(fieldsList, { isSingleTable });
25075
- const tableSql = (() => {
25076
- if (is(table4, Table2) && table4[Table2.Symbol.OriginalName] !== table4[Table2.Symbol.Name]) {
25077
- let fullName = sql`${sql.identifier(table4[Table2.Symbol.OriginalName])}`;
25078
- if (table4[Table2.Symbol.Schema]) {
25079
- fullName = sql`${sql.identifier(table4[Table2.Symbol.Schema])}.${fullName}`;
25080
- }
25081
- return sql`${fullName} ${sql.identifier(table4[Table2.Symbol.Name])}`;
25082
- }
25083
- return table4;
25084
- })();
25085
- const joinsArray = [];
25086
- if (joins) {
25087
- for (const [index4, joinMeta] of joins.entries()) {
25088
- if (index4 === 0) {
25089
- joinsArray.push(sql` `);
25090
- }
25091
- const table22 = joinMeta.table;
25092
- const lateralSql = joinMeta.lateral ? sql` lateral` : void 0;
25093
- if (is(table22, PgTable)) {
25094
- const tableName = table22[PgTable.Symbol.Name];
25095
- const tableSchema = table22[PgTable.Symbol.Schema];
25096
- const origTableName = table22[PgTable.Symbol.OriginalName];
25097
- const alias = tableName === origTableName ? void 0 : joinMeta.alias;
25098
- joinsArray.push(
25099
- sql`${sql.raw(joinMeta.joinType)} join${lateralSql} ${tableSchema ? sql`${sql.identifier(tableSchema)}.` : void 0}${sql.identifier(origTableName)}${alias && sql` ${sql.identifier(alias)}`} on ${joinMeta.on}`
25100
- );
25101
- } else if (is(table22, View3)) {
25102
- const viewName = table22[ViewBaseConfig].name;
25103
- const viewSchema = table22[ViewBaseConfig].schema;
25104
- const origViewName = table22[ViewBaseConfig].originalName;
25105
- const alias = viewName === origViewName ? void 0 : joinMeta.alias;
25106
- joinsArray.push(
25107
- sql`${sql.raw(joinMeta.joinType)} join${lateralSql} ${viewSchema ? sql`${sql.identifier(viewSchema)}.` : void 0}${sql.identifier(origViewName)}${alias && sql` ${sql.identifier(alias)}`} on ${joinMeta.on}`
25108
- );
25109
- } else {
25110
- joinsArray.push(
25111
- sql`${sql.raw(joinMeta.joinType)} join${lateralSql} ${table22} on ${joinMeta.on}`
25112
- );
25113
- }
25114
- if (index4 < joins.length - 1) {
25115
- joinsArray.push(sql` `);
25116
- }
25117
- }
25118
- }
25119
- const joinsSql = sql.join(joinsArray);
24984
+ const tableSql = this.buildFromTable(table4);
24985
+ const joinsSql = this.buildJoins(joins);
25120
24986
  const whereSql = where ? sql` where ${where}` : void 0;
25121
24987
  const havingSql = having ? sql` having ${having}` : void 0;
25122
24988
  let orderBySql;
@@ -25197,43 +25063,55 @@ var init_dialect = __esm({
25197
25063
  const offsetSql = offset ? sql` offset ${offset}` : void 0;
25198
25064
  return sql`${leftChunk}${operatorChunk}${rightChunk}${orderBySql}${limitSql}${offsetSql}`;
25199
25065
  }
25200
- buildInsertQuery({ table: table4, values, onConflict, returning, withList }) {
25066
+ buildInsertQuery({ table: table4, values: valuesOrSelect, onConflict, returning, withList, select, overridingSystemValue_ }) {
25201
25067
  const valuesSqlList = [];
25202
25068
  const columns = table4[Table2.Symbol.Columns];
25203
25069
  const colEntries = Object.entries(columns).filter(([_2, col]) => !col.shouldDisableInsert());
25204
25070
  const insertOrder = colEntries.map(
25205
25071
  ([, column4]) => sql.identifier(this.casing.getColumnCasing(column4))
25206
25072
  );
25207
- for (const [valueIndex, value] of values.entries()) {
25208
- const valueList = [];
25209
- for (const [fieldName, col] of colEntries) {
25210
- const colValue = value[fieldName];
25211
- if (colValue === void 0 || is(colValue, Param) && colValue.value === void 0) {
25212
- if (col.defaultFn !== void 0) {
25213
- const defaultFnResult = col.defaultFn();
25214
- const defaultValue = is(defaultFnResult, SQL) ? defaultFnResult : sql.param(defaultFnResult, col);
25215
- valueList.push(defaultValue);
25216
- } else if (!col.default && col.onUpdateFn !== void 0) {
25217
- const onUpdateFnResult = col.onUpdateFn();
25218
- const newValue = is(onUpdateFnResult, SQL) ? onUpdateFnResult : sql.param(onUpdateFnResult, col);
25219
- valueList.push(newValue);
25073
+ if (select) {
25074
+ const select2 = valuesOrSelect;
25075
+ if (is(select2, SQL)) {
25076
+ valuesSqlList.push(select2);
25077
+ } else {
25078
+ valuesSqlList.push(select2.getSQL());
25079
+ }
25080
+ } else {
25081
+ const values = valuesOrSelect;
25082
+ valuesSqlList.push(sql.raw("values "));
25083
+ for (const [valueIndex, value] of values.entries()) {
25084
+ const valueList = [];
25085
+ for (const [fieldName, col] of colEntries) {
25086
+ const colValue = value[fieldName];
25087
+ if (colValue === void 0 || is(colValue, Param) && colValue.value === void 0) {
25088
+ if (col.defaultFn !== void 0) {
25089
+ const defaultFnResult = col.defaultFn();
25090
+ const defaultValue = is(defaultFnResult, SQL) ? defaultFnResult : sql.param(defaultFnResult, col);
25091
+ valueList.push(defaultValue);
25092
+ } else if (!col.default && col.onUpdateFn !== void 0) {
25093
+ const onUpdateFnResult = col.onUpdateFn();
25094
+ const newValue = is(onUpdateFnResult, SQL) ? onUpdateFnResult : sql.param(onUpdateFnResult, col);
25095
+ valueList.push(newValue);
25096
+ } else {
25097
+ valueList.push(sql`default`);
25098
+ }
25220
25099
  } else {
25221
- valueList.push(sql`default`);
25100
+ valueList.push(colValue);
25222
25101
  }
25223
- } else {
25224
- valueList.push(colValue);
25225
25102
  }
25226
- }
25227
- valuesSqlList.push(valueList);
25228
- if (valueIndex < values.length - 1) {
25229
- valuesSqlList.push(sql`, `);
25103
+ valuesSqlList.push(valueList);
25104
+ if (valueIndex < values.length - 1) {
25105
+ valuesSqlList.push(sql`, `);
25106
+ }
25230
25107
  }
25231
25108
  }
25232
25109
  const withSql = this.buildWithCTE(withList);
25233
25110
  const valuesSql = sql.join(valuesSqlList);
25234
25111
  const returningSql = returning ? sql` returning ${this.buildSelection(returning, { isSingleTable: true })}` : void 0;
25235
25112
  const onConflictSql = onConflict ? sql` on conflict ${onConflict}` : void 0;
25236
- return sql`${withSql}insert into ${table4} ${insertOrder} values ${valuesSql}${onConflictSql}${returningSql}`;
25113
+ const overridingSql = overridingSystemValue_ === true ? sql`overriding system value ` : void 0;
25114
+ return sql`${withSql}insert into ${table4} ${insertOrder} ${overridingSql}${valuesSql}${onConflictSql}${returningSql}`;
25237
25115
  }
25238
25116
  buildRefreshMaterializedViewQuery({ view: view4, concurrently, withNoData }) {
25239
25117
  const concurrentlySql = concurrently ? sql` concurrently` : void 0;
@@ -25969,12 +25847,12 @@ var init_dialect = __esm({
25969
25847
  };
25970
25848
  }
25971
25849
  };
25972
- __publicField(PgDialect, _a129, "PgDialect");
25850
+ __publicField(PgDialect, _a127, "PgDialect");
25973
25851
  }
25974
25852
  });
25975
25853
 
25976
25854
  // ../drizzle-orm/dist/selection-proxy.js
25977
- var _a130, _SelectionProxyHandler, SelectionProxyHandler;
25855
+ var _a128, _SelectionProxyHandler, SelectionProxyHandler;
25978
25856
  var init_selection_proxy = __esm({
25979
25857
  "../drizzle-orm/dist/selection-proxy.js"() {
25980
25858
  "use strict";
@@ -25984,7 +25862,7 @@ var init_selection_proxy = __esm({
25984
25862
  init_sql();
25985
25863
  init_subquery();
25986
25864
  init_view_common();
25987
- _a130 = entityKind;
25865
+ _a128 = entityKind;
25988
25866
  _SelectionProxyHandler = class _SelectionProxyHandler {
25989
25867
  constructor(config) {
25990
25868
  __publicField(this, "config");
@@ -26050,25 +25928,25 @@ var init_selection_proxy = __esm({
26050
25928
  return new Proxy(value, new _SelectionProxyHandler(this.config));
26051
25929
  }
26052
25930
  };
26053
- __publicField(_SelectionProxyHandler, _a130, "SelectionProxyHandler");
25931
+ __publicField(_SelectionProxyHandler, _a128, "SelectionProxyHandler");
26054
25932
  SelectionProxyHandler = _SelectionProxyHandler;
26055
25933
  }
26056
25934
  });
26057
25935
 
26058
25936
  // ../drizzle-orm/dist/query-builders/query-builder.js
26059
- var _a131, TypedQueryBuilder;
25937
+ var _a129, TypedQueryBuilder;
26060
25938
  var init_query_builder = __esm({
26061
25939
  "../drizzle-orm/dist/query-builders/query-builder.js"() {
26062
25940
  "use strict";
26063
25941
  init_entity();
26064
- _a131 = entityKind;
25942
+ _a129 = entityKind;
26065
25943
  TypedQueryBuilder = class {
26066
25944
  /** @internal */
26067
25945
  getSelectedFields() {
26068
25946
  return this._.selectedFields;
26069
25947
  }
26070
25948
  };
26071
- __publicField(TypedQueryBuilder, _a131, "TypedQueryBuilder");
25949
+ __publicField(TypedQueryBuilder, _a129, "TypedQueryBuilder");
26072
25950
  }
26073
25951
  });
26074
25952
 
@@ -26090,7 +25968,7 @@ function createSetOperator(type, isAll) {
26090
25968
  return leftSelect.addSetOperators(setOperators);
26091
25969
  };
26092
25970
  }
26093
- var _a132, PgSelectBuilder, _a133, _b100, PgSelectQueryBuilderBase, _a134, _b101, PgSelectBase, getPgSetOperators, union, unionAll, intersect, intersectAll, except, exceptAll;
25971
+ var _a130, PgSelectBuilder, _a131, _b99, PgSelectQueryBuilderBase, _a132, _b100, PgSelectBase, getPgSetOperators, union, unionAll, intersect, intersectAll, except, exceptAll;
26094
25972
  var init_select2 = __esm({
26095
25973
  "../drizzle-orm/dist/pg-core/query-builders/select.js"() {
26096
25974
  "use strict";
@@ -26106,7 +25984,7 @@ var init_select2 = __esm({
26106
25984
  init_utils2();
26107
25985
  init_utils2();
26108
25986
  init_view_common();
26109
- _a132 = entityKind;
25987
+ _a130 = entityKind;
26110
25988
  PgSelectBuilder = class {
26111
25989
  constructor(config) {
26112
25990
  __publicField(this, "fields");
@@ -26114,6 +25992,7 @@ var init_select2 = __esm({
26114
25992
  __publicField(this, "dialect");
26115
25993
  __publicField(this, "withList", []);
26116
25994
  __publicField(this, "distinct");
25995
+ __publicField(this, "authToken");
26117
25996
  this.fields = config.fields;
26118
25997
  this.session = config.session;
26119
25998
  this.dialect = config.dialect;
@@ -26122,6 +26001,11 @@ var init_select2 = __esm({
26122
26001
  }
26123
26002
  this.distinct = config.distinct;
26124
26003
  }
26004
+ /** @internal */
26005
+ setToken(token) {
26006
+ this.authToken = token;
26007
+ return this;
26008
+ }
26125
26009
  /**
26126
26010
  * Specify the table, subquery, or other target that you're
26127
26011
  * building a select query against.
@@ -26152,11 +26036,11 @@ var init_select2 = __esm({
26152
26036
  dialect: this.dialect,
26153
26037
  withList: this.withList,
26154
26038
  distinct: this.distinct
26155
- });
26039
+ }).setToken(this.authToken);
26156
26040
  }
26157
26041
  };
26158
- __publicField(PgSelectBuilder, _a132, "PgSelectBuilder");
26159
- PgSelectQueryBuilderBase = class extends (_b100 = TypedQueryBuilder, _a133 = entityKind, _b100) {
26042
+ __publicField(PgSelectBuilder, _a130, "PgSelectBuilder");
26043
+ PgSelectQueryBuilderBase = class extends (_b99 = TypedQueryBuilder, _a131 = entityKind, _b99) {
26160
26044
  constructor({ table: table4, fields, isPartialSelect, session, dialect: dialect4, withList, distinct }) {
26161
26045
  super();
26162
26046
  __publicField(this, "_");
@@ -26756,19 +26640,20 @@ var init_select2 = __esm({
26756
26640
  return this;
26757
26641
  }
26758
26642
  };
26759
- __publicField(PgSelectQueryBuilderBase, _a133, "PgSelectQueryBuilder");
26760
- PgSelectBase = class extends (_b101 = PgSelectQueryBuilderBase, _a134 = entityKind, _b101) {
26643
+ __publicField(PgSelectQueryBuilderBase, _a131, "PgSelectQueryBuilder");
26644
+ PgSelectBase = class extends (_b100 = PgSelectQueryBuilderBase, _a132 = entityKind, _b100) {
26761
26645
  constructor() {
26762
26646
  super(...arguments);
26647
+ __publicField(this, "authToken");
26763
26648
  __publicField(this, "execute", (placeholderValues) => {
26764
26649
  return tracer.startActiveSpan("drizzle.operation", () => {
26765
- return this._prepare().execute(placeholderValues);
26650
+ return this._prepare().execute(placeholderValues, this.authToken);
26766
26651
  });
26767
26652
  });
26768
26653
  }
26769
26654
  /** @internal */
26770
26655
  _prepare(name2) {
26771
- const { session, config, dialect: dialect4, joinsNotNullableMap } = this;
26656
+ const { session, config, dialect: dialect4, joinsNotNullableMap, authToken } = this;
26772
26657
  if (!session) {
26773
26658
  throw new Error("Cannot execute a query on a query builder. Please use a database instance instead.");
26774
26659
  }
@@ -26776,7 +26661,7 @@ var init_select2 = __esm({
26776
26661
  const fieldsList = orderSelectedFields(config.fields);
26777
26662
  const query = session.prepareQuery(dialect4.sqlToQuery(this.getSQL()), fieldsList, name2, true);
26778
26663
  query.joinsNotNullableMap = joinsNotNullableMap;
26779
- return query;
26664
+ return query.setToken(authToken);
26780
26665
  });
26781
26666
  }
26782
26667
  /**
@@ -26789,8 +26674,13 @@ var init_select2 = __esm({
26789
26674
  prepare(name2) {
26790
26675
  return this._prepare(name2);
26791
26676
  }
26677
+ /** @internal */
26678
+ setToken(token) {
26679
+ this.authToken = token;
26680
+ return this;
26681
+ }
26792
26682
  };
26793
- __publicField(PgSelectBase, _a134, "PgSelect");
26683
+ __publicField(PgSelectBase, _a132, "PgSelect");
26794
26684
  applyMixins(PgSelectBase, [QueryPromise]);
26795
26685
  getPgSetOperators = () => ({
26796
26686
  union,
@@ -26810,7 +26700,7 @@ var init_select2 = __esm({
26810
26700
  });
26811
26701
 
26812
26702
  // ../drizzle-orm/dist/pg-core/query-builders/query-builder.js
26813
- var _a135, QueryBuilder;
26703
+ var _a133, QueryBuilder;
26814
26704
  var init_query_builder2 = __esm({
26815
26705
  "../drizzle-orm/dist/pg-core/query-builders/query-builder.js"() {
26816
26706
  "use strict";
@@ -26819,7 +26709,7 @@ var init_query_builder2 = __esm({
26819
26709
  init_selection_proxy();
26820
26710
  init_subquery();
26821
26711
  init_select2();
26822
- _a135 = entityKind;
26712
+ _a133 = entityKind;
26823
26713
  QueryBuilder = class {
26824
26714
  constructor(dialect4) {
26825
26715
  __publicField(this, "dialect");
@@ -26900,36 +26790,228 @@ var init_query_builder2 = __esm({
26900
26790
  return this.dialect;
26901
26791
  }
26902
26792
  };
26903
- __publicField(QueryBuilder, _a135, "PgQueryBuilder");
26793
+ __publicField(QueryBuilder, _a133, "PgQueryBuilder");
26904
26794
  }
26905
26795
  });
26906
26796
 
26907
- // ../drizzle-orm/dist/pg-core/query-builders/refresh-materialized-view.js
26908
- var _a136, _b102, PgRefreshMaterializedView;
26909
- var init_refresh_materialized_view = __esm({
26910
- "../drizzle-orm/dist/pg-core/query-builders/refresh-materialized-view.js"() {
26797
+ // ../drizzle-orm/dist/pg-core/query-builders/insert.js
26798
+ var _a134, PgInsertBuilder, _a135, _b101, PgInsertBase;
26799
+ var init_insert = __esm({
26800
+ "../drizzle-orm/dist/pg-core/query-builders/insert.js"() {
26911
26801
  "use strict";
26912
26802
  init_entity();
26913
26803
  init_query_promise();
26804
+ init_sql();
26805
+ init_table();
26914
26806
  init_tracing();
26915
- PgRefreshMaterializedView = class extends (_b102 = QueryPromise, _a136 = entityKind, _b102) {
26916
- constructor(view4, session, dialect4) {
26917
- super();
26918
- __publicField(this, "config");
26919
- __publicField(this, "execute", (placeholderValues) => {
26920
- return tracer.startActiveSpan("drizzle.operation", () => {
26921
- return this._prepare().execute(placeholderValues);
26922
- });
26923
- });
26807
+ init_utils2();
26808
+ init_query_builder2();
26809
+ _a134 = entityKind;
26810
+ PgInsertBuilder = class {
26811
+ constructor(table4, session, dialect4, withList, overridingSystemValue_) {
26812
+ __publicField(this, "authToken");
26813
+ this.table = table4;
26924
26814
  this.session = session;
26925
26815
  this.dialect = dialect4;
26926
- this.config = { view: view4 };
26816
+ this.withList = withList;
26817
+ this.overridingSystemValue_ = overridingSystemValue_;
26927
26818
  }
26928
- concurrently() {
26929
- if (this.config.withNoData !== void 0) {
26930
- throw new Error("Cannot use concurrently and withNoData together");
26931
- }
26932
- this.config.concurrently = true;
26819
+ /** @internal */
26820
+ setToken(token) {
26821
+ this.authToken = token;
26822
+ return this;
26823
+ }
26824
+ overridingSystemValue() {
26825
+ this.overridingSystemValue_ = true;
26826
+ return this;
26827
+ }
26828
+ values(values) {
26829
+ values = Array.isArray(values) ? values : [values];
26830
+ if (values.length === 0) {
26831
+ throw new Error("values() must be called with at least one value");
26832
+ }
26833
+ const mappedValues = values.map((entry) => {
26834
+ const result = {};
26835
+ const cols = this.table[Table2.Symbol.Columns];
26836
+ for (const colKey of Object.keys(entry)) {
26837
+ const colValue = entry[colKey];
26838
+ result[colKey] = is(colValue, SQL) ? colValue : new Param(colValue, cols[colKey]);
26839
+ }
26840
+ return result;
26841
+ });
26842
+ return new PgInsertBase(
26843
+ this.table,
26844
+ mappedValues,
26845
+ this.session,
26846
+ this.dialect,
26847
+ this.withList,
26848
+ false,
26849
+ this.overridingSystemValue_
26850
+ ).setToken(this.authToken);
26851
+ }
26852
+ select(selectQuery) {
26853
+ const select = typeof selectQuery === "function" ? selectQuery(new QueryBuilder()) : selectQuery;
26854
+ if (!is(select, SQL) && !haveSameKeys(this.table[Columns], select._.selectedFields)) {
26855
+ throw new Error(
26856
+ "Insert select error: selected fields are not the same or are in a different order compared to the table definition"
26857
+ );
26858
+ }
26859
+ return new PgInsertBase(this.table, select, this.session, this.dialect, this.withList, true);
26860
+ }
26861
+ };
26862
+ __publicField(PgInsertBuilder, _a134, "PgInsertBuilder");
26863
+ PgInsertBase = class extends (_b101 = QueryPromise, _a135 = entityKind, _b101) {
26864
+ constructor(table4, values, session, dialect4, withList, select, overridingSystemValue_) {
26865
+ super();
26866
+ __publicField(this, "config");
26867
+ __publicField(this, "authToken");
26868
+ __publicField(this, "execute", (placeholderValues) => {
26869
+ return tracer.startActiveSpan("drizzle.operation", () => {
26870
+ return this._prepare().execute(placeholderValues, this.authToken);
26871
+ });
26872
+ });
26873
+ this.session = session;
26874
+ this.dialect = dialect4;
26875
+ this.config = { table: table4, values, withList, select, overridingSystemValue_ };
26876
+ }
26877
+ returning(fields = this.config.table[Table2.Symbol.Columns]) {
26878
+ this.config.returning = orderSelectedFields(fields);
26879
+ return this;
26880
+ }
26881
+ /**
26882
+ * Adds an `on conflict do nothing` clause to the query.
26883
+ *
26884
+ * Calling this method simply avoids inserting a row as its alternative action.
26885
+ *
26886
+ * See docs: {@link https://orm.drizzle.team/docs/insert#on-conflict-do-nothing}
26887
+ *
26888
+ * @param config The `target` and `where` clauses.
26889
+ *
26890
+ * @example
26891
+ * ```ts
26892
+ * // Insert one row and cancel the insert if there's a conflict
26893
+ * await db.insert(cars)
26894
+ * .values({ id: 1, brand: 'BMW' })
26895
+ * .onConflictDoNothing();
26896
+ *
26897
+ * // Explicitly specify conflict target
26898
+ * await db.insert(cars)
26899
+ * .values({ id: 1, brand: 'BMW' })
26900
+ * .onConflictDoNothing({ target: cars.id });
26901
+ * ```
26902
+ */
26903
+ onConflictDoNothing(config = {}) {
26904
+ if (config.target === void 0) {
26905
+ this.config.onConflict = sql`do nothing`;
26906
+ } else {
26907
+ let targetColumn = "";
26908
+ targetColumn = Array.isArray(config.target) ? config.target.map((it) => this.dialect.escapeName(this.dialect.casing.getColumnCasing(it))).join(",") : this.dialect.escapeName(this.dialect.casing.getColumnCasing(config.target));
26909
+ const whereSql = config.where ? sql` where ${config.where}` : void 0;
26910
+ this.config.onConflict = sql`(${sql.raw(targetColumn)})${whereSql} do nothing`;
26911
+ }
26912
+ return this;
26913
+ }
26914
+ /**
26915
+ * Adds an `on conflict do update` clause to the query.
26916
+ *
26917
+ * Calling this method will update the existing row that conflicts with the row proposed for insertion as its alternative action.
26918
+ *
26919
+ * See docs: {@link https://orm.drizzle.team/docs/insert#upserts-and-conflicts}
26920
+ *
26921
+ * @param config The `target`, `set` and `where` clauses.
26922
+ *
26923
+ * @example
26924
+ * ```ts
26925
+ * // Update the row if there's a conflict
26926
+ * await db.insert(cars)
26927
+ * .values({ id: 1, brand: 'BMW' })
26928
+ * .onConflictDoUpdate({
26929
+ * target: cars.id,
26930
+ * set: { brand: 'Porsche' }
26931
+ * });
26932
+ *
26933
+ * // Upsert with 'where' clause
26934
+ * await db.insert(cars)
26935
+ * .values({ id: 1, brand: 'BMW' })
26936
+ * .onConflictDoUpdate({
26937
+ * target: cars.id,
26938
+ * set: { brand: 'newBMW' },
26939
+ * targetWhere: sql`${cars.createdAt} > '2023-01-01'::date`,
26940
+ * });
26941
+ * ```
26942
+ */
26943
+ onConflictDoUpdate(config) {
26944
+ if (config.where && (config.targetWhere || config.setWhere)) {
26945
+ throw new Error(
26946
+ 'You cannot use both "where" and "targetWhere"/"setWhere" at the same time - "where" is deprecated, use "targetWhere" or "setWhere" instead.'
26947
+ );
26948
+ }
26949
+ const whereSql = config.where ? sql` where ${config.where}` : void 0;
26950
+ const targetWhereSql = config.targetWhere ? sql` where ${config.targetWhere}` : void 0;
26951
+ const setWhereSql = config.setWhere ? sql` where ${config.setWhere}` : void 0;
26952
+ const setSql = this.dialect.buildUpdateSet(this.config.table, mapUpdateSet(this.config.table, config.set));
26953
+ let targetColumn = "";
26954
+ targetColumn = Array.isArray(config.target) ? config.target.map((it) => this.dialect.escapeName(this.dialect.casing.getColumnCasing(it))).join(",") : this.dialect.escapeName(this.dialect.casing.getColumnCasing(config.target));
26955
+ this.config.onConflict = sql`(${sql.raw(targetColumn)})${targetWhereSql} do update set ${setSql}${whereSql}${setWhereSql}`;
26956
+ return this;
26957
+ }
26958
+ /** @internal */
26959
+ getSQL() {
26960
+ return this.dialect.buildInsertQuery(this.config);
26961
+ }
26962
+ toSQL() {
26963
+ const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
26964
+ return rest;
26965
+ }
26966
+ /** @internal */
26967
+ _prepare(name2) {
26968
+ return tracer.startActiveSpan("drizzle.prepareQuery", () => {
26969
+ return this.session.prepareQuery(this.dialect.sqlToQuery(this.getSQL()), this.config.returning, name2, true);
26970
+ });
26971
+ }
26972
+ prepare(name2) {
26973
+ return this._prepare(name2);
26974
+ }
26975
+ /** @internal */
26976
+ setToken(token) {
26977
+ this.authToken = token;
26978
+ return this;
26979
+ }
26980
+ $dynamic() {
26981
+ return this;
26982
+ }
26983
+ };
26984
+ __publicField(PgInsertBase, _a135, "PgInsert");
26985
+ }
26986
+ });
26987
+
26988
+ // ../drizzle-orm/dist/pg-core/query-builders/refresh-materialized-view.js
26989
+ var _a136, _b102, PgRefreshMaterializedView;
26990
+ var init_refresh_materialized_view = __esm({
26991
+ "../drizzle-orm/dist/pg-core/query-builders/refresh-materialized-view.js"() {
26992
+ "use strict";
26993
+ init_entity();
26994
+ init_query_promise();
26995
+ init_tracing();
26996
+ PgRefreshMaterializedView = class extends (_b102 = QueryPromise, _a136 = entityKind, _b102) {
26997
+ constructor(view4, session, dialect4) {
26998
+ super();
26999
+ __publicField(this, "config");
27000
+ __publicField(this, "authToken");
27001
+ __publicField(this, "execute", (placeholderValues) => {
27002
+ return tracer.startActiveSpan("drizzle.operation", () => {
27003
+ return this._prepare().execute(placeholderValues, this.authToken);
27004
+ });
27005
+ });
27006
+ this.session = session;
27007
+ this.dialect = dialect4;
27008
+ this.config = { view: view4 };
27009
+ }
27010
+ concurrently() {
27011
+ if (this.config.withNoData !== void 0) {
27012
+ throw new Error("Cannot use concurrently and withNoData together");
27013
+ }
27014
+ this.config.concurrently = true;
26933
27015
  return this;
26934
27016
  }
26935
27017
  withNoData() {
@@ -26956,6 +27038,11 @@ var init_refresh_materialized_view = __esm({
26956
27038
  prepare(name2) {
26957
27039
  return this._prepare(name2);
26958
27040
  }
27041
+ /** @internal */
27042
+ setToken(token) {
27043
+ this.authToken = token;
27044
+ return this;
27045
+ }
26959
27046
  };
26960
27047
  __publicField(PgRefreshMaterializedView, _a136, "PgRefreshMaterializedView");
26961
27048
  }
@@ -26974,17 +27061,27 @@ var init_update = __esm({
26974
27061
  "../drizzle-orm/dist/pg-core/query-builders/update.js"() {
26975
27062
  "use strict";
26976
27063
  init_entity();
27064
+ init_table2();
26977
27065
  init_query_promise();
27066
+ init_selection_proxy();
27067
+ init_sql();
27068
+ init_subquery();
26978
27069
  init_table();
26979
27070
  init_utils2();
27071
+ init_view_common();
26980
27072
  _a137 = entityKind;
26981
27073
  PgUpdateBuilder = class {
26982
27074
  constructor(table4, session, dialect4, withList) {
27075
+ __publicField(this, "authToken");
26983
27076
  this.table = table4;
26984
27077
  this.session = session;
26985
27078
  this.dialect = dialect4;
26986
27079
  this.withList = withList;
26987
27080
  }
27081
+ setToken(token) {
27082
+ this.authToken = token;
27083
+ return this;
27084
+ }
26988
27085
  set(values) {
26989
27086
  return new PgUpdateBase(
26990
27087
  this.table,
@@ -26992,7 +27089,7 @@ var init_update = __esm({
26992
27089
  this.session,
26993
27090
  this.dialect,
26994
27091
  this.withList
26995
- );
27092
+ ).setToken(this.authToken);
26996
27093
  }
26997
27094
  };
26998
27095
  __publicField(PgUpdateBuilder, _a137, "PgUpdateBuilder");
@@ -27000,12 +27097,86 @@ var init_update = __esm({
27000
27097
  constructor(table4, set, session, dialect4, withList) {
27001
27098
  super();
27002
27099
  __publicField(this, "config");
27100
+ __publicField(this, "tableName");
27101
+ __publicField(this, "joinsNotNullableMap");
27102
+ __publicField(this, "leftJoin", this.createJoin("left"));
27103
+ __publicField(this, "rightJoin", this.createJoin("right"));
27104
+ __publicField(this, "innerJoin", this.createJoin("inner"));
27105
+ __publicField(this, "fullJoin", this.createJoin("full"));
27106
+ __publicField(this, "authToken");
27003
27107
  __publicField(this, "execute", (placeholderValues) => {
27004
- return this._prepare().execute(placeholderValues);
27108
+ return this._prepare().execute(placeholderValues, this.authToken);
27005
27109
  });
27006
27110
  this.session = session;
27007
27111
  this.dialect = dialect4;
27008
- this.config = { set, table: table4, withList };
27112
+ this.config = { set, table: table4, withList, joins: [] };
27113
+ this.tableName = getTableLikeName(table4);
27114
+ this.joinsNotNullableMap = typeof this.tableName === "string" ? { [this.tableName]: true } : {};
27115
+ }
27116
+ from(source) {
27117
+ const tableName = getTableLikeName(source);
27118
+ if (typeof tableName === "string") {
27119
+ this.joinsNotNullableMap[tableName] = true;
27120
+ }
27121
+ this.config.from = source;
27122
+ return this;
27123
+ }
27124
+ getTableLikeFields(table4) {
27125
+ if (is(table4, PgTable)) {
27126
+ return table4[Table2.Symbol.Columns];
27127
+ } else if (is(table4, Subquery)) {
27128
+ return table4._.selectedFields;
27129
+ }
27130
+ return table4[ViewBaseConfig].selectedFields;
27131
+ }
27132
+ createJoin(joinType) {
27133
+ return (table4, on) => {
27134
+ const tableName = getTableLikeName(table4);
27135
+ if (typeof tableName === "string" && this.config.joins.some((join) => join.alias === tableName)) {
27136
+ throw new Error(`Alias "${tableName}" is already used in this query`);
27137
+ }
27138
+ if (typeof on === "function") {
27139
+ const from = this.config.from && !is(this.config.from, SQL) ? this.getTableLikeFields(this.config.from) : void 0;
27140
+ on = on(
27141
+ new Proxy(
27142
+ this.config.table[Table2.Symbol.Columns],
27143
+ new SelectionProxyHandler({ sqlAliasedBehavior: "sql", sqlBehavior: "sql" })
27144
+ ),
27145
+ from && new Proxy(
27146
+ from,
27147
+ new SelectionProxyHandler({ sqlAliasedBehavior: "sql", sqlBehavior: "sql" })
27148
+ )
27149
+ );
27150
+ }
27151
+ this.config.joins.push({ on, table: table4, joinType, alias: tableName });
27152
+ if (typeof tableName === "string") {
27153
+ switch (joinType) {
27154
+ case "left": {
27155
+ this.joinsNotNullableMap[tableName] = false;
27156
+ break;
27157
+ }
27158
+ case "right": {
27159
+ this.joinsNotNullableMap = Object.fromEntries(
27160
+ Object.entries(this.joinsNotNullableMap).map(([key]) => [key, false])
27161
+ );
27162
+ this.joinsNotNullableMap[tableName] = true;
27163
+ break;
27164
+ }
27165
+ case "inner": {
27166
+ this.joinsNotNullableMap[tableName] = true;
27167
+ break;
27168
+ }
27169
+ case "full": {
27170
+ this.joinsNotNullableMap = Object.fromEntries(
27171
+ Object.entries(this.joinsNotNullableMap).map(([key]) => [key, false])
27172
+ );
27173
+ this.joinsNotNullableMap[tableName] = false;
27174
+ break;
27175
+ }
27176
+ }
27177
+ }
27178
+ return this;
27179
+ };
27009
27180
  }
27010
27181
  /**
27011
27182
  * Adds a 'where' clause to the query.
@@ -27044,7 +27215,24 @@ var init_update = __esm({
27044
27215
  this.config.where = where;
27045
27216
  return this;
27046
27217
  }
27047
- returning(fields = this.config.table[Table2.Symbol.Columns]) {
27218
+ returning(fields) {
27219
+ if (!fields) {
27220
+ fields = Object.assign({}, this.config.table[Table2.Symbol.Columns]);
27221
+ if (this.config.from) {
27222
+ const tableName = getTableLikeName(this.config.from);
27223
+ if (typeof tableName === "string" && this.config.from && !is(this.config.from, SQL)) {
27224
+ const fromFields = this.getTableLikeFields(this.config.from);
27225
+ fields[tableName] = fromFields;
27226
+ }
27227
+ for (const join of this.config.joins) {
27228
+ const tableName2 = getTableLikeName(join.table);
27229
+ if (typeof tableName2 === "string" && !is(join.table, SQL)) {
27230
+ const fromFields = this.getTableLikeFields(join.table);
27231
+ fields[tableName2] = fromFields;
27232
+ }
27233
+ }
27234
+ }
27235
+ }
27048
27236
  this.config.returning = orderSelectedFields(fields);
27049
27237
  return this;
27050
27238
  }
@@ -27058,11 +27246,18 @@ var init_update = __esm({
27058
27246
  }
27059
27247
  /** @internal */
27060
27248
  _prepare(name2) {
27061
- return this.session.prepareQuery(this.dialect.sqlToQuery(this.getSQL()), this.config.returning, name2, true);
27249
+ const query = this.session.prepareQuery(this.dialect.sqlToQuery(this.getSQL()), this.config.returning, name2, true);
27250
+ query.joinsNotNullableMap = this.joinsNotNullableMap;
27251
+ return query;
27062
27252
  }
27063
27253
  prepare(name2) {
27064
27254
  return this._prepare(name2);
27065
27255
  }
27256
+ /** @internal */
27257
+ setToken(token) {
27258
+ this.authToken = token;
27259
+ return this;
27260
+ }
27066
27261
  $dynamic() {
27067
27262
  return this;
27068
27263
  }
@@ -27096,6 +27291,7 @@ var init_count = __esm({
27096
27291
  constructor(params) {
27097
27292
  super(_PgCountBuilder.buildEmbeddedCount(params.source, params.filters).queryChunks);
27098
27293
  __publicField(this, "sql");
27294
+ __publicField(this, "token");
27099
27295
  __publicField(this, _a139, "PgCountBuilder");
27100
27296
  __publicField(this, "session");
27101
27297
  this.params = params;
@@ -27112,8 +27308,13 @@ var init_count = __esm({
27112
27308
  static buildCount(source, filters) {
27113
27309
  return sql`select count(*) as count from ${source}${sql.raw(" where ").if(filters)}${filters};`;
27114
27310
  }
27311
+ /** @intrnal */
27312
+ setToken(token) {
27313
+ this.token = token;
27314
+ return this;
27315
+ }
27115
27316
  then(onfulfilled, onrejected) {
27116
- return Promise.resolve(this.session.count(this.sql)).then(
27317
+ return Promise.resolve(this.session.count(this.sql, this.token)).then(
27117
27318
  onfulfilled,
27118
27319
  onrejected
27119
27320
  );
@@ -27190,6 +27391,7 @@ var init_query = __esm({
27190
27391
  PgRelationalQuery = class extends (_b105 = QueryPromise, _a141 = entityKind, _b105) {
27191
27392
  constructor(fullSchema, schema4, tableNamesMap, table4, tableConfig, dialect4, session, config, mode) {
27192
27393
  super();
27394
+ __publicField(this, "authToken");
27193
27395
  this.fullSchema = fullSchema;
27194
27396
  this.schema = schema4;
27195
27397
  this.tableNamesMap = tableNamesMap;
@@ -27247,9 +27449,14 @@ var init_query = __esm({
27247
27449
  toSQL() {
27248
27450
  return this._toSQL().builtQuery;
27249
27451
  }
27452
+ /** @internal */
27453
+ setToken(token) {
27454
+ this.authToken = token;
27455
+ return this;
27456
+ }
27250
27457
  execute() {
27251
27458
  return tracer.startActiveSpan("drizzle.operation", () => {
27252
- return this._prepare().execute();
27459
+ return this._prepare().execute(void 0, this.authToken);
27253
27460
  });
27254
27461
  }
27255
27462
  };
@@ -27312,6 +27519,7 @@ var init_db = __esm({
27312
27519
  PgDatabase = class {
27313
27520
  constructor(dialect4, session, schema4) {
27314
27521
  __publicField(this, "query");
27522
+ __publicField(this, "authToken");
27315
27523
  this.dialect = dialect4;
27316
27524
  this.session = session;
27317
27525
  this._ = schema4 ? {
@@ -27567,7 +27775,7 @@ var init_db = __esm({
27567
27775
  false
27568
27776
  );
27569
27777
  return new PgRaw(
27570
- () => prepared.execute(),
27778
+ () => prepared.execute(void 0, this.authToken),
27571
27779
  sequel,
27572
27780
  builtQuery,
27573
27781
  (result) => prepared.mapResult(result, true)
@@ -28112,6 +28320,7 @@ var init_session = __esm({
28112
28320
  _a159 = entityKind;
28113
28321
  PgPreparedQuery = class {
28114
28322
  constructor(query) {
28323
+ __publicField(this, "authToken");
28115
28324
  /** @internal */
28116
28325
  __publicField(this, "joinsNotNullableMap");
28117
28326
  this.query = query;
@@ -28122,6 +28331,11 @@ var init_session = __esm({
28122
28331
  mapResult(response, _isFromBatch) {
28123
28332
  return response;
28124
28333
  }
28334
+ /** @internal */
28335
+ setToken(token) {
28336
+ this.authToken = token;
28337
+ return this;
28338
+ }
28125
28339
  };
28126
28340
  __publicField(PgPreparedQuery, _a159, "PgPreparedQuery");
28127
28341
  _a160 = entityKind;
@@ -28129,7 +28343,8 @@ var init_session = __esm({
28129
28343
  constructor(dialect4) {
28130
28344
  this.dialect = dialect4;
28131
28345
  }
28132
- execute(query) {
28346
+ /** @internal */
28347
+ execute(query, token) {
28133
28348
  return tracer.startActiveSpan("drizzle.operation", () => {
28134
28349
  const prepared = tracer.startActiveSpan("drizzle.prepareQuery", () => {
28135
28350
  return this.prepareQuery(
@@ -28139,7 +28354,7 @@ var init_session = __esm({
28139
28354
  false
28140
28355
  );
28141
28356
  });
28142
- return prepared.execute();
28357
+ return prepared.setToken(token).execute(void 0, token);
28143
28358
  });
28144
28359
  }
28145
28360
  all(query) {
@@ -28150,8 +28365,9 @@ var init_session = __esm({
28150
28365
  false
28151
28366
  ).all();
28152
28367
  }
28153
- async count(sql2) {
28154
- const res = await this.execute(sql2);
28368
+ /** @internal */
28369
+ async count(sql2, token) {
28370
+ const res = await this.execute(sql2, token);
28155
28371
  return Number(
28156
28372
  res[0]["count"]
28157
28373
  );
@@ -30785,180 +31001,12 @@ var init_delete2 = __esm({
30785
31001
  return this;
30786
31002
  }
30787
31003
  returning(fields = this.table[SQLiteTable.Symbol.Columns]) {
30788
- this.config.returning = orderSelectedFields(fields);
30789
- return this;
30790
- }
30791
- /** @internal */
30792
- getSQL() {
30793
- return this.dialect.buildDeleteQuery(this.config);
30794
- }
30795
- toSQL() {
30796
- const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
30797
- return rest;
30798
- }
30799
- /** @internal */
30800
- _prepare(isOneTimeQuery = true) {
30801
- return this.session[isOneTimeQuery ? "prepareOneTimeQuery" : "prepareQuery"](
30802
- this.dialect.sqlToQuery(this.getSQL()),
30803
- this.config.returning,
30804
- this.config.returning ? "all" : "run",
30805
- true
30806
- );
30807
- }
30808
- prepare() {
30809
- return this._prepare(false);
30810
- }
30811
- async execute(placeholderValues) {
30812
- return this._prepare().execute(placeholderValues);
30813
- }
30814
- $dynamic() {
30815
- return this;
30816
- }
30817
- };
30818
- __publicField(SQLiteDeleteBase, _a196, "SQLiteDelete");
30819
- }
30820
- });
30821
-
30822
- // ../drizzle-orm/dist/sqlite-core/query-builders/insert.js
30823
- var _a197, SQLiteInsertBuilder, _a198, _b142, SQLiteInsertBase;
30824
- var init_insert2 = __esm({
30825
- "../drizzle-orm/dist/sqlite-core/query-builders/insert.js"() {
30826
- "use strict";
30827
- init_entity();
30828
- init_query_promise();
30829
- init_sql();
30830
- init_table3();
30831
- init_table();
30832
- init_utils2();
30833
- _a197 = entityKind;
30834
- SQLiteInsertBuilder = class {
30835
- constructor(table4, session, dialect4, withList) {
30836
- this.table = table4;
30837
- this.session = session;
30838
- this.dialect = dialect4;
30839
- this.withList = withList;
30840
- }
30841
- values(values) {
30842
- values = Array.isArray(values) ? values : [values];
30843
- if (values.length === 0) {
30844
- throw new Error("values() must be called with at least one value");
30845
- }
30846
- const mappedValues = values.map((entry) => {
30847
- const result = {};
30848
- const cols = this.table[Table2.Symbol.Columns];
30849
- for (const colKey of Object.keys(entry)) {
30850
- const colValue = entry[colKey];
30851
- result[colKey] = is(colValue, SQL) ? colValue : new Param(colValue, cols[colKey]);
30852
- }
30853
- return result;
30854
- });
30855
- return new SQLiteInsertBase(this.table, mappedValues, this.session, this.dialect, this.withList);
30856
- }
30857
- };
30858
- __publicField(SQLiteInsertBuilder, _a197, "SQLiteInsertBuilder");
30859
- SQLiteInsertBase = class extends (_b142 = QueryPromise, _a198 = entityKind, _b142) {
30860
- constructor(table4, values, session, dialect4, withList) {
30861
- super();
30862
- /** @internal */
30863
- __publicField(this, "config");
30864
- __publicField(this, "run", (placeholderValues) => {
30865
- return this._prepare().run(placeholderValues);
30866
- });
30867
- __publicField(this, "all", (placeholderValues) => {
30868
- return this._prepare().all(placeholderValues);
30869
- });
30870
- __publicField(this, "get", (placeholderValues) => {
30871
- return this._prepare().get(placeholderValues);
30872
- });
30873
- __publicField(this, "values", (placeholderValues) => {
30874
- return this._prepare().values(placeholderValues);
30875
- });
30876
- this.session = session;
30877
- this.dialect = dialect4;
30878
- this.config = { table: table4, values, withList };
30879
- }
30880
- returning(fields = this.config.table[SQLiteTable.Symbol.Columns]) {
30881
- this.config.returning = orderSelectedFields(fields);
30882
- return this;
30883
- }
30884
- /**
30885
- * Adds an `on conflict do nothing` clause to the query.
30886
- *
30887
- * Calling this method simply avoids inserting a row as its alternative action.
30888
- *
30889
- * See docs: {@link https://orm.drizzle.team/docs/insert#on-conflict-do-nothing}
30890
- *
30891
- * @param config The `target` and `where` clauses.
30892
- *
30893
- * @example
30894
- * ```ts
30895
- * // Insert one row and cancel the insert if there's a conflict
30896
- * await db.insert(cars)
30897
- * .values({ id: 1, brand: 'BMW' })
30898
- * .onConflictDoNothing();
30899
- *
30900
- * // Explicitly specify conflict target
30901
- * await db.insert(cars)
30902
- * .values({ id: 1, brand: 'BMW' })
30903
- * .onConflictDoNothing({ target: cars.id });
30904
- * ```
30905
- */
30906
- onConflictDoNothing(config = {}) {
30907
- if (config.target === void 0) {
30908
- this.config.onConflict = sql`do nothing`;
30909
- } else {
30910
- const targetSql = Array.isArray(config.target) ? sql`${config.target}` : sql`${[config.target]}`;
30911
- const whereSql = config.where ? sql` where ${config.where}` : sql``;
30912
- this.config.onConflict = sql`${targetSql} do nothing${whereSql}`;
30913
- }
30914
- return this;
30915
- }
30916
- /**
30917
- * Adds an `on conflict do update` clause to the query.
30918
- *
30919
- * Calling this method will update the existing row that conflicts with the row proposed for insertion as its alternative action.
30920
- *
30921
- * See docs: {@link https://orm.drizzle.team/docs/insert#upserts-and-conflicts}
30922
- *
30923
- * @param config The `target`, `set` and `where` clauses.
30924
- *
30925
- * @example
30926
- * ```ts
30927
- * // Update the row if there's a conflict
30928
- * await db.insert(cars)
30929
- * .values({ id: 1, brand: 'BMW' })
30930
- * .onConflictDoUpdate({
30931
- * target: cars.id,
30932
- * set: { brand: 'Porsche' }
30933
- * });
30934
- *
30935
- * // Upsert with 'where' clause
30936
- * await db.insert(cars)
30937
- * .values({ id: 1, brand: 'BMW' })
30938
- * .onConflictDoUpdate({
30939
- * target: cars.id,
30940
- * set: { brand: 'newBMW' },
30941
- * where: sql`${cars.createdAt} > '2023-01-01'::date`,
30942
- * });
30943
- * ```
30944
- */
30945
- onConflictDoUpdate(config) {
30946
- if (config.where && (config.targetWhere || config.setWhere)) {
30947
- throw new Error(
30948
- 'You cannot use both "where" and "targetWhere"/"setWhere" at the same time - "where" is deprecated, use "targetWhere" or "setWhere" instead.'
30949
- );
30950
- }
30951
- const whereSql = config.where ? sql` where ${config.where}` : void 0;
30952
- const targetWhereSql = config.targetWhere ? sql` where ${config.targetWhere}` : void 0;
30953
- const setWhereSql = config.setWhere ? sql` where ${config.setWhere}` : void 0;
30954
- const targetSql = Array.isArray(config.target) ? sql`${config.target}` : sql`${[config.target]}`;
30955
- const setSql = this.dialect.buildUpdateSet(this.config.table, mapUpdateSet(this.config.table, config.set));
30956
- this.config.onConflict = sql`${targetSql}${targetWhereSql} do update set ${setSql}${whereSql}${setWhereSql}`;
31004
+ this.config.returning = orderSelectedFields(fields);
30957
31005
  return this;
30958
31006
  }
30959
31007
  /** @internal */
30960
31008
  getSQL() {
30961
- return this.dialect.buildInsertQuery(this.config);
31009
+ return this.dialect.buildDeleteQuery(this.config);
30962
31010
  }
30963
31011
  toSQL() {
30964
31012
  const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
@@ -30976,32 +31024,32 @@ var init_insert2 = __esm({
30976
31024
  prepare() {
30977
31025
  return this._prepare(false);
30978
31026
  }
30979
- async execute() {
30980
- return this.config.returning ? this.all() : this.run();
31027
+ async execute(placeholderValues) {
31028
+ return this._prepare().execute(placeholderValues);
30981
31029
  }
30982
31030
  $dynamic() {
30983
31031
  return this;
30984
31032
  }
30985
31033
  };
30986
- __publicField(SQLiteInsertBase, _a198, "SQLiteInsert");
31034
+ __publicField(SQLiteDeleteBase, _a196, "SQLiteDelete");
30987
31035
  }
30988
31036
  });
30989
31037
 
30990
31038
  // ../drizzle-orm/dist/sqlite-core/view-base.js
30991
- var _a199, _b143, SQLiteViewBase;
31039
+ var _a197, _b142, SQLiteViewBase;
30992
31040
  var init_view_base2 = __esm({
30993
31041
  "../drizzle-orm/dist/sqlite-core/view-base.js"() {
30994
31042
  "use strict";
30995
31043
  init_entity();
30996
31044
  init_sql();
30997
- SQLiteViewBase = class extends (_b143 = View3, _a199 = entityKind, _b143) {
31045
+ SQLiteViewBase = class extends (_b142 = View3, _a197 = entityKind, _b142) {
30998
31046
  };
30999
- __publicField(SQLiteViewBase, _a199, "SQLiteViewBase");
31047
+ __publicField(SQLiteViewBase, _a197, "SQLiteViewBase");
31000
31048
  }
31001
31049
  });
31002
31050
 
31003
31051
  // ../drizzle-orm/dist/sqlite-core/dialect.js
31004
- var _a200, SQLiteDialect, _a201, _b144, SQLiteSyncDialect, _a202, _b145, SQLiteAsyncDialect;
31052
+ var _a198, SQLiteDialect, _a199, _b143, SQLiteSyncDialect, _a200, _b144, SQLiteAsyncDialect;
31005
31053
  var init_dialect2 = __esm({
31006
31054
  "../drizzle-orm/dist/sqlite-core/dialect.js"() {
31007
31055
  "use strict";
@@ -31020,7 +31068,7 @@ var init_dialect2 = __esm({
31020
31068
  init_utils2();
31021
31069
  init_view_common();
31022
31070
  init_view_base2();
31023
- _a200 = entityKind;
31071
+ _a198 = entityKind;
31024
31072
  SQLiteDialect = class {
31025
31073
  constructor(config) {
31026
31074
  /** @internal */
@@ -31073,14 +31121,16 @@ var init_dialect2 = __esm({
31073
31121
  return [res];
31074
31122
  }));
31075
31123
  }
31076
- buildUpdateQuery({ table: table4, set, where, returning, withList, limit, orderBy }) {
31124
+ buildUpdateQuery({ table: table4, set, where, returning, withList, joins, from, limit, orderBy }) {
31077
31125
  const withSql = this.buildWithCTE(withList);
31078
31126
  const setSql = this.buildUpdateSet(table4, set);
31127
+ const fromSql = from && sql.join([sql.raw(" from "), this.buildFromTable(from)]);
31128
+ const joinsSql = this.buildJoins(joins);
31079
31129
  const returningSql = returning ? sql` returning ${this.buildSelection(returning, { isSingleTable: true })}` : void 0;
31080
31130
  const whereSql = where ? sql` where ${where}` : void 0;
31081
31131
  const orderBySql = this.buildOrderBy(orderBy);
31082
31132
  const limitSql = this.buildLimit(limit);
31083
- return sql`${withSql}update ${table4} set ${setSql}${whereSql}${returningSql}${orderBySql}${limitSql}`;
31133
+ return sql`${withSql}update ${table4} set ${setSql}${fromSql}${joinsSql}${whereSql}${returningSql}${orderBySql}${limitSql}`;
31084
31134
  }
31085
31135
  /**
31086
31136
  * Builds selection SQL with provided fields/expressions
@@ -31133,6 +31183,37 @@ var init_dialect2 = __esm({
31133
31183
  });
31134
31184
  return sql.join(chunks);
31135
31185
  }
31186
+ buildJoins(joins) {
31187
+ if (!joins || joins.length === 0) {
31188
+ return void 0;
31189
+ }
31190
+ const joinsArray = [];
31191
+ if (joins) {
31192
+ for (const [index4, joinMeta] of joins.entries()) {
31193
+ if (index4 === 0) {
31194
+ joinsArray.push(sql` `);
31195
+ }
31196
+ const table4 = joinMeta.table;
31197
+ if (is(table4, SQLiteTable)) {
31198
+ const tableName = table4[SQLiteTable.Symbol.Name];
31199
+ const tableSchema = table4[SQLiteTable.Symbol.Schema];
31200
+ const origTableName = table4[SQLiteTable.Symbol.OriginalName];
31201
+ const alias = tableName === origTableName ? void 0 : joinMeta.alias;
31202
+ joinsArray.push(
31203
+ sql`${sql.raw(joinMeta.joinType)} join ${tableSchema ? sql`${sql.identifier(tableSchema)}.` : void 0}${sql.identifier(origTableName)}${alias && sql` ${sql.identifier(alias)}`} on ${joinMeta.on}`
31204
+ );
31205
+ } else {
31206
+ joinsArray.push(
31207
+ sql`${sql.raw(joinMeta.joinType)} join ${table4} on ${joinMeta.on}`
31208
+ );
31209
+ }
31210
+ if (index4 < joins.length - 1) {
31211
+ joinsArray.push(sql` `);
31212
+ }
31213
+ }
31214
+ }
31215
+ return sql.join(joinsArray);
31216
+ }
31136
31217
  buildLimit(limit) {
31137
31218
  return typeof limit === "object" || typeof limit === "number" && limit >= 0 ? sql` limit ${limit}` : void 0;
31138
31219
  }
@@ -31148,6 +31229,12 @@ var init_dialect2 = __esm({
31148
31229
  }
31149
31230
  return orderByList.length > 0 ? sql` order by ${sql.join(orderByList)}` : void 0;
31150
31231
  }
31232
+ buildFromTable(table4) {
31233
+ if (is(table4, Table2) && table4[Table2.Symbol.OriginalName] !== table4[Table2.Symbol.Name]) {
31234
+ return sql`${sql.identifier(table4[Table2.Symbol.OriginalName])} ${sql.identifier(table4[Table2.Symbol.Name])}`;
31235
+ }
31236
+ return table4;
31237
+ }
31151
31238
  buildSelectQuery({
31152
31239
  withList,
31153
31240
  fields,
@@ -31178,38 +31265,8 @@ var init_dialect2 = __esm({
31178
31265
  const withSql = this.buildWithCTE(withList);
31179
31266
  const distinctSql = distinct ? sql` distinct` : void 0;
31180
31267
  const selection = this.buildSelection(fieldsList, { isSingleTable });
31181
- const tableSql = (() => {
31182
- if (is(table4, Table2) && table4[Table2.Symbol.OriginalName] !== table4[Table2.Symbol.Name]) {
31183
- return sql`${sql.identifier(table4[Table2.Symbol.OriginalName])} ${sql.identifier(table4[Table2.Symbol.Name])}`;
31184
- }
31185
- return table4;
31186
- })();
31187
- const joinsArray = [];
31188
- if (joins) {
31189
- for (const [index4, joinMeta] of joins.entries()) {
31190
- if (index4 === 0) {
31191
- joinsArray.push(sql` `);
31192
- }
31193
- const table22 = joinMeta.table;
31194
- if (is(table22, SQLiteTable)) {
31195
- const tableName = table22[SQLiteTable.Symbol.Name];
31196
- const tableSchema = table22[SQLiteTable.Symbol.Schema];
31197
- const origTableName = table22[SQLiteTable.Symbol.OriginalName];
31198
- const alias = tableName === origTableName ? void 0 : joinMeta.alias;
31199
- joinsArray.push(
31200
- sql`${sql.raw(joinMeta.joinType)} join ${tableSchema ? sql`${sql.identifier(tableSchema)}.` : void 0}${sql.identifier(origTableName)}${alias && sql` ${sql.identifier(alias)}`} on ${joinMeta.on}`
31201
- );
31202
- } else {
31203
- joinsArray.push(
31204
- sql`${sql.raw(joinMeta.joinType)} join ${table22} on ${joinMeta.on}`
31205
- );
31206
- }
31207
- if (index4 < joins.length - 1) {
31208
- joinsArray.push(sql` `);
31209
- }
31210
- }
31211
- }
31212
- const joinsSql = sql.join(joinsArray);
31268
+ const tableSql = this.buildFromTable(table4);
31269
+ const joinsSql = this.buildJoins(joins);
31213
31270
  const whereSql = where ? sql` where ${where}` : void 0;
31214
31271
  const havingSql = having ? sql` having ${having}` : void 0;
31215
31272
  const groupByList = [];
@@ -31275,45 +31332,56 @@ var init_dialect2 = __esm({
31275
31332
  const offsetSql = offset ? sql` offset ${offset}` : void 0;
31276
31333
  return sql`${leftChunk}${operatorChunk}${rightChunk}${orderBySql}${limitSql}${offsetSql}`;
31277
31334
  }
31278
- buildInsertQuery({ table: table4, values, onConflict, returning, withList }) {
31335
+ buildInsertQuery({ table: table4, values: valuesOrSelect, onConflict, returning, withList, select }) {
31279
31336
  const valuesSqlList = [];
31280
31337
  const columns = table4[Table2.Symbol.Columns];
31281
31338
  const colEntries = Object.entries(columns).filter(
31282
31339
  ([_2, col]) => !col.shouldDisableInsert()
31283
31340
  );
31284
31341
  const insertOrder = colEntries.map(([, column4]) => sql.identifier(this.casing.getColumnCasing(column4)));
31285
- for (const [valueIndex, value] of values.entries()) {
31286
- const valueList = [];
31287
- for (const [fieldName, col] of colEntries) {
31288
- const colValue = value[fieldName];
31289
- if (colValue === void 0 || is(colValue, Param) && colValue.value === void 0) {
31290
- let defaultValue;
31291
- if (col.default !== null && col.default !== void 0) {
31292
- defaultValue = is(col.default, SQL) ? col.default : sql.param(col.default, col);
31293
- } else if (col.defaultFn !== void 0) {
31294
- const defaultFnResult = col.defaultFn();
31295
- defaultValue = is(defaultFnResult, SQL) ? defaultFnResult : sql.param(defaultFnResult, col);
31296
- } else if (!col.default && col.onUpdateFn !== void 0) {
31297
- const onUpdateFnResult = col.onUpdateFn();
31298
- defaultValue = is(onUpdateFnResult, SQL) ? onUpdateFnResult : sql.param(onUpdateFnResult, col);
31342
+ if (select) {
31343
+ const select2 = valuesOrSelect;
31344
+ if (is(select2, SQL)) {
31345
+ valuesSqlList.push(select2);
31346
+ } else {
31347
+ valuesSqlList.push(select2.getSQL());
31348
+ }
31349
+ } else {
31350
+ const values = valuesOrSelect;
31351
+ valuesSqlList.push(sql.raw("values "));
31352
+ for (const [valueIndex, value] of values.entries()) {
31353
+ const valueList = [];
31354
+ for (const [fieldName, col] of colEntries) {
31355
+ const colValue = value[fieldName];
31356
+ if (colValue === void 0 || is(colValue, Param) && colValue.value === void 0) {
31357
+ let defaultValue;
31358
+ if (col.default !== null && col.default !== void 0) {
31359
+ defaultValue = is(col.default, SQL) ? col.default : sql.param(col.default, col);
31360
+ } else if (col.defaultFn !== void 0) {
31361
+ const defaultFnResult = col.defaultFn();
31362
+ defaultValue = is(defaultFnResult, SQL) ? defaultFnResult : sql.param(defaultFnResult, col);
31363
+ } else if (!col.default && col.onUpdateFn !== void 0) {
31364
+ const onUpdateFnResult = col.onUpdateFn();
31365
+ defaultValue = is(onUpdateFnResult, SQL) ? onUpdateFnResult : sql.param(onUpdateFnResult, col);
31366
+ } else {
31367
+ defaultValue = sql`null`;
31368
+ }
31369
+ valueList.push(defaultValue);
31299
31370
  } else {
31300
- defaultValue = sql`null`;
31371
+ valueList.push(colValue);
31301
31372
  }
31302
- valueList.push(defaultValue);
31303
- } else {
31304
- valueList.push(colValue);
31305
31373
  }
31306
- }
31307
- valuesSqlList.push(valueList);
31308
- if (valueIndex < values.length - 1) {
31309
- valuesSqlList.push(sql`, `);
31374
+ valuesSqlList.push(valueList);
31375
+ if (valueIndex < values.length - 1) {
31376
+ valuesSqlList.push(sql`, `);
31377
+ }
31310
31378
  }
31311
31379
  }
31312
31380
  const withSql = this.buildWithCTE(withList);
31313
31381
  const valuesSql = sql.join(valuesSqlList);
31314
31382
  const returningSql = returning ? sql` returning ${this.buildSelection(returning, { isSingleTable: true })}` : void 0;
31315
31383
  const onConflictSql = onConflict ? sql` on conflict ${onConflict}` : void 0;
31316
- return sql`${withSql}insert into ${table4} ${insertOrder} values ${valuesSql}${onConflictSql}${returningSql}`;
31384
+ return sql`${withSql}insert into ${table4} ${insertOrder} ${valuesSql}${onConflictSql}${returningSql}`;
31317
31385
  }
31318
31386
  sqlToQuery(sql2, invokeSource) {
31319
31387
  return sql2.toQuery({
@@ -31542,8 +31610,8 @@ var init_dialect2 = __esm({
31542
31610
  };
31543
31611
  }
31544
31612
  };
31545
- __publicField(SQLiteDialect, _a200, "SQLiteDialect");
31546
- SQLiteSyncDialect = class extends (_b144 = SQLiteDialect, _a201 = entityKind, _b144) {
31613
+ __publicField(SQLiteDialect, _a198, "SQLiteDialect");
31614
+ SQLiteSyncDialect = class extends (_b143 = SQLiteDialect, _a199 = entityKind, _b143) {
31547
31615
  migrate(migrations, session, config) {
31548
31616
  const migrationsTable = config === void 0 ? "__drizzle_migrations" : typeof config === "string" ? "__drizzle_migrations" : config.migrationsTable ?? "__drizzle_migrations";
31549
31617
  const migrationTableCreate = sql`
@@ -31577,8 +31645,8 @@ var init_dialect2 = __esm({
31577
31645
  }
31578
31646
  }
31579
31647
  };
31580
- __publicField(SQLiteSyncDialect, _a201, "SQLiteSyncDialect");
31581
- SQLiteAsyncDialect = class extends (_b145 = SQLiteDialect, _a202 = entityKind, _b145) {
31648
+ __publicField(SQLiteSyncDialect, _a199, "SQLiteSyncDialect");
31649
+ SQLiteAsyncDialect = class extends (_b144 = SQLiteDialect, _a200 = entityKind, _b144) {
31582
31650
  async migrate(migrations, session, config) {
31583
31651
  const migrationsTable = config === void 0 ? "__drizzle_migrations" : typeof config === "string" ? "__drizzle_migrations" : config.migrationsTable ?? "__drizzle_migrations";
31584
31652
  const migrationTableCreate = sql`
@@ -31607,7 +31675,7 @@ var init_dialect2 = __esm({
31607
31675
  });
31608
31676
  }
31609
31677
  };
31610
- __publicField(SQLiteAsyncDialect, _a202, "SQLiteAsyncDialect");
31678
+ __publicField(SQLiteAsyncDialect, _a200, "SQLiteAsyncDialect");
31611
31679
  }
31612
31680
  });
31613
31681
 
@@ -31629,7 +31697,7 @@ function createSetOperator2(type, isAll) {
31629
31697
  return leftSelect.addSetOperators(setOperators);
31630
31698
  };
31631
31699
  }
31632
- var _a203, SQLiteSelectBuilder, _a204, _b146, SQLiteSelectQueryBuilderBase, _a205, _b147, SQLiteSelectBase, getSQLiteSetOperators, union2, unionAll2, intersect2, except2;
31700
+ var _a201, SQLiteSelectBuilder, _a202, _b145, SQLiteSelectQueryBuilderBase, _a203, _b146, SQLiteSelectBase, getSQLiteSetOperators, union2, unionAll2, intersect2, except2;
31633
31701
  var init_select3 = __esm({
31634
31702
  "../drizzle-orm/dist/sqlite-core/query-builders/select.js"() {
31635
31703
  "use strict";
@@ -31643,7 +31711,7 @@ var init_select3 = __esm({
31643
31711
  init_utils2();
31644
31712
  init_view_common();
31645
31713
  init_view_base2();
31646
- _a203 = entityKind;
31714
+ _a201 = entityKind;
31647
31715
  SQLiteSelectBuilder = class {
31648
31716
  constructor(config) {
31649
31717
  __publicField(this, "fields");
@@ -31684,8 +31752,8 @@ var init_select3 = __esm({
31684
31752
  });
31685
31753
  }
31686
31754
  };
31687
- __publicField(SQLiteSelectBuilder, _a203, "SQLiteSelectBuilder");
31688
- SQLiteSelectQueryBuilderBase = class extends (_b146 = TypedQueryBuilder, _a204 = entityKind, _b146) {
31755
+ __publicField(SQLiteSelectBuilder, _a201, "SQLiteSelectBuilder");
31756
+ SQLiteSelectQueryBuilderBase = class extends (_b145 = TypedQueryBuilder, _a202 = entityKind, _b145) {
31689
31757
  constructor({ table: table4, fields, isPartialSelect, session, dialect: dialect4, withList, distinct }) {
31690
31758
  super();
31691
31759
  __publicField(this, "_");
@@ -32190,8 +32258,8 @@ var init_select3 = __esm({
32190
32258
  return this;
32191
32259
  }
32192
32260
  };
32193
- __publicField(SQLiteSelectQueryBuilderBase, _a204, "SQLiteSelectQueryBuilder");
32194
- SQLiteSelectBase = class extends (_b147 = SQLiteSelectQueryBuilderBase, _a205 = entityKind, _b147) {
32261
+ __publicField(SQLiteSelectQueryBuilderBase, _a202, "SQLiteSelectQueryBuilder");
32262
+ SQLiteSelectBase = class extends (_b146 = SQLiteSelectQueryBuilderBase, _a203 = entityKind, _b146) {
32195
32263
  constructor() {
32196
32264
  super(...arguments);
32197
32265
  __publicField(this, "run", (placeholderValues) => {
@@ -32229,7 +32297,7 @@ var init_select3 = __esm({
32229
32297
  return this.all();
32230
32298
  }
32231
32299
  };
32232
- __publicField(SQLiteSelectBase, _a205, "SQLiteSelect");
32300
+ __publicField(SQLiteSelectBase, _a203, "SQLiteSelect");
32233
32301
  applyMixins(SQLiteSelectBase, [QueryPromise]);
32234
32302
  getSQLiteSetOperators = () => ({
32235
32303
  union: union2,
@@ -32245,7 +32313,7 @@ var init_select3 = __esm({
32245
32313
  });
32246
32314
 
32247
32315
  // ../drizzle-orm/dist/sqlite-core/query-builders/query-builder.js
32248
- var _a206, QueryBuilder2;
32316
+ var _a204, QueryBuilder2;
32249
32317
  var init_query_builder3 = __esm({
32250
32318
  "../drizzle-orm/dist/sqlite-core/query-builders/query-builder.js"() {
32251
32319
  "use strict";
@@ -32254,7 +32322,7 @@ var init_query_builder3 = __esm({
32254
32322
  init_dialect2();
32255
32323
  init_subquery();
32256
32324
  init_select3();
32257
- _a206 = entityKind;
32325
+ _a204 = entityKind;
32258
32326
  QueryBuilder2 = class {
32259
32327
  constructor(dialect4) {
32260
32328
  __publicField(this, "dialect");
@@ -32316,7 +32384,185 @@ var init_query_builder3 = __esm({
32316
32384
  return this.dialect;
32317
32385
  }
32318
32386
  };
32319
- __publicField(QueryBuilder2, _a206, "SQLiteQueryBuilder");
32387
+ __publicField(QueryBuilder2, _a204, "SQLiteQueryBuilder");
32388
+ }
32389
+ });
32390
+
32391
+ // ../drizzle-orm/dist/sqlite-core/query-builders/insert.js
32392
+ var _a205, SQLiteInsertBuilder, _a206, _b147, SQLiteInsertBase;
32393
+ var init_insert2 = __esm({
32394
+ "../drizzle-orm/dist/sqlite-core/query-builders/insert.js"() {
32395
+ "use strict";
32396
+ init_entity();
32397
+ init_query_promise();
32398
+ init_sql();
32399
+ init_table3();
32400
+ init_table();
32401
+ init_utils2();
32402
+ init_query_builder3();
32403
+ _a205 = entityKind;
32404
+ SQLiteInsertBuilder = class {
32405
+ constructor(table4, session, dialect4, withList) {
32406
+ this.table = table4;
32407
+ this.session = session;
32408
+ this.dialect = dialect4;
32409
+ this.withList = withList;
32410
+ }
32411
+ values(values) {
32412
+ values = Array.isArray(values) ? values : [values];
32413
+ if (values.length === 0) {
32414
+ throw new Error("values() must be called with at least one value");
32415
+ }
32416
+ const mappedValues = values.map((entry) => {
32417
+ const result = {};
32418
+ const cols = this.table[Table2.Symbol.Columns];
32419
+ for (const colKey of Object.keys(entry)) {
32420
+ const colValue = entry[colKey];
32421
+ result[colKey] = is(colValue, SQL) ? colValue : new Param(colValue, cols[colKey]);
32422
+ }
32423
+ return result;
32424
+ });
32425
+ return new SQLiteInsertBase(this.table, mappedValues, this.session, this.dialect, this.withList);
32426
+ }
32427
+ select(selectQuery) {
32428
+ const select = typeof selectQuery === "function" ? selectQuery(new QueryBuilder2()) : selectQuery;
32429
+ if (!is(select, SQL) && !haveSameKeys(this.table[Columns], select._.selectedFields)) {
32430
+ throw new Error(
32431
+ "Insert select error: selected fields are not the same or are in a different order compared to the table definition"
32432
+ );
32433
+ }
32434
+ return new SQLiteInsertBase(this.table, select, this.session, this.dialect, this.withList, true);
32435
+ }
32436
+ };
32437
+ __publicField(SQLiteInsertBuilder, _a205, "SQLiteInsertBuilder");
32438
+ SQLiteInsertBase = class extends (_b147 = QueryPromise, _a206 = entityKind, _b147) {
32439
+ constructor(table4, values, session, dialect4, withList, select) {
32440
+ super();
32441
+ /** @internal */
32442
+ __publicField(this, "config");
32443
+ __publicField(this, "run", (placeholderValues) => {
32444
+ return this._prepare().run(placeholderValues);
32445
+ });
32446
+ __publicField(this, "all", (placeholderValues) => {
32447
+ return this._prepare().all(placeholderValues);
32448
+ });
32449
+ __publicField(this, "get", (placeholderValues) => {
32450
+ return this._prepare().get(placeholderValues);
32451
+ });
32452
+ __publicField(this, "values", (placeholderValues) => {
32453
+ return this._prepare().values(placeholderValues);
32454
+ });
32455
+ this.session = session;
32456
+ this.dialect = dialect4;
32457
+ this.config = { table: table4, values, withList, select };
32458
+ }
32459
+ returning(fields = this.config.table[SQLiteTable.Symbol.Columns]) {
32460
+ this.config.returning = orderSelectedFields(fields);
32461
+ return this;
32462
+ }
32463
+ /**
32464
+ * Adds an `on conflict do nothing` clause to the query.
32465
+ *
32466
+ * Calling this method simply avoids inserting a row as its alternative action.
32467
+ *
32468
+ * See docs: {@link https://orm.drizzle.team/docs/insert#on-conflict-do-nothing}
32469
+ *
32470
+ * @param config The `target` and `where` clauses.
32471
+ *
32472
+ * @example
32473
+ * ```ts
32474
+ * // Insert one row and cancel the insert if there's a conflict
32475
+ * await db.insert(cars)
32476
+ * .values({ id: 1, brand: 'BMW' })
32477
+ * .onConflictDoNothing();
32478
+ *
32479
+ * // Explicitly specify conflict target
32480
+ * await db.insert(cars)
32481
+ * .values({ id: 1, brand: 'BMW' })
32482
+ * .onConflictDoNothing({ target: cars.id });
32483
+ * ```
32484
+ */
32485
+ onConflictDoNothing(config = {}) {
32486
+ if (config.target === void 0) {
32487
+ this.config.onConflict = sql`do nothing`;
32488
+ } else {
32489
+ const targetSql = Array.isArray(config.target) ? sql`${config.target}` : sql`${[config.target]}`;
32490
+ const whereSql = config.where ? sql` where ${config.where}` : sql``;
32491
+ this.config.onConflict = sql`${targetSql} do nothing${whereSql}`;
32492
+ }
32493
+ return this;
32494
+ }
32495
+ /**
32496
+ * Adds an `on conflict do update` clause to the query.
32497
+ *
32498
+ * Calling this method will update the existing row that conflicts with the row proposed for insertion as its alternative action.
32499
+ *
32500
+ * See docs: {@link https://orm.drizzle.team/docs/insert#upserts-and-conflicts}
32501
+ *
32502
+ * @param config The `target`, `set` and `where` clauses.
32503
+ *
32504
+ * @example
32505
+ * ```ts
32506
+ * // Update the row if there's a conflict
32507
+ * await db.insert(cars)
32508
+ * .values({ id: 1, brand: 'BMW' })
32509
+ * .onConflictDoUpdate({
32510
+ * target: cars.id,
32511
+ * set: { brand: 'Porsche' }
32512
+ * });
32513
+ *
32514
+ * // Upsert with 'where' clause
32515
+ * await db.insert(cars)
32516
+ * .values({ id: 1, brand: 'BMW' })
32517
+ * .onConflictDoUpdate({
32518
+ * target: cars.id,
32519
+ * set: { brand: 'newBMW' },
32520
+ * where: sql`${cars.createdAt} > '2023-01-01'::date`,
32521
+ * });
32522
+ * ```
32523
+ */
32524
+ onConflictDoUpdate(config) {
32525
+ if (config.where && (config.targetWhere || config.setWhere)) {
32526
+ throw new Error(
32527
+ 'You cannot use both "where" and "targetWhere"/"setWhere" at the same time - "where" is deprecated, use "targetWhere" or "setWhere" instead.'
32528
+ );
32529
+ }
32530
+ const whereSql = config.where ? sql` where ${config.where}` : void 0;
32531
+ const targetWhereSql = config.targetWhere ? sql` where ${config.targetWhere}` : void 0;
32532
+ const setWhereSql = config.setWhere ? sql` where ${config.setWhere}` : void 0;
32533
+ const targetSql = Array.isArray(config.target) ? sql`${config.target}` : sql`${[config.target]}`;
32534
+ const setSql = this.dialect.buildUpdateSet(this.config.table, mapUpdateSet(this.config.table, config.set));
32535
+ this.config.onConflict = sql`${targetSql}${targetWhereSql} do update set ${setSql}${whereSql}${setWhereSql}`;
32536
+ return this;
32537
+ }
32538
+ /** @internal */
32539
+ getSQL() {
32540
+ return this.dialect.buildInsertQuery(this.config);
32541
+ }
32542
+ toSQL() {
32543
+ const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
32544
+ return rest;
32545
+ }
32546
+ /** @internal */
32547
+ _prepare(isOneTimeQuery = true) {
32548
+ return this.session[isOneTimeQuery ? "prepareOneTimeQuery" : "prepareQuery"](
32549
+ this.dialect.sqlToQuery(this.getSQL()),
32550
+ this.config.returning,
32551
+ this.config.returning ? "all" : "run",
32552
+ true
32553
+ );
32554
+ }
32555
+ prepare() {
32556
+ return this._prepare(false);
32557
+ }
32558
+ async execute() {
32559
+ return this.config.returning ? this.all() : this.run();
32560
+ }
32561
+ $dynamic() {
32562
+ return this;
32563
+ }
32564
+ };
32565
+ __publicField(SQLiteInsertBase, _a206, "SQLiteInsert");
32320
32566
  }
32321
32567
  });
32322
32568
 
@@ -32336,8 +32582,11 @@ var init_update2 = __esm({
32336
32582
  init_query_promise();
32337
32583
  init_selection_proxy();
32338
32584
  init_table3();
32585
+ init_subquery();
32339
32586
  init_table();
32340
32587
  init_utils2();
32588
+ init_view_common();
32589
+ init_view_base2();
32341
32590
  _a207 = entityKind;
32342
32591
  SQLiteUpdateBuilder = class {
32343
32592
  constructor(table4, session, dialect4, withList) {
@@ -32362,6 +32611,10 @@ var init_update2 = __esm({
32362
32611
  super();
32363
32612
  /** @internal */
32364
32613
  __publicField(this, "config");
32614
+ __publicField(this, "leftJoin", this.createJoin("left"));
32615
+ __publicField(this, "rightJoin", this.createJoin("right"));
32616
+ __publicField(this, "innerJoin", this.createJoin("inner"));
32617
+ __publicField(this, "fullJoin", this.createJoin("full"));
32365
32618
  __publicField(this, "run", (placeholderValues) => {
32366
32619
  return this._prepare().run(placeholderValues);
32367
32620
  });
@@ -32376,7 +32629,34 @@ var init_update2 = __esm({
32376
32629
  });
32377
32630
  this.session = session;
32378
32631
  this.dialect = dialect4;
32379
- this.config = { set, table: table4, withList };
32632
+ this.config = { set, table: table4, withList, joins: [] };
32633
+ }
32634
+ from(source) {
32635
+ this.config.from = source;
32636
+ return this;
32637
+ }
32638
+ createJoin(joinType) {
32639
+ return (table4, on) => {
32640
+ const tableName = getTableLikeName(table4);
32641
+ if (typeof tableName === "string" && this.config.joins.some((join) => join.alias === tableName)) {
32642
+ throw new Error(`Alias "${tableName}" is already used in this query`);
32643
+ }
32644
+ if (typeof on === "function") {
32645
+ const from = this.config.from ? is(table4, SQLiteTable) ? table4[Table2.Symbol.Columns] : is(table4, Subquery) ? table4._.selectedFields : is(table4, SQLiteViewBase) ? table4[ViewBaseConfig].selectedFields : void 0 : void 0;
32646
+ on = on(
32647
+ new Proxy(
32648
+ this.config.table[Table2.Symbol.Columns],
32649
+ new SelectionProxyHandler({ sqlAliasedBehavior: "sql", sqlBehavior: "sql" })
32650
+ ),
32651
+ from && new Proxy(
32652
+ from,
32653
+ new SelectionProxyHandler({ sqlAliasedBehavior: "sql", sqlBehavior: "sql" })
32654
+ )
32655
+ );
32656
+ }
32657
+ this.config.joins.push({ on, table: table4, joinType, alias: tableName });
32658
+ return this;
32659
+ };
32380
32660
  }
32381
32661
  /**
32382
32662
  * Adds a 'where' clause to the query.
@@ -35674,131 +35954,6 @@ var init_delete3 = __esm({
35674
35954
  }
35675
35955
  });
35676
35956
 
35677
- // ../drizzle-orm/dist/mysql-core/query-builders/insert.js
35678
- var _a299, MySqlInsertBuilder, _a300, _b222, MySqlInsertBase;
35679
- var init_insert3 = __esm({
35680
- "../drizzle-orm/dist/mysql-core/query-builders/insert.js"() {
35681
- "use strict";
35682
- init_entity();
35683
- init_query_promise();
35684
- init_sql();
35685
- init_table();
35686
- init_utils2();
35687
- _a299 = entityKind;
35688
- MySqlInsertBuilder = class {
35689
- constructor(table4, session, dialect4) {
35690
- __publicField(this, "shouldIgnore", false);
35691
- this.table = table4;
35692
- this.session = session;
35693
- this.dialect = dialect4;
35694
- }
35695
- ignore() {
35696
- this.shouldIgnore = true;
35697
- return this;
35698
- }
35699
- values(values) {
35700
- values = Array.isArray(values) ? values : [values];
35701
- if (values.length === 0) {
35702
- throw new Error("values() must be called with at least one value");
35703
- }
35704
- const mappedValues = values.map((entry) => {
35705
- const result = {};
35706
- const cols = this.table[Table2.Symbol.Columns];
35707
- for (const colKey of Object.keys(entry)) {
35708
- const colValue = entry[colKey];
35709
- result[colKey] = is(colValue, SQL) ? colValue : new Param(colValue, cols[colKey]);
35710
- }
35711
- return result;
35712
- });
35713
- return new MySqlInsertBase(this.table, mappedValues, this.shouldIgnore, this.session, this.dialect);
35714
- }
35715
- };
35716
- __publicField(MySqlInsertBuilder, _a299, "MySqlInsertBuilder");
35717
- MySqlInsertBase = class extends (_b222 = QueryPromise, _a300 = entityKind, _b222) {
35718
- constructor(table4, values, ignore, session, dialect4) {
35719
- super();
35720
- __publicField(this, "config");
35721
- __publicField(this, "execute", (placeholderValues) => {
35722
- return this.prepare().execute(placeholderValues);
35723
- });
35724
- __publicField(this, "createIterator", () => {
35725
- const self2 = this;
35726
- return async function* (placeholderValues) {
35727
- yield* self2.prepare().iterator(placeholderValues);
35728
- };
35729
- });
35730
- __publicField(this, "iterator", this.createIterator());
35731
- this.session = session;
35732
- this.dialect = dialect4;
35733
- this.config = { table: table4, values, ignore };
35734
- }
35735
- /**
35736
- * Adds an `on duplicate key update` clause to the query.
35737
- *
35738
- * Calling this method will update update the row if any unique index conflicts. MySQL will automatically determine the conflict target based on the primary key and unique indexes.
35739
- *
35740
- * See docs: {@link https://orm.drizzle.team/docs/insert#on-duplicate-key-update}
35741
- *
35742
- * @param config The `set` clause
35743
- *
35744
- * @example
35745
- * ```ts
35746
- * await db.insert(cars)
35747
- * .values({ id: 1, brand: 'BMW'})
35748
- * .onDuplicateKeyUpdate({ set: { brand: 'Porsche' }});
35749
- * ```
35750
- *
35751
- * While MySQL does not directly support doing nothing on conflict, you can perform a no-op by setting any column's value to itself and achieve the same effect:
35752
- *
35753
- * ```ts
35754
- * import { sql } from 'drizzle-orm';
35755
- *
35756
- * await db.insert(cars)
35757
- * .values({ id: 1, brand: 'BMW' })
35758
- * .onDuplicateKeyUpdate({ set: { id: sql`id` } });
35759
- * ```
35760
- */
35761
- onDuplicateKeyUpdate(config) {
35762
- const setSql = this.dialect.buildUpdateSet(this.config.table, mapUpdateSet(this.config.table, config.set));
35763
- this.config.onConflict = sql`update ${setSql}`;
35764
- return this;
35765
- }
35766
- $returningId() {
35767
- const returning = [];
35768
- for (const [key, value] of Object.entries(this.config.table[Table2.Symbol.Columns])) {
35769
- if (value.primary) {
35770
- returning.push({ field: value, path: [key] });
35771
- }
35772
- }
35773
- this.config.returning = orderSelectedFields(this.config.table[Table2.Symbol.Columns]);
35774
- return this;
35775
- }
35776
- /** @internal */
35777
- getSQL() {
35778
- return this.dialect.buildInsertQuery(this.config).sql;
35779
- }
35780
- toSQL() {
35781
- const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
35782
- return rest;
35783
- }
35784
- prepare() {
35785
- const { sql: sql2, generatedIds } = this.dialect.buildInsertQuery(this.config);
35786
- return this.session.prepareQuery(
35787
- this.dialect.sqlToQuery(sql2),
35788
- void 0,
35789
- void 0,
35790
- generatedIds,
35791
- this.config.returning
35792
- );
35793
- }
35794
- $dynamic() {
35795
- return this;
35796
- }
35797
- };
35798
- __publicField(MySqlInsertBase, _a300, "MySqlInsert");
35799
- }
35800
- });
35801
-
35802
35957
  // ../drizzle-orm/dist/mysql-core/columns/all.js
35803
35958
  function getMySqlColumnBuilders() {
35804
35959
  return {
@@ -35879,7 +36034,7 @@ function mysqlTableWithSchema(name2, columns, extraConfig, schema4, baseName = n
35879
36034
  }
35880
36035
  return table4;
35881
36036
  }
35882
- var InlineForeignKeys3, _a301, _b223, _c9, _d4, _e4, MySqlTable, mysqlTable;
36037
+ var InlineForeignKeys3, _a299, _b222, _c9, _d4, _e4, MySqlTable, mysqlTable;
35883
36038
  var init_table4 = __esm({
35884
36039
  "../drizzle-orm/dist/mysql-core/table.js"() {
35885
36040
  "use strict";
@@ -35887,15 +36042,15 @@ var init_table4 = __esm({
35887
36042
  init_table();
35888
36043
  init_all3();
35889
36044
  InlineForeignKeys3 = Symbol.for("drizzle:MySqlInlineForeignKeys");
35890
- MySqlTable = class extends (_e4 = Table2, _d4 = entityKind, _c9 = Table2.Symbol.Columns, _b223 = InlineForeignKeys3, _a301 = Table2.Symbol.ExtraConfigBuilder, _e4) {
36045
+ MySqlTable = class extends (_e4 = Table2, _d4 = entityKind, _c9 = Table2.Symbol.Columns, _b222 = InlineForeignKeys3, _a299 = Table2.Symbol.ExtraConfigBuilder, _e4) {
35891
36046
  constructor() {
35892
36047
  super(...arguments);
35893
36048
  /** @internal */
35894
36049
  __publicField(this, _c9);
35895
36050
  /** @internal */
35896
- __publicField(this, _b223, []);
36051
+ __publicField(this, _b222, []);
35897
36052
  /** @internal */
35898
- __publicField(this, _a301);
36053
+ __publicField(this, _a299);
35899
36054
  }
35900
36055
  };
35901
36056
  __publicField(MySqlTable, _d4, "MySqlTable");
@@ -35910,20 +36065,20 @@ var init_table4 = __esm({
35910
36065
  });
35911
36066
 
35912
36067
  // ../drizzle-orm/dist/mysql-core/view-base.js
35913
- var _a302, _b224, MySqlViewBase;
36068
+ var _a300, _b223, MySqlViewBase;
35914
36069
  var init_view_base3 = __esm({
35915
36070
  "../drizzle-orm/dist/mysql-core/view-base.js"() {
35916
36071
  "use strict";
35917
36072
  init_entity();
35918
36073
  init_sql();
35919
- MySqlViewBase = class extends (_b224 = View3, _a302 = entityKind, _b224) {
36074
+ MySqlViewBase = class extends (_b223 = View3, _a300 = entityKind, _b223) {
35920
36075
  };
35921
- __publicField(MySqlViewBase, _a302, "MySqlViewBase");
36076
+ __publicField(MySqlViewBase, _a300, "MySqlViewBase");
35922
36077
  }
35923
36078
  });
35924
36079
 
35925
36080
  // ../drizzle-orm/dist/mysql-core/dialect.js
35926
- var _a303, MySqlDialect;
36081
+ var _a301, MySqlDialect;
35927
36082
  var init_dialect3 = __esm({
35928
36083
  "../drizzle-orm/dist/mysql-core/dialect.js"() {
35929
36084
  "use strict";
@@ -35942,7 +36097,7 @@ var init_dialect3 = __esm({
35942
36097
  init_common4();
35943
36098
  init_table4();
35944
36099
  init_view_base3();
35945
- _a303 = entityKind;
36100
+ _a301 = entityKind;
35946
36101
  MySqlDialect = class {
35947
36102
  constructor(config) {
35948
36103
  /** @internal */
@@ -36225,7 +36380,7 @@ var init_dialect3 = __esm({
36225
36380
  const offsetSql = offset ? sql` offset ${offset}` : void 0;
36226
36381
  return sql`${leftChunk}${operatorChunk}${rightChunk}${orderBySql}${limitSql}${offsetSql}`;
36227
36382
  }
36228
- buildInsertQuery({ table: table4, values, ignore, onConflict }) {
36383
+ buildInsertQuery({ table: table4, values: valuesOrSelect, ignore, onConflict, select }) {
36229
36384
  const valuesSqlList = [];
36230
36385
  const columns = table4[Table2.Symbol.Columns];
36231
36386
  const colEntries = Object.entries(columns).filter(
@@ -36233,42 +36388,53 @@ var init_dialect3 = __esm({
36233
36388
  );
36234
36389
  const insertOrder = colEntries.map(([, column4]) => sql.identifier(this.casing.getColumnCasing(column4)));
36235
36390
  const generatedIdsResponse = [];
36236
- for (const [valueIndex, value] of values.entries()) {
36237
- const generatedIds = {};
36238
- const valueList = [];
36239
- for (const [fieldName, col] of colEntries) {
36240
- const colValue = value[fieldName];
36241
- if (colValue === void 0 || is(colValue, Param) && colValue.value === void 0) {
36242
- if (col.defaultFn !== void 0) {
36243
- const defaultFnResult = col.defaultFn();
36244
- generatedIds[fieldName] = defaultFnResult;
36245
- const defaultValue = is(defaultFnResult, SQL) ? defaultFnResult : sql.param(defaultFnResult, col);
36246
- valueList.push(defaultValue);
36247
- } else if (!col.default && col.onUpdateFn !== void 0) {
36248
- const onUpdateFnResult = col.onUpdateFn();
36249
- const newValue = is(onUpdateFnResult, SQL) ? onUpdateFnResult : sql.param(onUpdateFnResult, col);
36250
- valueList.push(newValue);
36391
+ if (select) {
36392
+ const select2 = valuesOrSelect;
36393
+ if (is(select2, SQL)) {
36394
+ valuesSqlList.push(select2);
36395
+ } else {
36396
+ valuesSqlList.push(select2.getSQL());
36397
+ }
36398
+ } else {
36399
+ const values = valuesOrSelect;
36400
+ valuesSqlList.push(sql.raw("values "));
36401
+ for (const [valueIndex, value] of values.entries()) {
36402
+ const generatedIds = {};
36403
+ const valueList = [];
36404
+ for (const [fieldName, col] of colEntries) {
36405
+ const colValue = value[fieldName];
36406
+ if (colValue === void 0 || is(colValue, Param) && colValue.value === void 0) {
36407
+ if (col.defaultFn !== void 0) {
36408
+ const defaultFnResult = col.defaultFn();
36409
+ generatedIds[fieldName] = defaultFnResult;
36410
+ const defaultValue = is(defaultFnResult, SQL) ? defaultFnResult : sql.param(defaultFnResult, col);
36411
+ valueList.push(defaultValue);
36412
+ } else if (!col.default && col.onUpdateFn !== void 0) {
36413
+ const onUpdateFnResult = col.onUpdateFn();
36414
+ const newValue = is(onUpdateFnResult, SQL) ? onUpdateFnResult : sql.param(onUpdateFnResult, col);
36415
+ valueList.push(newValue);
36416
+ } else {
36417
+ valueList.push(sql`default`);
36418
+ }
36251
36419
  } else {
36252
- valueList.push(sql`default`);
36253
- }
36254
- } else {
36255
- if (col.defaultFn && is(colValue, Param)) {
36256
- generatedIds[fieldName] = colValue.value;
36420
+ if (col.defaultFn && is(colValue, Param)) {
36421
+ generatedIds[fieldName] = colValue.value;
36422
+ }
36423
+ valueList.push(colValue);
36257
36424
  }
36258
- valueList.push(colValue);
36259
36425
  }
36260
- }
36261
- generatedIdsResponse.push(generatedIds);
36262
- valuesSqlList.push(valueList);
36263
- if (valueIndex < values.length - 1) {
36264
- valuesSqlList.push(sql`, `);
36426
+ generatedIdsResponse.push(generatedIds);
36427
+ valuesSqlList.push(valueList);
36428
+ if (valueIndex < values.length - 1) {
36429
+ valuesSqlList.push(sql`, `);
36430
+ }
36265
36431
  }
36266
36432
  }
36267
36433
  const valuesSql = sql.join(valuesSqlList);
36268
36434
  const ignoreSql = ignore ? sql` ignore` : void 0;
36269
36435
  const onConflictSql = onConflict ? sql` on duplicate key ${onConflict}` : void 0;
36270
36436
  return {
36271
- sql: sql`insert${ignoreSql} into ${table4} ${insertOrder} values ${valuesSql}${onConflictSql}`,
36437
+ sql: sql`insert${ignoreSql} into ${table4} ${insertOrder} ${valuesSql}${onConflictSql}`,
36272
36438
  generatedIds: generatedIdsResponse
36273
36439
  };
36274
36440
  }
@@ -36728,7 +36894,7 @@ var init_dialect3 = __esm({
36728
36894
  };
36729
36895
  }
36730
36896
  };
36731
- __publicField(MySqlDialect, _a303, "MySqlDialect");
36897
+ __publicField(MySqlDialect, _a301, "MySqlDialect");
36732
36898
  }
36733
36899
  });
36734
36900
 
@@ -36750,7 +36916,7 @@ function createSetOperator3(type, isAll) {
36750
36916
  return leftSelect.addSetOperators(setOperators);
36751
36917
  };
36752
36918
  }
36753
- var _a304, MySqlSelectBuilder, _a305, _b225, MySqlSelectQueryBuilderBase, _a306, _b226, MySqlSelectBase, getMySqlSetOperators, union3, unionAll3, intersect3, intersectAll2, except3, exceptAll2;
36919
+ var _a302, MySqlSelectBuilder, _a303, _b224, MySqlSelectQueryBuilderBase, _a304, _b225, MySqlSelectBase, getMySqlSetOperators, union3, unionAll3, intersect3, intersectAll2, except3, exceptAll2;
36754
36920
  var init_select4 = __esm({
36755
36921
  "../drizzle-orm/dist/mysql-core/query-builders/select.js"() {
36756
36922
  "use strict";
@@ -36765,7 +36931,7 @@ var init_select4 = __esm({
36765
36931
  init_utils2();
36766
36932
  init_view_common();
36767
36933
  init_view_base3();
36768
- _a304 = entityKind;
36934
+ _a302 = entityKind;
36769
36935
  MySqlSelectBuilder = class {
36770
36936
  constructor(config) {
36771
36937
  __publicField(this, "fields");
@@ -36810,8 +36976,8 @@ var init_select4 = __esm({
36810
36976
  );
36811
36977
  }
36812
36978
  };
36813
- __publicField(MySqlSelectBuilder, _a304, "MySqlSelectBuilder");
36814
- MySqlSelectQueryBuilderBase = class extends (_b225 = TypedQueryBuilder, _a305 = entityKind, _b225) {
36979
+ __publicField(MySqlSelectBuilder, _a302, "MySqlSelectBuilder");
36980
+ MySqlSelectQueryBuilderBase = class extends (_b224 = TypedQueryBuilder, _a303 = entityKind, _b224) {
36815
36981
  constructor({ table: table4, fields, isPartialSelect, session, dialect: dialect4, withList, distinct }) {
36816
36982
  super();
36817
36983
  __publicField(this, "_");
@@ -37412,8 +37578,8 @@ var init_select4 = __esm({
37412
37578
  return this;
37413
37579
  }
37414
37580
  };
37415
- __publicField(MySqlSelectQueryBuilderBase, _a305, "MySqlSelectQueryBuilder");
37416
- MySqlSelectBase = class extends (_b226 = MySqlSelectQueryBuilderBase, _a306 = entityKind, _b226) {
37581
+ __publicField(MySqlSelectQueryBuilderBase, _a303, "MySqlSelectQueryBuilder");
37582
+ MySqlSelectBase = class extends (_b225 = MySqlSelectQueryBuilderBase, _a304 = entityKind, _b225) {
37417
37583
  constructor() {
37418
37584
  super(...arguments);
37419
37585
  __publicField(this, "execute", (placeholderValues) => {
@@ -37437,7 +37603,7 @@ var init_select4 = __esm({
37437
37603
  return query;
37438
37604
  }
37439
37605
  };
37440
- __publicField(MySqlSelectBase, _a306, "MySqlSelect");
37606
+ __publicField(MySqlSelectBase, _a304, "MySqlSelect");
37441
37607
  applyMixins(MySqlSelectBase, [QueryPromise]);
37442
37608
  getMySqlSetOperators = () => ({
37443
37609
  union: union3,
@@ -37457,7 +37623,7 @@ var init_select4 = __esm({
37457
37623
  });
37458
37624
 
37459
37625
  // ../drizzle-orm/dist/mysql-core/query-builders/query-builder.js
37460
- var _a307, QueryBuilder3;
37626
+ var _a305, QueryBuilder3;
37461
37627
  var init_query_builder4 = __esm({
37462
37628
  "../drizzle-orm/dist/mysql-core/query-builders/query-builder.js"() {
37463
37629
  "use strict";
@@ -37466,7 +37632,7 @@ var init_query_builder4 = __esm({
37466
37632
  init_selection_proxy();
37467
37633
  init_subquery();
37468
37634
  init_select4();
37469
- _a307 = entityKind;
37635
+ _a305 = entityKind;
37470
37636
  QueryBuilder3 = class {
37471
37637
  constructor(dialect4) {
37472
37638
  __publicField(this, "dialect");
@@ -37528,7 +37694,142 @@ var init_query_builder4 = __esm({
37528
37694
  return this.dialect;
37529
37695
  }
37530
37696
  };
37531
- __publicField(QueryBuilder3, _a307, "MySqlQueryBuilder");
37697
+ __publicField(QueryBuilder3, _a305, "MySqlQueryBuilder");
37698
+ }
37699
+ });
37700
+
37701
+ // ../drizzle-orm/dist/mysql-core/query-builders/insert.js
37702
+ var _a306, MySqlInsertBuilder, _a307, _b226, MySqlInsertBase;
37703
+ var init_insert3 = __esm({
37704
+ "../drizzle-orm/dist/mysql-core/query-builders/insert.js"() {
37705
+ "use strict";
37706
+ init_entity();
37707
+ init_query_promise();
37708
+ init_sql();
37709
+ init_table();
37710
+ init_utils2();
37711
+ init_query_builder4();
37712
+ _a306 = entityKind;
37713
+ MySqlInsertBuilder = class {
37714
+ constructor(table4, session, dialect4) {
37715
+ __publicField(this, "shouldIgnore", false);
37716
+ this.table = table4;
37717
+ this.session = session;
37718
+ this.dialect = dialect4;
37719
+ }
37720
+ ignore() {
37721
+ this.shouldIgnore = true;
37722
+ return this;
37723
+ }
37724
+ values(values) {
37725
+ values = Array.isArray(values) ? values : [values];
37726
+ if (values.length === 0) {
37727
+ throw new Error("values() must be called with at least one value");
37728
+ }
37729
+ const mappedValues = values.map((entry) => {
37730
+ const result = {};
37731
+ const cols = this.table[Table2.Symbol.Columns];
37732
+ for (const colKey of Object.keys(entry)) {
37733
+ const colValue = entry[colKey];
37734
+ result[colKey] = is(colValue, SQL) ? colValue : new Param(colValue, cols[colKey]);
37735
+ }
37736
+ return result;
37737
+ });
37738
+ return new MySqlInsertBase(this.table, mappedValues, this.shouldIgnore, this.session, this.dialect);
37739
+ }
37740
+ select(selectQuery) {
37741
+ const select = typeof selectQuery === "function" ? selectQuery(new QueryBuilder3()) : selectQuery;
37742
+ if (!is(select, SQL) && !haveSameKeys(this.table[Columns], select._.selectedFields)) {
37743
+ throw new Error(
37744
+ "Insert select error: selected fields are not the same or are in a different order compared to the table definition"
37745
+ );
37746
+ }
37747
+ return new MySqlInsertBase(this.table, select, this.shouldIgnore, this.session, this.dialect, true);
37748
+ }
37749
+ };
37750
+ __publicField(MySqlInsertBuilder, _a306, "MySqlInsertBuilder");
37751
+ MySqlInsertBase = class extends (_b226 = QueryPromise, _a307 = entityKind, _b226) {
37752
+ constructor(table4, values, ignore, session, dialect4, select) {
37753
+ super();
37754
+ __publicField(this, "config");
37755
+ __publicField(this, "execute", (placeholderValues) => {
37756
+ return this.prepare().execute(placeholderValues);
37757
+ });
37758
+ __publicField(this, "createIterator", () => {
37759
+ const self2 = this;
37760
+ return async function* (placeholderValues) {
37761
+ yield* self2.prepare().iterator(placeholderValues);
37762
+ };
37763
+ });
37764
+ __publicField(this, "iterator", this.createIterator());
37765
+ this.session = session;
37766
+ this.dialect = dialect4;
37767
+ this.config = { table: table4, values, select, ignore };
37768
+ }
37769
+ /**
37770
+ * Adds an `on duplicate key update` clause to the query.
37771
+ *
37772
+ * Calling this method will update the row if any unique index conflicts. MySQL will automatically determine the conflict target based on the primary key and unique indexes.
37773
+ *
37774
+ * See docs: {@link https://orm.drizzle.team/docs/insert#on-duplicate-key-update}
37775
+ *
37776
+ * @param config The `set` clause
37777
+ *
37778
+ * @example
37779
+ * ```ts
37780
+ * await db.insert(cars)
37781
+ * .values({ id: 1, brand: 'BMW'})
37782
+ * .onDuplicateKeyUpdate({ set: { brand: 'Porsche' }});
37783
+ * ```
37784
+ *
37785
+ * While MySQL does not directly support doing nothing on conflict, you can perform a no-op by setting any column's value to itself and achieve the same effect:
37786
+ *
37787
+ * ```ts
37788
+ * import { sql } from 'drizzle-orm';
37789
+ *
37790
+ * await db.insert(cars)
37791
+ * .values({ id: 1, brand: 'BMW' })
37792
+ * .onDuplicateKeyUpdate({ set: { id: sql`id` } });
37793
+ * ```
37794
+ */
37795
+ onDuplicateKeyUpdate(config) {
37796
+ const setSql = this.dialect.buildUpdateSet(this.config.table, mapUpdateSet(this.config.table, config.set));
37797
+ this.config.onConflict = sql`update ${setSql}`;
37798
+ return this;
37799
+ }
37800
+ $returningId() {
37801
+ const returning = [];
37802
+ for (const [key, value] of Object.entries(this.config.table[Table2.Symbol.Columns])) {
37803
+ if (value.primary) {
37804
+ returning.push({ field: value, path: [key] });
37805
+ }
37806
+ }
37807
+ this.config.returning = returning;
37808
+ return this;
37809
+ }
37810
+ /** @internal */
37811
+ getSQL() {
37812
+ return this.dialect.buildInsertQuery(this.config).sql;
37813
+ }
37814
+ toSQL() {
37815
+ const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
37816
+ return rest;
37817
+ }
37818
+ prepare() {
37819
+ const { sql: sql2, generatedIds } = this.dialect.buildInsertQuery(this.config);
37820
+ return this.session.prepareQuery(
37821
+ this.dialect.sqlToQuery(sql2),
37822
+ void 0,
37823
+ void 0,
37824
+ generatedIds,
37825
+ this.config.returning
37826
+ );
37827
+ }
37828
+ $dynamic() {
37829
+ return this;
37830
+ }
37831
+ };
37832
+ __publicField(MySqlInsertBase, _a307, "MySqlInsert");
37532
37833
  }
37533
37834
  });
37534
37835