fix: fixed backwards compatibility issues

Author: titanism

lib/dialects/base/blocks.js

@@ -855,4 +855,31 @@ module.exports = function (dialect) {
 
     throw new TypeError('Unknown `type` property value "' + type + '"');
   });
+
+  dialect.blocks.add('insert:values', (parameters) => {
+    let { values } = parameters;
+
+    if (!isArray(values)) {
+      values = [values];
+    }
+
+    const fields =
+      parameters.fields ||
+      map(values, (row) => keys(row))
+        .flat()
+        .filter((value, index, array) => array.indexOf(value) === index);
+
+    return dialect.buildTemplate('insertValues', {
+      fields,
+      values: map(values, (row) =>
+        map(fields, (field) =>
+          dialect.buildBlock('value', { value: row[field] })
+        )
+      ),
+    });
+  });
+
+  dialect.blocks.add('insertValues:values', (parameters) =>
+    map(parameters.values, (row) => '(' + row.join(', ') + ')').join(', ')
+  );
 };

lib/dialects/base/index.js

@@ -5,7 +5,7 @@ const blocksInit = require('./blocks.js');
 const operatorsInit = require('./operators/index.js');
 const modifiersInit = require('./modifiers.js');
 
-const blockRegExp = /{([a-z\d]+)}/gi;
+const blockRegExp = /{([a-z\d:]+)}/gi;
 
 function Dialect(builder) {
   this.builder = builder;
@@ -62,18 +62,46 @@ Dialect.prototype.buildQuery = function (query) {
   return this.buildTemplate(template.pattern, query);
 };
 
-Dialect.prototype.buildTemplate = function (template, query) {
-  const result = template.replaceAll(blockRegExp, (match, blockName) => {
-    const block = this.blocks.get(blockName);
+Dialect.prototype.buildTemplate = function (templateName, query) {
+  // If templateName is already a pattern string, use it directly
+  if (typeof templateName === 'string' && templateName.includes('{')) {
+    const template = templateName;
+    const result = template.replaceAll(blockRegExp, (match, blockName) => {
+      const block = this.blocks.get(blockName);
 
-    if (!block) {
-      // Return empty string for unknown blocks instead of throwing error
-      return '';
-    }
+      if (!block) {
+        // Return empty string for unknown blocks instead of throwing error
+        return '';
+      }
+
+      const blockResult = block.call(this, query);
+      return blockResult || '';
+    });
+
+    // Clean up extra spaces
+    return result.replaceAll(/\s+/g, ' ').trim();
+  }
+
+  // Otherwise, get the template by name
+  const template = this.templates.get(templateName);
+  if (!template) {
+    throw new Error('Unknown template "' + templateName + '"');
+  }
 
-    const blockResult = block.call(this, query);
-    return blockResult || '';
-  });
+  const result = template.pattern.replaceAll(
+    blockRegExp,
+    (match, blockName) => {
+      const block = this.blocks.get(blockName);
+
+      if (!block) {
+        // Return empty string for unknown blocks instead of throwing error
+        return '';
+      }
+
+      const blockResult = block.call(this, query);
+      return blockResult || '';
+    }
+  );
 
   // Clean up extra spaces
   return result.replaceAll(/\s+/g, ' ').trim();

lib/dialects/base/templates.js

@@ -68,7 +68,7 @@ module.exports = function (dialect) {
   });
 
   dialect.templates.add('insertValues', {
-    pattern: '({fields}) values {values}',
+    pattern: '({fields}) values {insertValues:values}',
     validate(type, parameters) {
       templateChecks.requiredProp('values', parameters, 'fields');
       templateChecks.propType('values', parameters, 'fields', 'array');
@@ -250,7 +250,7 @@ module.exports = function (dialect) {
 
   dialect.templates.add('insert', {
     pattern:
-      '{with} {withRecursive} insert {or} into {table} {values} {condition} ' +
+      '{with} {withRecursive} insert {or} into {table} {insert:values} {condition} ' +
       '{returning}',
     validate(type, parameters) {
       templateChecks.onlyOneOfProps(type, parameters, [