paco_sako_server/sqlite3-promises.js

const sqlite3 = module.exports = require('sqlite3');

sqlite3.openAsync = function openAsync(filename, mode) {
  if (arguments.length < 2) {
    mode = sqlite3.OPEN_READWRITE | sqlite3.OPEN_CREATE;
  }
  return new Promise((resolve, reject) => {
    const db = new sqlite3.Database(filename, mode, (err) => {
      if (err) {
        reject(err);
      } else {
        resolve(db);
      }
    });
  });
};

sqlite3.openAsyncCached = function openAsyncCached(filename, mode) {
  if (arguments.length < 2) {
    mode = sqlite3.OPEN_READWRITE | sqlite3.OPEN_CREATE;
  }
  return new Promise((resolve, reject) => {
    const db = new sqlite3.cached.Database(filename, mode, (err) => {
      if (err) {
        reject(err);
      } else {
        resolve(db);
      }
    });
  });
};

sqlite3.Database.prototype.runAsync = function runAsync(sql, params) {
  const db = this;
  if (typeof params !== 'object') {
    params = [...arguments].slice(1);
  }
  return new Promise((resolve, reject) => {
    db.run(sql, params, (err) => {
      if (err) {
        reject(err);
      } else {
        resolve(db);
      }
    });
  });
};

sqlite3.Database.prototype.getAsync = function getAsync(sql, params) {
  const db = this;
  if (typeof params !== 'object') {
    params = [...arguments].slice(1);
  }
  return new Promise((resolve, reject) => {
    db.get(sql, params, (err, row) => {
      if (err) {
        reject(err);
      } else {
        resolve(row);
      }
    });
  });
};

sqlite3.Database.prototype.allAsync = function allAsync(sql, params) {
  const db = this;
  if (typeof params !== 'object') {
    params = [...arguments].slice(1);
  }
  return new Promise((resolve, reject) => {
    db.all(sql, params, (err, rows) => {
      if (err) {
        reject(err);
      } else {
        resolve(rows);
      }
    });
  });
};

/* Returns an async iterator; use with `for await` or simply `await result.next()`. */
/* For details see <https://javascript.info/async-iterators-generators>. */
sqlite3.Database.prototype.eachAsync = function eachAsync(sql, params) {
  const db = this;
  if (typeof params !== 'object') {
    params = [...arguments].slice(1);
  }
  const first = new Promise((resolve, reject) => {
    let resolve_row = resolve;
    let reject_row = reject;
    db.each(sql, params, (err, row) => {
      if (err) {
        reject_row(err);
      } else {
        let resolve_next;
        let reject_next;
        const next = new Promise((resolve2, reject2) => {
          resolve_next = resolve2;
          reject_next = reject2;
        });
        resolve_row({ done: false, value: row, next: next });
        resolve_row = resolve_next;
        reject_row = reject_next;
      }
    }, (err) => {
      if (err) {
        reject_row(err);
      } else {
        resolve_row({ done: true });
      }
    });
  });

  let current = first;
  return {
    [Symbol.asyncIterator]() {
      return this;
    },

    async next() {
      const result = await current;
      if (result.done) {
        return { done: true };
      } else {
        current = result.next;
        return { done: false, value: result.value };
      }
    }
  };
};

sqlite3.Database.prototype.execAsync = function execAsync(sql) {
  const db = this;
  return new Promise((resolve, reject) => {
    db.exec(sql, (err) => {
      if (err) {
        reject(err);
      } else {
        resolve(db);
      }
    });
  });
};