react-native-flipper-databases/lib/commonjs/mappers.js

Flipper Databases plugin for React Native

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.databaseExecuteSqlResponseToFlipperObject = databaseExecuteSqlResponseToFlipperObject;
exports.databaseGetTableDataReponseToFlipperObject = databaseGetTableDataReponseToFlipperObject;
exports.databaseGetTableInfoResponseToFlipperObject = databaseGetTableInfoResponseToFlipperObject;
exports.databaseGetTableStructureResponseToFlipperObject = databaseGetTableStructureResponseToFlipperObject;
exports.databaseListToFlipperArray = databaseListToFlipperArray;
exports.flipperObjectToExecuteSqlRequest = flipperObjectToExecuteSqlRequest;
exports.flipperObjectToGetTableDataRequest = flipperObjectToGetTableDataRequest;
exports.flipperObjectToGetTableInfoRequest = flipperObjectToGetTableInfoRequest;
exports.flipperObjectToGetTableStructureRequest = flipperObjectToGetTableStructureRequest;
exports.toErrorFlipperObject = toErrorFlipperObject;

async function databaseListToFlipperArray(databaseDescriptorHolderList) {
  const databases = [];

  for (const databaseDescriptorHolder of databaseDescriptorHolderList) {
    const {
      databaseDescriptor,
      databaseDriver,
      id
    } = databaseDescriptorHolder;
    const tableNameList = await databaseDriver.getTableNames(databaseDescriptor);
    databases.push({
      id,
      name: databaseDescriptor.name,
      tables: tableNameList.sort()
    });
  }

  return databases;
}

function flipperObjectToGetTableStructureRequest(params) {
  const databaseId = params.databaseId;
  const table = params.table;

  if (databaseId <= 0 || !table) {
    return null;
  }

  return {
    databaseId,
    table
  };
}

function databaseGetTableStructureResponseToFlipperObject(databaseGetTableStructureResponse) {
  const structureColumns = databaseGetTableStructureResponse.structureColumns;
  const indexesColumns = databaseGetTableStructureResponse.indexesColumns;
  const structureValues = [];

  for (const row of databaseGetTableStructureResponse.structureValues) {
    const cols = [];

    for (const item of row) {
      cols.push(objectAndTypeToFlipperObject(item));
    }

    structureValues.push(cols);
  }

  const indexesValues = [];

  for (const row of databaseGetTableStructureResponse.indexesValues) {
    const cols = [];

    for (const item of row) {
      cols.push(objectAndTypeToFlipperObject(item));
    }

    indexesValues.push(cols);
  }

  return {
    structureColumns,
    structureValues,
    indexesColumns,
    indexesValues
  };
}

function flipperObjectToGetTableDataRequest(params) {
  const databaseId = params.databaseId;
  const table = params.table;
  const reverse = params.reverse;
  const order = params.order;
  const start = params.start;
  const count = params.count;

  if (databaseId <= 0 || !table) {
    return null;
  }

  return {
    databaseId,
    table,
    order,
    reverse,
    start,
    count
  };
}

function databaseGetTableDataReponseToFlipperObject(databaseGetTableDataResponse) {
  const columns = [...databaseGetTableDataResponse.columns];
  const rows = [];

  for (const row of databaseGetTableDataResponse.values) {
    const rowData = [];

    for (const item of row) {
      rowData.push(objectAndTypeToFlipperObject(item));
    }

    rows.push(rowData);
  }

  return {
    columns,
    values: rows,
    start: databaseGetTableDataResponse.start,
    count: databaseGetTableDataResponse.count,
    total: databaseGetTableDataResponse.total
  };
}

function flipperObjectToGetTableInfoRequest(params) {
  const databaseId = params.databaseId;
  const table = params.table;

  if (databaseId <= 0 || !table) {
    return null;
  }

  return {
    databaseId,
    table
  };
}

function databaseGetTableInfoResponseToFlipperObject(databaseGetTableInfoResponse) {
  return {
    definition: databaseGetTableInfoResponse.definition
  };
}

function flipperObjectToExecuteSqlRequest(params) {
  const databaseId = params.databaseId;
  const value = params.value;

  if (databaseId <= 0 || !value) {
    return null;
  }

  return {
    databaseId,
    value
  };
}

function databaseExecuteSqlResponseToFlipperObject(databaseExecuteSqlResponse) {
  const columns = [];

  if (databaseExecuteSqlResponse.columns !== null) {
    for (const columnName of databaseExecuteSqlResponse.columns) {
      columns.push(columnName);
    }
  }

  const rows = [];

  if (databaseExecuteSqlResponse.values !== null) {
    for (const row of databaseExecuteSqlResponse.values) {
      const values = [];

      for (const item of row) {
        values.push(objectAndTypeToFlipperObject(item));
      }

      rows.push(values);
    }
  }

  return {
    type: databaseExecuteSqlResponse.type,
    columns: columns,
    values: rows,
    insertedId: databaseExecuteSqlResponse.insertedId,
    affectedCount: databaseExecuteSqlResponse.affectedCount
  };
}

function toErrorFlipperObject(code, message) {
  return {
    code,
    message
  };
} // PRIVATE


function objectAndTypeToFlipperObject(obj) {
  if (obj === null || typeof obj === 'undefined') {
    return {
      type: 'null'
    };
  }

  if (typeof obj === 'bigint') {
    return {
      type: 'integer',
      value: obj
    };
  }

  if (typeof obj === 'number') {
    return {
      type: 'float',
      value: obj
    };
  }

  if (typeof obj === 'string') {
    return {
      type: 'string',
      value: obj
    };
  }

  if (typeof obj === 'boolean') {
    return {
      type: 'boolean',
      value: obj
    };
  }

  throw new Error('type of Object is invalid');
}
//# sourceMappingURL=mappers.js.map