falcon-client/falcon-core

The cross-database ORM that powers falcon

falcon-core's Issues

PR: deleteTable(), truncateTable()

PR: Manage Connections

• Validation of connections
• Encryption of passwords
• Supporting persistence of meta keys

Graphql broken when sqlite does not have primary key

PR: sqlite read-only

Ideal API

The API from sqlectron was pretty unorganized. Because falcon-core was a fork of it, we had to borrow its architecture. I think core has matured enough to the point where we can migrate away from sqlectron's API and move towards one of our own: one that's more object oriented and namespaced to allow for faster imports, which we need. To keep a lot of the lower level database specific logic out of the UI, this newer API for falcon-core should be higher level.

import { ConnectionPool, ConnectionManager } from 'falcon-core';
import { SqliteProvider } from 'falcon-core/sqlite';

const connetionManager = new ConnetionManager();
const pool = new ConnectionPool();
const provider = new SqliteProvider();

const dbConn = await provider.connect({
  database: 'demo.sqlite',
  readonly: true
});
connectionManager.add(dbConn.config);
pool.add(dbConn);

// Connect to a favorite connection
const [firstConnection] = await connectionManager.getAll();
firstConnection.connect();

PR: Deprecate `./lib`

PR: Test Connection

Complements falcon-client/falcon#45

Infra updates

• lint-staged
• fix eslint errors
• disable flow type-errors plugin

Schema CRUD

https://www.sqlite.org/lang_altertable.html

The sqlite docs actually discuss how to manipulate the schema. We should investigate this.

UPDATE: db browser uses this file to create and transform sqlite ast's

• https://github.com/sqlitebrowser/sqlitebrowser/blob/master/src/sqlitetypes.cpp#L673
• https://github.com/sqlitebrowser/sqlitebrowser/blob/master/src/sqlitetypes.cpp#L455
• https://gitter.im/sqlitebrowser/sqlitebrowser?at=5acfdc137c3a01610dd80595

UPDATE: Make sure to take advantage of sqlite savepoints. Create a savepoint before making schema changes

Add rollup support

Add rollup to bundle all the code and the deps. This is much better than publishing the packages themselves

PR: Get all metadata/configs

Similar to this

PR: Test ssh tunnelling queries

Create a `getDatabasePrimaryKeys()` method

Would be useful in the falcon front to offload some of the logic. Right now it's convoluted

PR: Manage Queries

See falcon-client/falcon#21

PR: SQLite Query Formatting

Investigate:

• https://github.com/mrdziuban/sql-formatter

RFC: getSupportedFeatures()

The basic idea with this is that each provider can return a list of features it supports. ex:

connection.hasFeatures('views') // false

CRUD method API update

Reference: https://www.sqlite.org/withoutrowid.html

• SQLite has two types of tables:
  • Ones with rowid - these may or may not have a primary key
  • Ones without rowid - these must have a primary key

TODO:

• Update update() and delete() to handle tables with rowid and without rowid

Investigate: SQLite Update Hooks

• https://www.sqlite.org/c3ref/update_hook.html
• https://www.sqlite.org/c3ref/changes.html
• https://www.sqlite.org/c3ref/total_changes.html
• Meteor live queries

PR: Minimum supported version

Support for erroring if db version is lower than minimum supported version.

PR: Test against race conditions

PR: on*Change methods

• onTableChange: Define a callback to fire when a table is changed
• onDatabaseChange: Define a callback to fire when a database is changed

type cbType = (dbName: string, tableName: string) => Promise<void>;
type onTableChange = (cb: cbType) => Promise<void>;
type onDatabaseChange = (cb: cbType) => Promise<void>;

Use cases:

• re-render the graph on change of the database
• let the UI define a callback to update the tables, schema definition, etc when a table changes

GraphQL Implementations

• MYSQL
• Postgres
• SQLITE

Fix sqlite node 10 compatibility

node-sqlite recently fixed this. Need to bump deps to fix this

PR: Query Builder

INVESTIGATE: User Timing API

• https://developer.mozilla.org/en-US/docs/Web/API/User_Timing_API
• https://nodejs.org/api/perf_hooks.html

PR: Remove database requirement

The current API requires the database to be given as a configuration argument to falcon. Sometimes the user might not know the database of a given connection. This works for sqlite but it wont work for other database types, such as mysql which can have multiple databases.

Change all the methods in ProviderInterface to accept a database argument before the table

PR: Support for showing users and privileges

Many databases show details of users, each of which have certain privileges. We need to be able to expose users and their privileges through an API.

We can ignore this for sqlite but we'll eventually need to implement this for other databases

Action required: Greenkeeper could not be activated 🚨

🚨 You need to enable Continuous Integration on all branches of this repository. 🚨

To enable Greenkeeper, you need to make sure that a commit status is reported on all branches. This is required by Greenkeeper because it uses your CI build statuses to figure out when to notify you about breaking changes.

Since we didn’t receive a CI status on the greenkeeper/initial branch, it’s possible that you don’t have CI set up yet. We recommend using Travis CI, but Greenkeeper will work with every other CI service as well.

If you have already set up a CI for this repository, you might need to check how it’s configured. Make sure it is set to run on all new branches. If you don’t want it to run on absolutely every branch, you can whitelist branches starting with greenkeeper/.

Once you have installed and configured CI on this repository correctly, you’ll need to re-trigger Greenkeeper’s initial pull request. To do this, please delete the greenkeeper/initial branch in this repository, and then remove and re-add this repository to the Greenkeeper App’s white list on Github. You'll find this list on your repo or organization’s settings page, under Installed GitHub Apps.

PR: Make errors throw

I forgot that es6 built-ins are extendable. Instead of returning an array of error messages, we can use try/catch by creating a class like this:

class FalconError extends Error {
  constructor(message, data) {
    super(message)
    this.data = data
  }
}

try {
  throw new FalconError('falcon err here', { foo: 'asdf' })
  console.log('asdf')
} catch(e) {
  console.log(e.data)
}

Investigate sqorn for string builder

https://github.com/lusakasa/sqorn

Bug: Restart the GraphQL server when the schema changes

PR: Get runtime performance metrics

• SQLite
  • www.sqlite.org/c3ref/status.html
  • www.sqlite.org/c3ref/db_status.html

Migrate to independent service provider architecture

The current api requires all the service providers to be loaded when falcon-core is imported. falcon-core currently takes about an entire second to load. Each provider requires its own native dependency. For example, the SqliteProvider depends on sqlite3, which is a native dep. Webpack can't work with native deps yet so this really hurts our perf of importing native deps (which includes falcon-core). We should migrate to an api which allows users of falcon-core to import only the providers they need like so:

async function main() {
  const  { SqliteProvider } = import('falcon-core')
  const serverInfo = {...};
  const serverSession = db.createServer(SqliteProvider, serverInfo);
  const connection = await serverSession.createConnection('demo.sqlite');
  await connection.connect();
  const schema = await connection.getSchema('tracks');
}