react-native-flipper-databases/lib/commonjs/drivers/QuickSQLite.js

Flipper Databases plugin for React Native

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.QuickSQLiteStorageDriver = void 0;

const doQuery = (database, query) => {
  return new Promise((resolve, reject) => {
    database.executeSql(query, [], result => resolve(result), message => reject(`failed: ${message}`));
  });
};

class QuickSQLiteStorageDriver {
  constructor(databases) {
    this.databases = databases;
  }

  async getDatabases() {
    return this.databases;
  }

  async getTableNames(_ref) {
    let {
      database
    } = _ref;
    const result = await doQuery(database, `SELECT name FROM sqlite_schema WHERE type IN ('table','view') AND name NOT LIKE 'sqlite_%'`);

    if (result.rows) {
      const tables = [];

      for (let index = 0; index < result.rows.length; index++) {
        tables.push(result.rows.item(index).name);
      }

      return tables;
    }

    return [];
  }

  async getTableStructure(_ref2, schema) {
    let {
      database
    } = _ref2;
    const result = await doQuery(database, `PRAGMA table_info(\`${schema}\`)`);

    if (result.rows) {
      const cols = [];

      for (let index = 0; index < result.rows.length; index++) {
        const col = result.rows.item(index);
        cols.push([col.name, col.type, Boolean(col.notnull), Boolean(col.pk), col.dflt_value]);
      }

      return {
        structureColumns: ['name', 'type', 'not null', 'primary key', 'default value'],
        structureValues: cols,
        indexesColumns: ['name', 'type'],
        indexesValues: cols.filter(col => col[3]).map(_ref3 => {
          let [name, type] = _ref3;
          return [name, type];
        })
      };
    }

    return {
      structureColumns: [],
      structureValues: [],
      indexesColumns: [],
      indexesValues: []
    };
  }

  async getTableData(databaseDescriptor, schema, order, reverse, start, count) {
    const {
      structureValues
    } = await this.getTableStructure(databaseDescriptor, schema);
    const columns = structureValues.map(_ref4 => {
      let [colName] = _ref4;
      return colName;
    });
    const countResult = await doQuery(databaseDescriptor.database, `SELECT COUNT(*) as count FROM \`${schema}\``);

    if (countResult.rows) {
      const totalCount = countResult.rows.item(0).count;
      const orderCol = order ?? 'rowid';
      const orderSort = reverse ? 'DESC' : 'ASC';
      const result = await doQuery(databaseDescriptor.database, `SELECT * FROM \`${schema}\` ORDER BY ${orderCol} ${orderSort} LIMIT ${count} OFFSET ${start}`);

      if (result.rows) {
        const values = [];

        for (let index = 0; index < result.rows.length; index++) {
          const row = result.rows.item(index);
          values.push(columns.map(colName => row[colName]));
        }

        return {
          columns,
          values,
          start,
          count: result.rows.length,
          total: totalCount
        };
      }
    }

    return {
      columns: [],
      values: [],
      start: 0,
      count: 0,
      total: 0
    };
  }

  async getTableInfo(_ref5, table) {
    let {
      database
    } = _ref5;
    const result = await doQuery(database, `SELECT sql FROM sqlite_schema WHERE name = "${table}"`);

    if (result.rows) {
      return {
        definition: result.rows.item(0).sql
      };
    }

    return {
      definition: ''
    };
  }

  async executeSql() {
    return Promise.reject('Unsupported method');
  }

}

exports.QuickSQLiteStorageDriver = QuickSQLiteStorageDriver;
//# sourceMappingURL=QuickSQLite.js.map