pqb 0.2.1 → 0.2.3

package/dist/index.js

@@ -634,6 +634,7 @@ class SmallSerialColumn extends IntegerBaseColumn {
     super(...arguments);
     this.dataType = "smallserial";
     this.parseItem = parseInt;
+    this.hasDefault = true;
   }
 }
 class SerialColumn extends IntegerBaseColumn {
@@ -641,12 +642,14 @@ class SerialColumn extends IntegerBaseColumn {
     super(...arguments);
     this.dataType = "serial";
     this.parseItem = parseInt;
+    this.hasDefault = true;
   }
 }
 class BigSerialColumn extends NumberAsStringBaseColumn {
   constructor() {
     super(...arguments);
     this.dataType = "bigserial";
+    this.hasDefault = true;
   }
 }
 
@@ -4259,28 +4262,31 @@ var __spreadValues$3 = (a, b) => {
     }
   return a;
 };
-const processInsertItem = (item, rowIndex, relations, prependRelations, appendRelations, requiredReturning, columns, columnsMap) => {
+const processInsertItem = (item, rowIndex, ctx, columns, columnsMap) => {
   Object.keys(item).forEach((key) => {
-    if (relations[key]) {
-      if (relations[key].type === "belongsTo") {
-        const foreignKey = relations[key].options.foreignKey;
+    if (ctx.relations[key]) {
+      if (ctx.relations[key].type === "belongsTo") {
+        const foreignKey = ctx.relations[key].options.foreignKey;
         let columnIndex = columnsMap[foreignKey];
         if (columnIndex === void 0) {
           columnsMap[foreignKey] = columnIndex = columns.length;
           columns.push(foreignKey);
         }
-        if (!prependRelations[key])
-          prependRelations[key] = [];
-        prependRelations[key].push([
+        if (!ctx.prependRelations[key])
+          ctx.prependRelations[key] = [];
+        ctx.prependRelations[key].push([
           rowIndex,
           columnIndex,
           item[key]
         ]);
       } else {
-        requiredReturning[relations[key].primaryKey] = true;
-        if (!appendRelations[key])
-          appendRelations[key] = [];
-        appendRelations[key].push([rowIndex, item[key]]);
+        ctx.requiredReturning[ctx.relations[key].primaryKey] = true;
+        if (!ctx.appendRelations[key])
+          ctx.appendRelations[key] = [];
+        ctx.appendRelations[key].push([
+          rowIndex,
+          item[key]
+        ]);
       }
     } else if (columnsMap[key] === void 0) {
       columnsMap[key] = columns.length;
@@ -4288,152 +4294,175 @@ const processInsertItem = (item, rowIndex, relations, prependRelations, appendRe
     }
   });
 };
-class Insert {
-  insert(data) {
-    return this.clone()._insert(data);
+const createInsertCtx = (q) => ({
+  prependRelations: {},
+  appendRelations: {},
+  requiredReturning: {},
+  relations: q.relations
+});
+const getInsertSingleReturnType = (q) => {
+  const { select, returnType } = q.query;
+  if (select) {
+    return returnType === "all" ? "one" : returnType;
+  } else {
+    return "rowCount";
   }
-  _insert(data) {
-    const q = this;
-    const returning = q.query.select;
-    delete q.query.and;
-    delete q.query.or;
-    let columns;
-    const prependRelations = {};
-    const appendRelations = {};
-    const requiredReturning = {};
-    const relations = this.relations;
-    let values;
-    let returnType = q.query.returnType;
-    if (returning) {
-      if (Array.isArray(data)) {
-        if (returnType === "one" || returnType === "oneOrThrow") {
-          returnType = "all";
-        }
+};
+const getInsertManyReturnType = (q) => {
+  const { select, returnType } = q.query;
+  if (select) {
+    return returnType === "one" || returnType === "oneOrThrow" ? "all" : returnType;
+  } else {
+    return "rowCount";
+  }
+};
+const handleInsertOneData = (q, data, ctx) => {
+  const columns = [];
+  const columnsMap = {};
+  const defaults = q.query.defaults;
+  if (defaults) {
+    data = __spreadValues$3(__spreadValues$3({}, defaults), data);
+  }
+  processInsertItem(data, 0, ctx, columns, columnsMap);
+  const values = [columns.map((key) => data[key])];
+  return { columns, values };
+};
+const handleInsertManyData = (q, data, ctx) => {
+  const columns = [];
+  const columnsMap = {};
+  const defaults = q.query.defaults;
+  if (defaults) {
+    data = data.map((item) => __spreadValues$3(__spreadValues$3({}, defaults), item));
+  }
+  data.forEach((item, i) => {
+    processInsertItem(item, i, ctx, columns, columnsMap);
+  });
+  const values = Array(data.length);
+  data.forEach((item, i) => {
+    values[i] = columns.map((key) => item[key]);
+  });
+  return { columns, values };
+};
+const insert = (self, {
+  columns,
+  values
+}, returnType, ctx) => {
+  const q = self;
+  const returning = q.query.select;
+  delete q.query.and;
+  delete q.query.or;
+  q.query.type = "insert";
+  q.query.columns = columns;
+  q.query.values = values;
+  if (!ctx) {
+    q.query.returnType = returnType;
+    return q;
+  }
+  const prependRelationsKeys = Object.keys(ctx.prependRelations);
+  if (prependRelationsKeys.length) {
+    pushQueryArray(
+      q,
+      "beforeQuery",
+      prependRelationsKeys.map((relationName) => {
+        return async (q2) => {
+          const relationData = ctx.prependRelations[relationName];
+          const relation = ctx.relations[relationName];
+          const inserted = await relation.nestedInsert(
+            q2,
+            relationData.map(([, , data]) => data)
+          );
+          const primaryKey = relation.options.primaryKey;
+          relationData.forEach(([rowIndex, columnIndex], index) => {
+            values[rowIndex][columnIndex] = inserted[index][primaryKey];
+          });
+        };
+      })
+    );
+  }
+  const appendRelationsKeys = Object.keys(ctx.appendRelations);
+  if (appendRelationsKeys.length) {
+    if (!(returning == null ? void 0 : returning.includes("*"))) {
+      const requiredColumns = Object.keys(ctx.requiredReturning);
+      if (!returning) {
+        q.query.select = requiredColumns;
       } else {
-        if (returnType === "all") {
-          returnType = "one";
-        }
+        q.query.select = [
+          .../* @__PURE__ */ new Set([...returning, ...requiredColumns])
+        ];
       }
-    } else {
-      returnType = "rowCount";
     }
-    if ("values" in data && typeof data.values === "object" && data.values && isRaw(data.values)) {
-      columns = data.columns;
-      values = data.values;
-    } else {
-      columns = [];
-      const columnsMap = {};
-      const defaults = q.query.defaults;
-      if (Array.isArray(data)) {
-        if (defaults) {
-          data = data.map((item) => __spreadValues$3(__spreadValues$3({}, defaults), item));
-        }
-        data.forEach((item, i) => {
-          processInsertItem(
-            item,
-            i,
-            relations,
-            prependRelations,
-            appendRelations,
-            requiredReturning,
-            columns,
-            columnsMap
+    let resultOfTypeAll;
+    if (returnType !== "all") {
+      const { handleResult } = q.query;
+      q.query.handleResult = async (q2, queryResult) => {
+        resultOfTypeAll = await handleResult(q2, queryResult);
+        if (queryMethodByReturnType[returnType] === "arrays") {
+          queryResult.rows.forEach(
+            (row, i) => queryResult.rows[i] = Object.values(row)
           );
-        });
-        values = Array(data.length);
-        data.forEach((item, i) => {
-          values[i] = columns.map((key) => item[key]);
-        });
-      } else {
-        if (defaults) {
-          data = __spreadValues$3(__spreadValues$3({}, defaults), data);
         }
-        processInsertItem(
-          data,
-          0,
-          relations,
-          prependRelations,
-          appendRelations,
-          requiredReturning,
-          columns,
-          columnsMap
-        );
-        values = [columns.map((key) => data[key])];
-      }
-    }
-    const prependRelationsKeys = Object.keys(prependRelations);
-    if (prependRelationsKeys.length) {
-      pushQueryArray(
-        q,
-        "beforeQuery",
-        prependRelationsKeys.map((relationName) => {
-          return async (q2) => {
-            const relationData = prependRelations[relationName];
-            const relation = relations[relationName];
-            const inserted = await relation.nestedInsert(
-              q2,
-              relationData.map(([, , data2]) => data2)
-            );
-            const primaryKey = relation.options.primaryKey;
-            relationData.forEach(([rowIndex, columnIndex], index) => {
-              values[rowIndex][columnIndex] = inserted[index][primaryKey];
-            });
-          };
-        })
-      );
+        return parseResult(q2, returnType, queryResult);
+      };
     }
-    const appendRelationsKeys = Object.keys(appendRelations);
-    if (appendRelationsKeys.length) {
-      if (!(returning == null ? void 0 : returning.includes("*"))) {
-        const requiredColumns = Object.keys(requiredReturning);
-        if (!returning) {
-          q.query.select = requiredColumns;
-        } else {
-          q.query.select = [
-            .../* @__PURE__ */ new Set([...returning, ...requiredColumns])
-          ];
-        }
-      }
-      let resultOfTypeAll;
-      if (returnType !== "all") {
-        const { handleResult } = q.query;
-        q.query.handleResult = async (q2, queryResult) => {
-          resultOfTypeAll = await handleResult(q2, queryResult);
-          if (queryMethodByReturnType[returnType] === "arrays") {
-            queryResult.rows.forEach(
-              (row, i) => queryResult.rows[i] = Object.values(row)
-            );
-          }
-          return parseResult(q2, returnType, queryResult);
+    pushQueryArray(
+      q,
+      "afterQuery",
+      appendRelationsKeys.map((relationName) => {
+        return (q2, result) => {
+          var _a, _b;
+          const all = resultOfTypeAll || result;
+          return (_b = (_a = ctx.relations[relationName]).nestedInsert) == null ? void 0 : _b.call(
+            _a,
+            q2,
+            ctx.appendRelations[relationName].map(([rowIndex, data]) => [
+              all[rowIndex],
+              data
+            ])
+          );
         };
-      }
-      pushQueryArray(
-        q,
-        "afterQuery",
-        appendRelationsKeys.map((relationName) => {
-          return (q2, result) => {
-            var _a, _b;
-            const all = resultOfTypeAll || result;
-            return (_b = (_a = relations[relationName]).nestedInsert) == null ? void 0 : _b.call(
-              _a,
-              q2,
-              appendRelations[relationName].map(([rowIndex, data2]) => [
-                all[rowIndex],
-                data2
-              ])
-            );
-          };
-        })
-      );
-    }
-    q.query.type = "insert";
-    q.query.columns = columns;
-    q.query.values = values;
-    if (prependRelationsKeys.length || appendRelationsKeys.length) {
-      q.query.wrapInTransaction = true;
-    }
-    q.query.returnType = appendRelationsKeys.length ? "all" : returnType;
-    return q;
+      })
+    );
+  }
+  if (prependRelationsKeys.length || appendRelationsKeys.length) {
+    q.query.wrapInTransaction = true;
+  }
+  q.query.returnType = appendRelationsKeys.length ? "all" : returnType;
+  return q;
+};
+class Insert {
+  insert(data) {
+    return this.clone()._insert(data);
+  }
+  _insert(data) {
+    const ctx = createInsertCtx(this);
+    return insert(
+      this,
+      handleInsertOneData(this, data, ctx),
+      getInsertSingleReturnType(this),
+      ctx
+    );
+  }
+  insertMany(data) {
+    return this.clone()._insertMany(data);
+  }
+  _insertMany(data) {
+    const ctx = createInsertCtx(this);
+    return insert(
+      this,
+      handleInsertManyData(this, data, ctx),
+      getInsertManyReturnType(this),
+      ctx
+    );
+  }
+  insertRaw(data) {
+    return this.clone()._insertRaw(data);
+  }
+  _insertRaw(data) {
+    return insert(
+      this,
+      data,
+      getInsertManyReturnType(this)
+    );
   }
   create(data) {
     return this.clone()._create(data);
@@ -4442,7 +4471,25 @@ class Insert {
     if (!this.query.select) {
       this.query.select = ["*"];
     }
-    return this.insert(data);
+    return this.clone()._insert(data);
+  }
+  createMany(data) {
+    return this.clone()._createMany(data);
+  }
+  _createMany(data) {
+    if (!this.query.select) {
+      this.query.select = ["*"];
+    }
+    return this.clone()._insertMany(data);
+  }
+  createRaw(data) {
+    return this.clone()._createRaw(data);
+  }
+  _createRaw(data) {
+    if (!this.query.select) {
+      this.query.select = ["*"];
+    }
+    return this.clone()._insertRaw(data);
   }
   defaults(data) {
     return this.clone()._defaults(data);