leoric 2.9.2 → 2.10.0-beta.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "leoric",
-  "version": "2.9.2",
+  "version": "2.10.0-beta.0",
   "description": "JavaScript Object-relational mapping alchemy",
   "main": "index.js",
   "types": "index.d.ts",
@@ -58,6 +58,26 @@
     "sqlstring": "^2.3.0",
     "validator": "^13.5.2"
   },
+  "peerDependencies": {
+    "mysql": "^2.17.1",
+    "mysql2": "^2.3.0",
+    "pg": "^8.5.1",
+    "sqlite3": "^5.0.2"
+  },
+  "peerDependenciesMeta": {
+    "mysql": {
+      "optional": true
+    },
+    "mysql2": {
+      "optional": true
+    },
+    "pg": {
+      "optional": true
+    },
+    "sqlite3": {
+      "optional": true
+    }
+  },
   "devDependencies": {
     "@babel/core": "^7.14.6",
     "@babel/eslint-parser": "^7.14.7",

package/src/bone.js

@@ -1591,33 +1591,37 @@ class Bone {
 
   static async transaction(callback) {
     const connection = await this.driver.getConnection();
+    const begin = async () => await this.driver.begin({ Model: this, connection });
+    const commit = async () => await this.driver.commit({ Model: this, connection });
+    const rollback = async () => await this.driver.rollback({ Model: this, connection });
+
     let result;
     if (callback.constructor.name === 'AsyncFunction') {
       // if callback is an AsyncFunction
-      await this.driver.query('BEGIN', [], { connection, Model: this, command: 'BEGIN'  });
+      await begin();
       try {
-        result = await callback({ connection });
-        await this.driver.query('COMMIT', [], { connection, Model: this, command: 'COMMIT'  });
+        result = await callback({ connection, commit, rollback });
+        await commit();
       } catch (err) {
-        await this.driver.query('ROLLBACK', [], { connection, Model: this, command: 'ROLLBACK' });
+        await rollback();
         throw err;
       } finally {
         connection.release();
       }
     } else if (callback.constructor.name === 'GeneratorFunction') {
-      const gen = callback({ connection });
+      const gen = callback({ connection, commit, rollback });
 
       try {
-        await this.driver.query('BEGIN', [], {  connection, Model: this, command: 'BEGIN' });
+        await begin();
         while (true) {
           const { value: spell, done } = gen.next(result);
           if (spell instanceof Spell) spell.connection = connection;
           result = spell && typeof spell.then === 'function' ? await spell : spell;
           if (done) break;
         }
-        await this.driver.query('COMMIT', [], {  connection, Model: this, command: 'COMMIT' });
+        await commit();
       } catch (err) {
-        await this.driver.query('ROLLBACK', [], { connection, Model: this, command: 'ROLLBACK' });
+        await rollback();
         throw err;
       } finally {
         connection.release();
@@ -1716,7 +1720,7 @@ class Bone {
 }
 
 const Spell_methods = [
-  'select', 'join', 'where', 'group', 'order', 'get', 'count', 'average', 'minimum', 'maximum', 'sum',
+  'select', 'join', 'where', 'group', 'order', 'get', 'count', 'average', 'minimum', 'maximum', 'sum', 'from',
 ];
 for (const method of Spell_methods) {
   Object.defineProperty(Bone, method, {

package/src/drivers/abstract/index.js

@@ -213,6 +213,22 @@ class AbstractDriver {
     await this.query(sql);
   }
 
+  async rollback(opts) {
+    const connection = opts.connection || await this.getConnection();
+    return await this.query('ROLLBACK', [], { command: 'ROLLBACK', ...opts, connection });
+  }
+
+  async commit(opts) {
+    const connection = opts.connection || await this.getConnection();
+
+    return await this.query('COMMIT', [], { command: 'COMMIT', ...opts, connection });
+  }
+
+  async begin(opts) {
+    const connection = opts.connection || await this.getConnection();
+    return await this.query('BEGIN', [], { command: 'BEGIN', ...opts, connection });
+  }
+
 };
 
 module.exports = AbstractDriver;

package/src/drivers/abstract/spellbook.js

@@ -2,65 +2,10 @@
 
 const SqlString = require('sqlstring');
 
-const { copyExpr, findExpr, walkExpr } = require('../../expr');
+const { findExpr, walkExpr } = require('../../expr');
 const { formatExpr, formatConditions, collectLiteral, isAggregatorExpr } = require('../../expr_formatter');
 const Raw = require('../../raw').default;
 
-/**
- * Create a subquery to make sure OFFSET and LIMIT on left table takes effect.
- * @param {Spell} spell
- */
-function createSubspell(spell) {
-  const { Model, columns, joins, whereConditions, orders } = spell;
-  const baseName = Model.tableAlias;
-  const subspell = spell.dup;
-
-  subspell.columns = [];
-  for (const token of columns) {
-    walkExpr(token, ({ type, qualifiers, value }) => {
-      if (type == 'id' && qualifiers[0] == baseName) {
-        subspell.columns.push({ type, value });
-      }
-    });
-  }
-
-  // If columns were whitelisted, make sure JOIN columns are included.
-  if (subspell.columns.length > 0) {
-    for (const qualifier in joins) {
-      const association = joins[qualifier];
-      walkExpr(association.on, ({ type, qualifiers, value }) => {
-        if (type == 'id' && qualifiers[0] == baseName) {
-          subspell.columns.push({ type, value });
-        }
-      });
-    }
-  }
-
-  // TODO: how to handle subqueries with GROUP?
-  subspell.groups = [];
-
-  subspell.whereConditions = [];
-  while (whereConditions.length > 0) {
-    const condition = whereConditions.shift();
-    const token = copyExpr(condition, ({ type, value }) => {
-      if (type === 'id') return { type, value };
-    });
-    subspell.whereConditions.push(token);
-  }
-
-  subspell.orders = [];
-  for (const order of orders) {
-    const [token, direction] = order;
-    const { type, qualifiers = [], value } = token;
-    if (type == 'id' && qualifiers[0] == baseName) {
-      subspell.orders.push([{ type, value }, direction]);
-      if (subspell.columns.length > 0) subspell.columns.push({ type, value });
-    }
-  }
-
-  return subspell;
-}
-
 /**
  * Make sure columns are qualified
  */
@@ -247,7 +192,8 @@ class SpellBook {
    * @param {Spell} spell
    */
   formatSelectWithoutJoin(spell) {
-    const { columns, whereConditions, groups, havingConditions, orders, rowCount, skip } = spell;
+    const { columns, whereConditions, groups, havingConditions, orders, rowCount, skip, Model } = spell;
+    const { escapeId } = Model.driver;
     const chunks = ['SELECT'];
     const values = [];
 
@@ -273,7 +219,8 @@ class SpellBook {
     const table = formatExpr(spell, spell.table);
     chunks.push(`FROM ${table}`);
     if (spell.table.value instanceof spell.constructor) {
-      chunks.push(`AS t${spell.subqueryIndex++}`);
+      const subTableAlias = spell.table.value.Model && spell.table.value.Model.tableAlias;
+      chunks.push(`AS ${subTableAlias? escapeId(subTableAlias) : `t${spell.subqueryIndex++}`}`);
     }
 
     // see https://dev.mysql.com/doc/refman/8.0/en/index-hints.html
@@ -534,24 +481,13 @@ class SpellBook {
     }
     chunks.push(selects.join(', '));
 
-    let hoistable = skip > 0 || rowCount > 0;
-    if (hoistable) {
-      function checkQualifier({ type, qualifiers = [] }) {
-        if (type === 'id' && qualifiers.length> 0 && !qualifiers.includes(baseName)) {
-          hoistable = false;
-        }
-      }
-      for (const condition of whereConditions) walkExpr(condition, checkQualifier);
-      for (const orderExpr of orders) walkExpr(orderExpr[0], checkQualifier);
-    }
-
-    if (hoistable) {
-      const subspell = createSubspell(spell);
-      const subquery = this.formatSelectWithoutJoin(subspell);
-      values.push(...subquery.values);
-      chunks.push(`FROM (${subquery.sql}) AS ${escapeId(baseName)}`);
+    const table = formatExpr(spell, spell.table);
+    chunks.push(`FROM ${table}`);
+    if (spell.table.value instanceof spell.constructor) {
+      const subTableAlias = spell.table.value.Model && spell.table.value.Model.tableAlias;
+      chunks.push(`AS ${subTableAlias? escapeId(subTableAlias) : `t${spell.subqueryIndex++}`}`);
     } else {
-      chunks.push(`FROM ${escapeId(Model.table)} AS ${escapeId(baseName)}`);
+      chunks.push(`AS ${escapeId(baseName)}`);
     }
 
     for (const qualifier in joins) {
@@ -581,10 +517,8 @@ class SpellBook {
     }
 
     if (orders.length > 0) chunks.push(`ORDER BY ${this.formatOrders(spell, orders).join(', ')}`);
-    if (!hoistable) {
-      if (rowCount > 0) chunks.push(`LIMIT ${rowCount}`);
-      if (skip > 0) chunks.push(`OFFSET ${skip}`);
-    }
+    if (rowCount > 0) chunks.push(`LIMIT ${rowCount}`);
+    if (skip > 0) chunks.push(`OFFSET ${skip}`);
     return { sql: chunks.join(' '), values };
   }
 

package/src/types/abstract_bone.d.ts

@@ -264,6 +264,8 @@ export class AbstractBone {
 
   static initialize(): void;
 
+  static from<T extends typeof AbstractBone>(table: string | Spell<T>): Spell<T>;
+
   constructor(values: { [key: string]: Literal }, opts?: { isNewRecord?: boolean });
 
   /**