Skip to content
This repository has been archived by the owner on Sep 7, 2021. It is now read-only.
/ cordova-sqlite-evplus-legacy-attach-detach-free Public archive

Cordova sqlite storage plugin, free enterprise version (GPL) for Android and iOS with memory improvement, support for attach/detach, and other extra features

License

View license
1 star 3 forks Branches Tags Activity
Star
Notifications You must be signed in to change notification settings

brodycj/cordova-sqlite-evplus-legacy-attach-detach-free

BranchesTags

Folders and files

NameName
Last commit message
Last commit date

Latest commit

 

History

982 Commits
bin
bin
 
 
node_modules
node_modules
 
 
scripts
scripts
 
 
spec
spec
 
 
src
src
 
 
tests
tests
 
 
www
www
 
 
.gitignore
.gitignore
 
 
.travis.yml
.travis.yml
 
 
AUTHORS.md
AUTHORS.md
 
 
CHANGES.md
CHANGES.md
 
 
HISTORY.md
HISTORY.md
 
 
LICENSE.md
LICENSE.md
 
 
README.md
README.md
 
 
SQLitePlugin.coffee.md
SQLitePlugin.coffee.md
 
 
circle.yml
circle.yml
 
 
package.json
package.json
 
 
plugin.xml
plugin.xml
 
 

Repository files navigation

Cordova/PhoneGap sqlite storage - premium enterprise version with legacy support for memory improvements, ATTACH/DETACH (Android/iOS/macOS), and TBD other extra features

Native interface to sqlite in a Cordova/PhoneGap plugin for Android, iOS, macOS, and Windows 10 UWP (Universal Windows Platform), with API similar to HTML5/Web SQL API.

This plugin version is available under GPL v3 (http://www.gnu.org/licenses/gpl.txt) or a premium commercial license.

NOTE: Commercial licenses for Cordova-sqlite-enterprise-free purchased before July 2016 are valid for this plugin version. Commercial licenses for Cordova-sqlite-evcore versions are NOT valid for this plugin version.

About this plugin version branch

This plugin version branch includes ATTACH/DETACH support for Android/iOS/macOS, some memory usage improvements for Android/iOS/macOS, and TBD other extra features.

NOTE: This version branch has some additional known issues fixed in newer version branches.

WARNING: Multiple SQLite problem on Android

This plugin uses a non-standard Android-sqlite-connector implementation on Android. In case an application access the same database using multiple plugins there is a risk of data corruption ref: litehelpers/Cordova-sqlite-storage#626) as described in http://ericsink.com/entries/multiple_sqlite_problem.html and https://www.sqlite.org/howtocorrupt.html.

The workaround is to use the androidDatabaseImplementation: 2 setting as described in the Android sqlite implementation section below:

var db = window.sqlitePlugin.openDatabase({name: "my.db", androidDatabaseImplementation: 2});

IMPORTANT: iCloud backup of SQLite database is NOT allowed

As documented in the "A User’s iCloud Storage Is Limited" section of iCloudFundamentals in Mac Developer Library iCloud Design Guide (near the beginning):

  • DO store the following in iCloud:
    • [other items omitted]
    • Change log files for a SQLite database (a SQLite database’s store file must never be stored in iCloud)
  • DO NOT store the following in iCloud:
    • [items omitted]
- iCloudFundamentals in Mac Developer Library iCloud Design Guide

How to disable iCloud backup

Already fixed in this version: Use the location option in sqlitePlugin.openDatabase() to store the database in a subdirectory that is NOT backed up to iCloud, as described in the section below.

NOTE: Changing BackupWebStorage in config.xml has no effect on a database created by this plugin. BackupWebStorage applies only to local storage and/or Web SQL storage created in the WebView (not using this plugin). For reference: phonegap/build#338 (comment)

Status

  • A recent version of the Cordova CLI (such as 6.5.0 / 7.1.0) is recommended. (Cordova CLI 8.x includes cordova-android@7, NOT supported by this plugin version due to litehelpers/Cordova-sqlite-storage#729.) Cordova versions older than 6.0.0 are missing the cordova-ios@4.0.0 security fixes. In addition it may be necessary to use cordova prepare in case of cordova-ios older than 4.3.0 (Cordova CLI 6.4.0).
  • This plugin is NOT supported by PhoneGap Developer App or PhoneGap Desktop App.
  • Default location for iOS is Library/LocalDatabase, will not be backed up to iCloud (may not be changed in this version)
  • This plugin version will NOT work on cordova-android@7 due to issue with JAR and NDK library files as discussed in litehelpers/Cordova-sqlite-storage#729.
  • Free support is available in litehelpers / Cordova-sqlite-evplus-legacy-attach-detach-free / issues; premium commercial support is available by contacting: sales@litehelpers.net
  • Patches patches will NOT be accepted on this project due to potential licensing issues.
  • SQLite 3.8.10.2 included in this plugin version, with the following definitions:
    • NDEBUG on Windows (Release build only)
    • SQLITE_THREADSAFE=1 (SQLITE_THREADSAFE=2 on Android)
    • SQLITE_DEFAULT_MEMSTATUS=0 (iOS/macOS/Windows)
    • SQLITE_OMIT_DECLTYPE (TBD issue with this option on sqlite 3.8.10.2)
    • SQLITE_OMIT_DEPRECATED (iOS/macOS/Windows)
    • SQLITE_OMIT_PROGRESS_CALLBACK (iOS/macOS/Windows)
    • SQLITE_OMIT_SHARED_CACHE (iOS/macOS/Windows)
    • SQLITE_TEMP_STORE=2
    • SQLITE_OMIT_LOAD_EXTENSION (iOS/macOS/Windows)
    • SQLITE_ENABLE_FTS3
    • SQLITE_ENABLE_FTS3_PARENTHESIS
    • SQLITE_ENABLE_FTS4
    • SQLITE_ENABLE_RTREE
    • SQLITE_DEFAULT_PAGE_SIZE=1024 and SQLITE_DEFAULT_CACHE_SIZE=2000 to avoid "potentially distruptive change(s)" from SQLite 3.12.0 described at: http://sqlite.org/pgszchng2016.html
    • SQLITE_OS_WINRT (Windows only)
    • NDEBUG (Windows only)
  • This plugin version supports the use of two (2) possible Android sqlite database implementations:
  • Windows platform version (using a customized version of the performant doo / SQLite3-WinRT C++ component) has the following known limitations:
  • The macOS platform version ("osx" platform) is not tested in a release build and should be considered pre-alpha.
  • Android versions supported: 2.3.3 - 7.1.1 (API level 10 - 25), depending on Cordova version ref: https://cordova.apache.org/docs/en/latest/guide/platforms/android/
  • iOS versions supported: 8.x / 9.x / 10.x / 11.x
  • FTS3, FTS4, and R-Tree are fully tested and supported for all target platforms in this version branch.
  • Default PRAGMA journal_mode setting (tested):
    • Android pre-8.0 with builtin android.database implementation (as selected using the androidDatabaseImplementation option in window.sqlitePlugin.openDatabase): persist
    • otherwise: delete
  • AUTO-VACUUM is not enabled by default. If no form of VACUUM or PRAGMA auto_vacuum is used then sqlite will automatically reuse deleted data space for new data but the database file will never shrink. For reference: http://www.sqlite.org/pragma.html#pragma_auto_vacuum and litehelpers/Cordova-sqlite-storage#646

Announcements

Highlights

  • Drop-in replacement for HTML5/Web SQL API: the only change should be to replace the static window.openDatabase() factory call with window.sqlitePlugin.openDatabase(), with parameters as documented below.
  • Failure-safe nested transactions with batch processing optimizations (according to HTML5/Web SQL API)
  • Transaction API (based on HTML5/Web SQL API) is designed for maximum flexiblibility, does not allow any transactions to be left hanging open.
  • Pre-populated openDatabase option (usage described below)
  • As described in this posting:
    • Keeps sqlite database in known, platform specific user data location on all supported platforms (Android/iOS/macOS/Windows), which can be reconfigured on iOS/macOS. Whether or not the database on the iOS platform is synchronized to iCloud depends on the selected database location.
    • No arbitrary size limit. SQLite limits described at: http://www.sqlite.org/limits.html
  • Also validated for multi-page applications by internal test selfTest function.
  • This project is self-contained though with sqlite3 dependencies auto-fetched by npm. There are no dependencies on other plugins such as cordova-plugin-file.
  • Windows platform version uses a customized version of the performant doo / SQLite3-WinRT C++ component.
  • SQLCipher support for Android/iOS/macOS/Windows is available in: litehelpers / Cordova-sqlcipher-adapter
  • Intellectual property:
    • All source code is tracked to the original author in git
    • Major authors are tracked in AUTHORS.md
    • License of each component is tracked in LICENSE.md
    • History of this project is also described in HISTORY.md

TIP: It is possible to migrate from Cordova to a pure native solution and continue using the data stored by this plugin.

Some apps using this plugin

TBD your app here

Security

Security of sensitive data

According to Web SQL Database API 7.2 Sensitivity of data:

User agents should treat persistently stored data as potentially sensitive; it's quite possible for e-mails, calendar appointments, health records, or other confidential documents to be stored in this mechanism.

To this end, user agents should ensure that when deleting data, it is promptly deleted from the underlying storage.

Unfortunately this plugin will not actually overwrite the deleted content unless the secure_delete PRAGMA is used.

SQL injection

As "strongly recommended" by Web SQL Database API 8.5 SQL injection:

Authors are strongly recommended to make use of the ? placeholder feature of the executeSql() method, and to never construct SQL statements on the fly.

Avoiding data loss

  • Double-check that the application code follows the documented API for SQL statements, parameter values, success callbacks, and error callbacks.
  • For standard Web SQL transactions include a transaction error callback with the proper logic that indicates to the user if data cannot be stored for any reason. In case of individual SQL error handlers be sure to indicate to the user if there is any issue with storing data.
  • For single statement and batch transactions include an error callback with logic that indicates to the user if data cannot be stored for any reason.

Known issues

  • This plugin will NOT work on cordova-android@7 due to issue with JAR and NDK library files as discussed in litehelpers/Cordova-sqlite-storage#729.
  • The iOS/macOS platform versions do not support certain rapidly repeated open-and-close or open-and-delete test scenarios due to how the implementation handles background processing
  • The Android platform version does not always handle four-byte UTF-8 characters emoji characters such as \u1F603 (SMILING FACE, MOUTH OPEN) correctly ref: litehelpers/Cordova-sqlite-storage#564. It is sometimes possible to store and retrieve such characters but certain operations such as hex conversions do not work properly when using the default Android-sqlite-connector database implementation. It is suspected that such characters would be stored incorrectly by the default Android platform version. Note that this is not an issue in case the built-in Android database is used (using the androidDatabaseImplementation: 2 setting in window.sqlitePlugin.openDatabase)
  • It is possible to request a SQL statement list such as "SELECT 1; SELECT 2" within a single SQL statement string, however the plugin will only execute the first statement and silently ignore the others ref: litehelpers/Cordova-sqlite-storage#551
  • Execution of INSERT statement that affects multiple rows (due to SELECT cause or using TRIGGER(s), for example) reports incorrect rowsAffected on Android in case the built-in Android database used (using the androidDatabaseImplementation option in window.sqlitePlugin.openDatabase)
  • Memory issue observed when adding a large number of records due to the JSON implementation which is improved in litehelpers / Cordova-sqlite-evcore-extbuild-free (GPL or commercial license terms)
  • Infinity (positive or negative) values are not supported on Android/iOS/macOS due to issues described above including a possible crash on iOS/macOS ref: litehelpers/Cordova-sqlite-storage#405
  • A stability issue was reported on the iOS platform version when in use together with SockJS client such as pusher-js at the same time (see litehelpers/Cordova-sqlite-storage#196). The workaround is to call sqlite functions and SockJS client functions in separate ticks (using setTimeout with 0 timeout).
  • FIXED for Android in newer plugin versions such as litehelpers / Cordova-sqlite-storage, litehelpers / cordova-sqlite-ext, and litehelpers / Cordova-sqlite-evcore-extbuild-free: In case of an error, the error code member is bogus on Android and Windows.
  • Possible crash on Android when using Unicode emoji and other 4-octet UTF-8 characters due to Android bug 81341, which should be fixed in Android 6.x
  • Close/delete database bugs described below.
  • When a database is opened and deleted without closing, the iOS/macOS platform version is known to leak resources.
  • It is NOT possible to open multiple databases with the same name but in different locations (iOS/macOS platform version).

Issues fixed in newer version branches

  • Incorrect or missing insertId/rowsAffected in results for INSERT/UPDATE/DELETE SQL statements with extra semicolon(s) in the beginning for Android platform version in case the androidDatabaseImplementation: 2 (built-in android.database implementation) option is used.
  • In case of an error, the error code member is bogus on Android
  • Windows platform version reports NONCOMPLIANT error code (-1) in case of an error
  • iOS platform version generates extra logging in release build
  • iOS platform version may crash if deleteDatabase is called with an object in place of the database name
  • readTransaction does not reject ALTER, REINDEX, and REPLACE operations
  • readTransaction does not reject modification statements with extra semicolon(s) in the beginning
  • extra executeSql callbacks: if a sql statement fails for which there is no error handler or the error handler does not return false to signal transaction recovery, the plugin fires the remaining sql callbacks before aborting the transaction.
  • does not signal an error in case of excess parameter argument values given on iOS/macOS

Some additional issues are tracked in open Cordova-sqlite-storage bug-general issues and open Cordova-sqlite-evplus-legacy-attach-detach-free bug issues.

Other limitations

  • The db version, display name, and size parameter values are not supported and will be ignored.
  • Absolute and relative subdirectory path(s) are not tested or supported.
  • This plugin will not work before the callback for the 'deviceready' event has been fired, as described in Usage. (This is consistent with the other Cordova plugins.)
  • Extremely large records are not supported by this plugin. It is recommended to store images and similar binary data in separate files. TBD: specify maximum record. For future consideration: support in a plugin version such as litehelpers / Cordova-sqlite-evcore-extbuild-free (GPL or commercial license terms).
  • This plugin version will not work within a web worker (not properly supported by the Cordova framework). Use within a web worker is supported for Android/iOS in litehelpers / cordova-sqlite-evmax-ext-workers-legacy-build-free (GPL or premium commercial license terms).
  • In-memory database db=window.sqlitePlugin.openDatabase({name: ':memory:', ...}) is currently not supported.
  • The Android platform version cannot properly support more than 100 open database files due to the threading model used.
  • SQL error messages reported by Windows platform version are not consistent with Android/iOS/macOS platform versions.
  • UNICODE \u2028 (line separator) and \u2029 (paragraph separator) characters are currently not supported and known to be broken on iOS, macOS, and Android platform versions due to JSON issues reported in Cordova bug CB-9435 and cordova/cordova-discuss#57. This is fixed with a workaround for iOS/macOS in: litehelpers / Cordova-sqlite-evplus-legacy-free and litehelpers / Cordova-sqlite-evplus-legacy-attach-detach-free (GPL or special commercial license terms) as well as litehelpers / Cordova-sqlite-evplus-legacy-workers-free (GPL or premium commercial license terms).
  • The BLOB data type is not fully supported on Windows in this version branch. SELECT BLOB with BASE64 conversion function for Android/iOS/macOS/Windows is supported by litehelpers / cordova-sqlite-ext (permissive license terms) and litehelpers / Cordova-sqlite-evcore-extbuild-free (GPL or commercial license terms).
  • Truncation in case of UNICODE \u0000 (same as \0) character on Android (default Android-sqlite-connector database implementation) and Windows.
  • Case-insensitive matching and other string manipulations on Unicode characters, which is provided by optional ICU integration in the sqlite source and working with recent versions of Android, is not supported for any target platforms.
  • The iOS/macOS platform version uses a thread pool but with only one thread working at a time due to "synchronized" database access.
  • Some large query results may be slow, also due to the JSON implementation.
  • UPDATE/DELETE with LIMIT or ORDER BY is not supported.
  • WITH clause is not supported on some older Android platform versions in case the androidDatabaseImplementation: 2 (built-in android.database implementation) option is used.
  • User-defined savepoints are not supported and not expected to be compatible with the transaction locking mechanism used by this plugin. In addition, the use of BEGIN/COMMIT/ROLLBACK statements is not supported.
  • Problems have been reported when using this plugin with Crosswalk (for Android). It may help to install Crosswalk as a plugin instead of using Crosswalk to create the project.
  • Does not work with axemclion / react-native-cordova-plugin since the window.sqlitePlugin object is not properly exported (ES5 feature). It is recommended to use andpor / react-native-sqlite-storage for SQLite database access with React Native Android/iOS instead.

Additional limitations are tracked in marked Cordova-sqlite-storage doc-todo issues.

Further testing needed

  • Integration with PhoneGap developer app
  • Use within InAppBrowser
  • Use within an iframe (see litehelpers/Cordova-sqlite-storage#368 (comment))
  • Date/time handling
  • Maximum record size supported
  • Actual behavior when using SAVEPOINT(s)
  • R-Tree is not fully tested with Android
  • UNICODE characters not fully tested
  • ORDER BY RANDOM() (ref: litehelpers/Cordova-sqlite-storage#334)
  • UPDATE/DELETE with LIMIT or ORDER BY (newer Android/iOS versions)
  • Integration with JXCore for Cordova (must be built without sqlite(3) built-in)
  • Delete an open database inside a statement or transaction callback.
  • WITH clause (not supported by some older sqlite3 versions)
  • Handling of invalid transaction and transaction.executeSql arguments
  • Use of database locations on macOS
  • Extremely large and small INTEGER and REAL values ref: litehelpers/Cordova-sqlite-storage#627)
  • More emojis and other 4-octet UTF-8 characters
  • ?NNN/:AAA/@AAAA/$AAAA parameter placeholders ref: https://www.sqlite.org/lang_expr.html#varparam, https://www.sqlite.org/c3ref/bind_blob.html)
  • Single-statement and SQL batch transaction calls with invalid arguments (TBD behavior subject to change)

Some tips and tricks

  • If you run into problems and your code follows the asynchronous HTML5/Web SQL transaction API, you can try opening a test database using window.openDatabase and see if you get the same problems.
  • In case your database schema may change, it is recommended to keep a table with one row and one column to keep track of your own schema version number. It is possible to add it later. The recommended schema update procedure is described below.

Pitfalls

Some common pitfall(s)

  • If a database is opened using the standard window.openDatabase call it will not have any of the benefits of this plugin and features such as the sqlBatch call would not be available.
  • It is NOT allowed to execute sql statements on a transaction that has already finished, as described below. This is consistent with the HTML5/Web SQL API.
  • The plugin class name starts with "SQL" in capital letters, but in Javascript the sqlitePlugin object name starts with "sql" in small letters.
  • Attempting to open a database before receiving the 'deviceready' event callback.
  • Inserting STRING into ID field
  • Auto-vacuum is NOT enabled by default. It is recommended to periodically VACUUM the database. If no form of VACUUM or PRAGMA auto_vacuum is used then sqlite will automatically reuse deleted data space for new data but the database file will never shrink. For reference: http://www.sqlite.org/pragma.html#pragma_auto_vacuum and litehelpers/Cordova-sqlite-storage#646
  • Transactions on a database are run sequentially. A large transaction could block smaller transactions requested afterwards.

Some weird pitfall(s)

Angular/ngCordova/Ionic-related pitfalls

General Cordova pitfalls

Documented in: brodybits / Avoiding-some-Cordova-pitfalls

Major TODOs

For future considertion

Alternatives

Comparison of sqlite plugin versions

  • litehelpers / Cordova-sqlite-storage - core plugin version for Android/iOS/macOS/Windows (permissive license terms)
  • litehelpers / cordova-sqlite-ext - plugin version with REGEXP (Android/iOS/macOS), SELECT BLOB in Base64 format (all platforms Android/iOS/macOS/Windows), and pre-populated databases (all platforms Android/iOS/macOS/Windows). Permissive license terms.
  • litehelpers / cordova-sqlite-legacy - support for Windows 8.1/Windows Phone 8.1 along with Android/iOS/macOS/Windows 10, with support for REGEXP (Android/iOS/macOS), SELECT BLOB in Base64 format (all platforms Android/iOS/macOS/Windows), and pre-populated databases (all platforms Android/iOS/macOS/Windows). Limited updates. Permissive license terms.
  • brodybits / cordova-sqlite-legacy-build-support - maintenance of WP8 platform version along with Windows 8.1/Windows Phone 8.1 and the other supported platforms Android/iOS/macOS/Windows 10; limited support for PhoneGap CLI/PhoneGap Build/plugman/Intel XDK; limited testing; limited updates. Permissive license terms.
  • litehelpers / Cordova-sqlcipher-adapter - supports SQLCipher for Android/iOS/macOS/Windows
  • litehelpers / Cordova-sqlite-evcore-extbuild-free - Enhancements for Android: JSON and SQL statement handling implemented in C, supports larger transactions and handles large SQL batches in less than half the time as this plugin version. Supports arbitrary database location on Android. Support for build environments such as PhoneGap Build and Intel XDK. Also includes REGEXP (Android/iOS/macOS) and SELECT BLOB in Base64 format (all platforms Android/iOS/macOS/Windows). GPL or commercial license terms.
  • litehelpers / cordova-sqlite-evplus-ext-legacy-build-free - internal memory improvements to support larger transactions (Android/iOS) and fix to support all Unicode characters (iOS). (GPL or special commercial license terms).
  • litehelpers / Cordova-sqlite-evplus-legacy-attach-detach-free - plugin version with support for ATTACH, includes internal memory improvements to support larger transactions (Android/iOS) and fix to support all Unicode characters (GPL or special commercial license terms).
  • litehelpers / cordova-sqlite-evmax-ext-workers-legacy-build-free - plugin version with support for web workers, includes internal memory improvements to support larger transactions (Android/iOS) and fix to support all Unicode characters (iOS). (GPL or premium commercial license terms).
  • Adaptation for React Native Android and iOS: andpor / react-native-sqlite-storage (permissive license terms)
  • Original plugin version for iOS (with a non-standard, outdated transaction API): davibe / Phonegap-SQLitePlugin (permissive license terms)

Other SQLite access projects

Alternative storage solutions

Usage

Self-test functions

To verify that both the Javascript and native part of this plugin are installed in your application:

window.sqlitePlugin.echoTest(successCallback, errorCallback);

To verify that this plugin is able to open a database (named ___$$$___litehelpers___$$$___test___$$$___.db), execute the CRUD (create, read, update, and delete) operations, and clean it up properly:

window.sqlitePlugin.selfTest(successCallback, errorCallback);

IMPORTANT: Please wait for the 'deviceready' event (see below for an example).

General

  • Drop-in replacement for HTML5/Web SQL API: the only change should be to replace the static window.openDatabase() factory call with window.sqlitePlugin.openDatabase(), with parameters as documented below. Some known deviations are documented in TBD newer version branches. Reports of any additional deviations would be appreciated.
  • Single-page application design is recommended.
  • In case of a multi-page application the JavaScript used by each page must use sqlitePlugin.openDatabase to open the database access handle object before it can access the data.

NOTE: If a sqlite statement in a transaction fails with an error, the error handler must return false in order to recover the transaction. This is correct according to the HTML5/Web SQL API standard. This is different from the WebKit implementation of Web SQL in Android and iOS which recovers the transaction if a sql error hander returns a non-true value.

Opening a database

There are two options to open a database access object:

  • Recommended: var db = window.sqlitePlugin.openDatabase({name: 'my.db', location: 'default'}, successcb, errorcb);
  • Classical: var db = window.sqlitePlugin.openDatabase("myDatabase.db", "1.0", "Demo", -1);

The location option is used to specify the database subdirectory location (iOS/macOS only):

  • 0: Documents - visible to iTunes and backed up by iCloud (disabled in this version)
  • 1: Library - backed up by iCloud, NOT visible to iTunes (disabled in this version)
  • 2 (default): Library/LocalDatabase - NOT visible to iTunes and NOT backed up by iCloud (same as using "default")

WARNING: The new "default" location value is NOT the same as the old default location (in other version such as cordova-sqlite-storage and cordova-sqlite-ext) and would break an upgrade for an app that was using the old default value (0) on iOS.

WARNING 2: As described above: by default this plugin uses a non-standard Android-sqlite-connector implementation on Android. In case an application access the same database using multiple plugins there is a risk of data corruption ref: litehelpers/Cordova-sqlite-storage#626) as described in http://ericsink.com/entries/multiple_sqlite_problem.html and https://www.sqlite.org/howtocorrupt.html. The workaround is to use the androidDatabaseImplementation: 2 setting as described in the Android sqlite implementation section below.

To specify a different location (affects iOS/macOS only):

(TBD) NOT SUPPORTED by this version: To specify a different location (affects iOS/macOS only):

var db = window.sqlitePlugin.openDatabase({name: 'my.db', iosDatabaseLocation: 'Library'}, successcb, errorcb);

where the iosDatabaseLocation option may be set to one of the following choices:

  • default: Library/LocalDatabase subdirectory - NOT visible to iTunes and NOT backed up by iCloud
  • Library: Library subdirectory - backed up by iCloud, NOT visible to iTunes (disabled in this version)
  • Documents: Documents subdirectory - visible to iTunes and backed up by iCloud (disabled in this version)

WARNING: Again, the new "default" iosDatabaseLocation value is NOT the same as the old default location (in other version such as cordova-sqlite-storage and cordova-sqlite-ext) and would break an upgrade for an app using the old default value (0) on iOS.

ALTERNATIVE (deprecated):

  • var db = window.sqlitePlugin.openDatabase({name: "my.db", location: 2}, successcb, errorcb);

with the location option set to one the following choices (affects iOS only):

  • 0 (default): Documents - visible to iTunes and backed up by iCloud~~ (disabled in this version)
  • 1: Library - backed up by iCloud, NOT visible to iTunes (disabled in this version)
  • 2: Library/LocalDatabase - NOT visible to iTunes and NOT backed up by iCloud (same as using "default")

IMPORTANT: Please wait for the 'deviceready' event, as in the following example:

// Wait for Cordova to load
document.addEventListener('deviceready', onDeviceReady, false);

// Cordova is ready
function onDeviceReady() {
  var db = window.sqlitePlugin.openDatabase({name: 'my.db', location: 'default'});
  // ...
}

The successcb and errorcb callback parameters are optional but can be extremely helpful in case anything goes wrong. For example:

window.sqlitePlugin.openDatabase({name: 'my.db', location: 'default'}, function(db) {
  db.transaction(function(tx) {
    // ...
  }, function(err) {
    console.log('Open database ERROR: ' + JSON.stringify(err));
  });
});

If any sql statements or transactions are attempted on a database object before the openDatabase result is known, they will be queued and will be aborted in case the database cannot be opened.

DATABASE NAME NOTES:

  • Database file names with slash (/) character(s) are not supported and not expected to work.
  • Database file names with ASCII control characters such as tab, vertical tab, carriage return, line feed, form feed, and backspace are not supported and do not work on Windows.
  • Some other ASCII characters not supported and not working on Windows: * < > ? \ " |
  • Database file names with emojis and other 4-octet UTF-8 characters are NOT RECOMMENDED.

OTHER NOTES:

  • The database file name should include the extension, if desired.
  • It is possible to open multiple database access handle objects for the same database.
  • The database handle access object can be closed as described below.

Web SQL replacement tip:

To overwrite window.openDatabase:

window.openDatabase = function(dbname, ignored1, ignored2, ignored3) {
  return window.sqlitePlugin.openDatabase({name: dbname, location: 'default'});
};

Pre-populated database(s)

Put the database file in the www directory and open the database like:

var db = window.sqlitePlugin.openDatabase({name: "my.db", createFromLocation: 1});

IMPORTANT NOTES:

  • Put the pre-populated database file in the www subdirectory.
  • The pre-populated database file name must match exactly the file name given in openDatabase. This plugin does not use an automatic extension.
  • The pre-populated database file is ignored if the database file with the same name already exists in the database file location.

TIP: If you don't see the data from the pre-populated database file, completely remove your app and try it again!

Alternative: You can also use an-rahulpandey / cordova-plugin-dbcopy to install a pre-populated database

Samples and tutorials:

Android sqlite implementation

By default, this plugin uses Android-sqlite-connector, which is lightweight and should be more efficient than the built-in Android database classes. To use the built-in Android database classes instead:

var db = window.sqlitePlugin.openDatabase({name: 'my.db', location: 'default', androidDatabaseImplementation: 2});

NOTE: The internal memory improvements do not apply to the use of the built-in Android database classes.

IMPORTANT:

Workaround for Android db locking issue

litehelpers/Cordova-sqlite-storage#193 reported (as observed by a number of app developers in the past) that when using the androidDatabaseImplementation: 2 setting on certain Android versions and if the app is stopped or aborted without closing the database then:

  • (sometimes) there is an unexpected database lock
  • the data that was inserted is lost.

The cause of this issue remains unknown. Of interest: android / platform_external_sqlite commit d4f30d0d15 which references and includes the sqlite commit at: http://www.sqlite.org/src/info/6c4c2b7dba

This is not an issue when default Android-sqlite-connector database implementation.

There is an optional workaround that simply closes and reopens the database file at the end of every transaction that is committed. The workaround is enabled by opening the database with options as follows:

var db = window.sqlitePlugin.openDatabase({
  name: 'my.db',
  location: 'default',
  androidDatabaseImplementation: 2,
  androidLockWorkaround: 1
});

IMPORTANT NOTE: This workaround is only applied when using db.sqlBatch or db.transaction(), not applied when running executeSql() on the database object.

SQL transactions

The following types of SQL transactions are supported by this plugin version:

  • Single-statement transactions
  • SQL batch transactions
  • Standard asynchronous transactions
  • Multi-part transactions

NOTE: Transaction requests are kept in one queue per database and executed in sequential order, according to the HTML5/Web SQL API.

WARNING: It is possible to request a SQL statement list such as "SELECT 1; SELECT 2" within a single SQL statement string, however the plugin will only execute the first statement and silently ignore the others. This could result in data loss if such a SQL statement list with any INSERT or UPDATE statement(s) are included. For reference: litehelpers/Cordova-sqlite-storage#551

Single-statement transactions

Sample with INSERT:

db.executeSql('INSERT INTO MyTable VALUES (?)', ['test-value'], function (resultSet) {
  console.log('resultSet.insertId: ' + resultSet.insertId);
  console.log('resultSet.rowsAffected: ' + resultSet.rowsAffected);
}, function(error) {
  console.log('SELECT error: ' + error.message);
});

Sample with SELECT:

db.executeSql("SELECT LENGTH('tenletters') AS stringlength", [], function (resultSet) {
  console.log('got stringlength: ' + resultSet.rows.item(0).stringlength);
}, function(error) {
  console.log('SELECT error: ' + error.message);
});

NOTE/minor bug: The object returned by resultSet.rows.item(rowNumber) is not immutable. In addition, multiple calls to resultSet.rows.item(rowNumber) with the same rowNumber on the same resultSet object return the same object. For example, the following code will show Second uppertext result: ANOTHER:

db.executeSql("SELECT UPPER('First') AS uppertext", [], function (resultSet) {
  var obj1 = resultSet.rows.item(0);
  obj1.uppertext = 'ANOTHER';
  console.log('Second uppertext result: ' + resultSet.rows.item(0).uppertext);
  console.log('SELECT error: ' + error.message);
});

SQL batch transactions

Sample:

db.sqlBatch([
  'DROP TABLE IF EXISTS MyTable',
  'CREATE TABLE MyTable (SampleColumn)',
  [ 'INSERT INTO MyTable VALUES (?)', ['test-value'] ],
], function() {
  db.executeSql('SELECT * FROM MyTable', [], function (resultSet) {
    console.log('Sample column value: ' + resultSet.rows.item(0).SampleColumn);
  });
}, function(error) {
  console.log('Populate table error: ' + error.message);
});

In case of an error, all changes in a sql batch are automatically discarded using ROLLBACK.

Standard asynchronous transactions

Standard asynchronous transactions follow the HTML5/Web SQL API which is very well documented and uses BEGIN and COMMIT or ROLLBACK to keep the transactions failure-safe. Here is a simple example:

db.transaction(function(tx) {
  tx.executeSql('DROP TABLE IF EXISTS MyTable');
  tx.executeSql('CREATE TABLE MyTable (SampleColumn)');
  tx.executeSql('INSERT INTO MyTable VALUES (?)', ['test-value'], function(tx, resultSet) {
    console.log('resultSet.insertId: ' + resultSet.insertId);
    console.log('resultSet.rowsAffected: ' + resultSet.rowsAffected);
  }, function(tx, error) {
    console.log('INSERT error: ' + error.message);
  });
}, function(error) {
  console.log('transaction error: ' + error.message);
}, function() {
  console.log('transaction ok');
});

In case of a read-only transaction, it is possible to use readTransaction which will not use BEGIN, COMMIT, or ROLLBACK:

db.readTransaction(function(tx) {
  tx.executeSql("SELECT UPPER('Some US-ASCII text') AS uppertext", [], function(tx, resultSet) {
    console.log("resultSet.rows.item(0).uppertext: " + resultSet.rows.item(0).uppertext);
  }, function(tx, error) {
    console.log('SELECT error: ' + error.message);
  });
}, function(error) {
  console.log('transaction error: ' + error.message);
}, function() {
  console.log('transaction ok');
});

WARNING: It is NOT allowed to execute sql statements on a transaction after it has finished. Here is an example from the Populating Cordova SQLite storage with the JQuery API post at http://www.brodybits.com/cordova/sqlite/api/jquery/2015/10/26/populating-cordova-sqlite-storage-with-the-jquery-api.html:

  // BROKEN SAMPLE:
  var db = window.sqlitePlugin.openDatabase({name: "test.db"});
  db.executeSql("DROP TABLE IF EXISTS tt");
  db.executeSql("CREATE TABLE tt (data)");

  db.transaction(function(tx) {
    $.ajax({
      url: 'https://api.github.com/users/litehelpers/repos',
      dataType: 'json',
      success: function(res) {
        console.log('Got AJAX response: ' + JSON.stringify(res));
        $.each(res, function(i, item) {
          console.log('REPO NAME: ' + item.name);
          tx.executeSql("INSERT INTO tt values (?)", JSON.stringify(item.name));
        });
      }
    });
  }, function(e) {
    console.log('Transaction error: ' + e.message);
  }, function() {
    // Check results:
    db.executeSql('SELECT COUNT(*) FROM tt', [], function(res) {
      console.log('Check SELECT result: ' + JSON.stringify(res.rows.item(0)));
    });
  });

You can find more details and a step-by-step description how to do this right in the Populating Cordova SQLite storage with the JQuery API post at: http://www.brodybits.com/cordova/sqlite/api/jquery/2015/10/26/populating-cordova-sqlite-storage-with-the-jquery-api.html

NOTE/minor bug: Just like the single-statement transaction described above, the object returned by resultSet.rows.item(rowNumber) is not immutable. In addition, multiple calls to resultSet.rows.item(rowNumber) with the same rowNumber on the same resultSet object return the same object. For example, the following code will show Second uppertext result: ANOTHER:

db.readTransaction(function(tx) {
  tx.executeSql("SELECT UPPER('First') AS uppertext", [], function(tx, resultSet) {
    var obj1 = resultSet.rows.item(0);
    obj1.uppertext = 'ANOTHER';
    console.log('Second uppertext result: ' + resultSet.rows.item(0).uppertext);
    console.log('SELECT error: ' + error.message);
  });
});

FUTURE TBD: It should be possible to get a row result object using resultSet.rows[rowNumber], also in case of a single-statement transaction. This is non-standard but is supported by the Chrome desktop browser.

Multi-part transactions

Sample (with success and error callbacks):

var tx = db.beginTransaction();
tx.executeSql("DROP TABLE IF EXISTS mytable");
tx.executeSql("CREATE TABLE mytable (myfield)");

tx.executeSql("INSERT INTO mytable values(?)", ['test value']);
tx.executeSql("SELECT * from mytable", [], function(tx, res) {
  console.log("Got value: " + res.rows.item(0).myfield);
}, function(tx, e) {
  console.log("Ignore unexpected error callback with message: " + e.message);
  return false;
});

tx.end(function() {
  console.log('Optional success callback fired');
}, function(e) {
  console.log("Optional error callback fired with message: " + e.message);
});

Sample with abort:

var tx = db.beginTransaction();
tx.executeSql("INSERT INTO mytable values(?)", ['wrong data']);
tx.abort(function() {
  console.log('Optional callback');
});

IMPORTANT NOTES:

  • In case a tx.executeSql call results in an error and it does not have an error callback or the error callback does NOT return false, the transaction will be aborted immediately with a ROLLBACK upon the tx.end call.
  • BUG: If a tx.executeSql call results in an error for which there is no error callback, the error callback does NOT return false, or the error callback throws an exception, the transaction is silently aborted and no tx.end callbacks will be fired.
  • When a multi-part transaction is started by the db.beginTransaction call, all other transactions are blocked until the multi-part transaction is either completed successfully or aborted (with a ROLLBACK).

Background processing

The threading model depends on which platform version is used:

  • For Android, one background thread per db;
  • for iOS/macOS, background processing using a very limited thread pool (only one thread working at a time);
  • for Windows, no background processing.

Sample with PRAGMA feature

Creates a table, adds a single entry, then queries the count to check if the item was inserted as expected. Note that a new transaction is created in the middle of the first callback.

// Wait for Cordova to load
document.addEventListener('deviceready', onDeviceReady, false);

// Cordova is ready
function onDeviceReady() {
  var db = window.sqlitePlugin.openDatabase({name: 'my.db', location: 'default'});

  db.transaction(function(tx) {
    tx.executeSql('DROP TABLE IF EXISTS test_table');
    tx.executeSql('CREATE TABLE IF NOT EXISTS test_table (id integer primary key, data text, data_num integer)');

    // demonstrate PRAGMA:
    db.executeSql("pragma table_info (test_table);", [], function(res) {
      console.log("PRAGMA res: " + JSON.stringify(res));
    });

    tx.executeSql("INSERT INTO test_table (data, data_num) VALUES (?,?)", ["test", 100], function(tx, res) {
      console.log("insertId: " + res.insertId + " -- probably 1");
      console.log("rowsAffected: " + res.rowsAffected + " -- should be 1");

      db.transaction(function(tx) {
        tx.executeSql("select count(id) as cnt from test_table;", [], function(tx, res) {
          console.log("res.rows.length: " + res.rows.length + " -- should be 1");
          console.log("res.rows.item(0).cnt: " + res.rows.item(0).cnt + " -- should be 1");
        });
      });

    }, function(e) {
      console.log("ERROR: " + e.message);
    });
  });
}

NOTE: PRAGMA statements must be executed in executeSql() on the database object (i.e. db.executeSql()) and NOT within a transaction.

Sample with transaction-level nesting

In this case, the same transaction in the first executeSql() callback is being reused to run executeSql() again.

// Wait for Cordova to load
document.addEventListener('deviceready', onDeviceReady, false);

// Cordova is ready
function onDeviceReady() {
  var db = window.sqlitePlugin.openDatabase({name: 'my.db', location: 'default'});

  db.transaction(function(tx) {
    tx.executeSql('DROP TABLE IF EXISTS test_table');
    tx.executeSql('CREATE TABLE IF NOT EXISTS test_table (id integer primary key, data text, data_num integer)');

    tx.executeSql("INSERT INTO test_table (data, data_num) VALUES (?,?)", ["test", 100], function(tx, res) {
      console.log("insertId: " + res.insertId + " -- probably 1");
      console.log("rowsAffected: " + res.rowsAffected + " -- should be 1");

      tx.executeSql("select count(id) as cnt from test_table;", [], function(tx, res) {
        console.log("res.rows.length: " + res.rows.length + " -- should be 1");
        console.log("res.rows.item(0).cnt: " + res.rows.item(0).cnt + " -- should be 1");
      });

    }, function(tx, e) {
      console.log("ERROR: " + e.message);
    });
  });
}

This case will also works with Safari (WebKit), assuming you replace window.sqlitePlugin.openDatabase with window.openDatabase.

Attach to another database

To attach to another database in the default location:

db.attach('alias_name', 'dbfilename', optionalSuccessCallback, optionalErrorCallback);

NOTE: For Android the database must be opened with the androidDatabaseImplementation: 2 option (FUTURE TBD).

Detach

db.detach('alias_name', optionalSuccessCallback, optionalErrorCallback);

To list attached databases

db.executeSql('PRAGMA database_list', [], function(res) {
  console.log('alias: ' + res.rows.item(1).name);
  console.log('file: ' + res.rows.item(1).file);
});

For more information: http://www.sqlite.org/pragma.html#pragma_database_list

Close a database object

This will invalidate all handle access handle objects for the database that is closed:

db.close(successcb, errorcb);

It is OK to close the database within a transaction callback but NOT within a statement callback. The following example is OK:

db.transaction(function(tx) {
  tx.executeSql("SELECT LENGTH('tenletters') AS stringlength", [], function(tx, res) {
    console.log('got stringlength: ' + res.rows.item(0).stringlength);
  });
}, function(error) {
  // OK to close here:
  console.log('transaction error: ' + error.message);
  db.close();
}, function() {
  // OK to close here:
  console.log('transaction ok');
  db.close(function() {
    console.log('database is closed ok');
  });
});

The following example is NOT OK:

// BROKEN:
db.transaction(function(tx) {
  tx.executeSql("SELECT LENGTH('tenletters') AS stringlength", [], function(tx, res) {
    console.log('got stringlength: ' + res.rows.item(0).stringlength);
    // BROKEN - this will trigger the error callback:
    db.close(function() {
      console.log('database is closed ok');
    }, function(error) {
      console.log('ERROR closing database');
    });
  });
});

BUG: It is currently NOT possible to close a database in a db.executeSql callback. For example:

// BROKEN DUE TO BUG:
db.executeSql("SELECT LENGTH('tenletters') AS stringlength", [], function (res) {
  var stringlength = res.rows.item(0).stringlength;
  console.log('got stringlength: ' + res.rows.item(0).stringlength);

  // BROKEN - this will trigger the error callback DUE TO BUG:
  db.close(function() {
    console.log('database is closed ok');
  }, function(error) {
    console.log('ERROR closing database');
  });
});

SECOND BUG: When a database connection is closed, any queued transactions are left hanging. TODO: All pending transactions should be errored whenever a database connection is closed.

NOTE: As described above, if multiple database access handle objects are opened for the same database and one database handle access object is closed, the database is no longer available for the other database handle objects. Possible workarounds:

  • It is still possible to open one or more new database handle objects on a database that has been closed.
  • It should be OK not to explicitly close a database handle since database transactions are ACID compliant and the app's memory resources are cleaned up by the system upon termination.

FUTURE TBD: dispose method on the database access handle object, such that a database is closed once all access handle objects are disposed.

Delete a database

window.sqlitePlugin.deleteDatabase({name: 'my.db', location: 'default'}, successcb, errorcb);

with location or iosDatabaseLocation parameter required as described above for openDatabase (affects iOS/macOS only)

Alternative supported by this version:

window.sqlitePlugin.deleteDatabase(name: 'my.db', successcb, errorcb);

BUG: When a database is deleted, any queued transactions for that database are left hanging. TODO: All pending transactions should be errored when a database is deleted.

Database schema versions

The transactional nature of the API makes it relatively straightforward to manage a database schema that may be upgraded over time (adding new columns or new tables, for example). Here is the recommended procedure to follow upon app startup:

  • Check your database schema version number (you can use db.executeSql since it should be a very simple query)
  • If your database needs to be upgraded, do the following within a single transaction to be failure-safe:

IMPORTANT: Since we cannot be certain when the users will actually update their apps, old schema versions will have to be supported for a very long time.

Use with Ionic/ngCordova/Angular

Ionic 2

Tutorials with Ionic 2:

Sample for Ionic 2 wanted ref: litehelpers/Cordova-sqlite-storage#585

Ionic 1

Tutorial with Ionic 1: https://blog.nraboy.com/2014/11/use-sqlite-instead-local-storage-ionic-framework/

A sample for Ionic 1 is provided at: litehelpers / Ionic-sqlite-database-example

Documentation at: http://ngcordova.com/docs/plugins/sqlite/

Other resource (apparently for Ionic 1): https://www.packtpub.com/books/content/how-use-sqlite-ionic-store-data

NOTE: Some Ionic and other Angular pitfalls are described above.

Installing

Easy installation with Cordova CLI tool

npm install -g cordova # (in case you don't have cordova)
cordova create MyProjectFolder com.my.project MyProject && cd MyProjectFolder # if you are just starting
cordova plugin add https://github.com/litehelpers/Cordova-sqlite-evplus-legacy-attach-detach-free

CLI NOTES:

  • You may have to update the platform and plugin version(s) before you can build: cordova prepare (or for a specific platform such as iOS: cordova prepare ios)
  • If you cannot build for a platform after cordova prepare, you may have to remove the platform and add it again, such as:
cordova platform rm ios
cordova platform add ios

or more drastically:

rm -rf platforms
cordova platform add ios

Plugin installation sources

Installation test

Easy installation test

Use window.sqlitePlugin.echoTest and/or window.sqlitePlugin.selfTest as described above (please wait for the deviceready event).

Quick installation test

Assuming your app has a recent template as used by the Cordova create script, add the following code to the onDeviceReady function, after app.receivedEvent('deviceready');:

  window.sqlitePlugin.openDatabase({ name: 'hello-world.db', location: 'default' }, function (db) {
    db.executeSql("select length('tenletters') as stringlength", [], function (res) {
      var stringlength = res.rows.item(0).stringlength;
      console.log('got stringlength: ' + stringlength);
      document.getElementById('deviceready').querySelector('.received').innerHTML = 'stringlength: ' + stringlength;
   });
  });

Support

Policy

Free support is provided on a best-effort basis and is only available in public forums. Please follow the steps below to be sure you have done your best before requesting help.

Commercial support is available by contacting: sales@litehelpers.net

Before seeking help

First steps:

and check the following:

  • You are using the latest version of the Plugin (Javascript and platform-specific part) from this repository.
  • The plugin is installed correctly.
  • You have included the correct version of cordova.js.
  • You have registered the plugin properly in config.xml.

If you still cannot get something to work:

If you continue to see the issue in the fresh, clean Cordova project:

  • Make the simplest test program you can to demonstrate the issue, including the following characteristics:
    • it completely self-contained, i.e. it is using no extra libraries beyond cordova & SQLitePlugin.js;
    • if the issue is with adding data to a table, that the test program includes the statements you used to open the database and create the table;
    • if the issue is with retrieving data from a table, that the test program includes the statements you used to open the database, create the table, and enter the data you are trying to retrieve.

Then you can raise the new issue.

What will be supported for free

Please make a small, self-contained test program that can demonstrate your problem and post it. Please do not use any other plugins or frameworks than are absolutely necessary to demonstrate your problem.

In case of a problem with a pre-populated database, please post your entire project.

Support for issues with Angular/"ngCordova"/Ionic

Free support for issues with Angular/"ngCordova"/Ionic will only be provided if you can demonstrate that you can do the same thing without such a framework.

  • Make a fresh, clean ngCordova or Ionic project with a test program that demonstrates the issue and post it. Please do not use any other plugins or frameworks unless absolutely necessary to demonstrate your issue.
  • Make another project without any form of Angular including ngCordova or Ionic, with the same test program to show that it will work outside Angular/"ngCordova"/Ionic.

What information is needed for help

Please include the following:

  • Which platform(s) (Android/iOS/macOS/Windows)
  • Clear description of the issue
  • A small, complete, self-contained program that demonstrates the problem, preferably as a Github project. ZIP/TGZ/BZ2 archive available from a public link is OK. No RAR or other such formats please!
  • A Cordova project is highly preferred. Intel, MS IDE, or similar project formats should be avoided.

Please do NOT use any of these formats

  • screen casts or videos
  • RAR or similar archive formats
  • Intel, MS IDE, or similar project formats unless absolutely necessary

Where to ask for help

Once you have followed the directions above, you may request free support in the following location(s):

Please include the information described above otherwise.

Professional support

Professional support is available, please contact: sales@litehelpers.net

Unit tests

Unit testing is done in spec.

running tests from shell

To run the tests from *nix shell, simply do either:

./bin/test.sh ios

or for Android:

./bin/test.sh android

To run from a windows powershell (here is a sample for android target):

.\bin\test.ps1 android

Adapters

GENERAL: The adapters described here are community maintained.

Lawnchair Adapter

PouchDB

Adapters wanted

  • IndexedDBShim adapter (possibly based on IndexedDBShim)

Source tree

  • SQLitePlugin.coffee.md: platform-independent (Literate CoffeeScript, can be compiled with a recent CoffeeScript (1.x) compiler)
  • www: platform-independent Javascript as generated from SQLitePlugin.coffee.md using coffeescript@1 (and committed!)
  • src: platform-specific source code
  • node_modules: placeholder for external dependencies
  • scripts: installation hook script to fetch the external dependencies via npm
  • spec: test suite using Jasmine (2.2.0)
  • tests: very simple Jasmine test suite that is run on Circle CI (Android platform) and Travis CI (iOS platform) (used as a placeholder)

Contributing

Community

  • Testimonials of apps that are using this plugin would be especially helpful.
  • Reporting issues can help improve the quality of this plugin.

NOTE: As stated above, patches will NOT be accepted on this project due to potential licensing issues. Issues with reproduction scenarios will help maintain and improve the quality of this plugin for future users. (It is also helpful if you have a pointer to the code that is causing the issue.)

Contact

sales@litehelpers.net

About

Cordova sqlite storage plugin, free enterprise version (GPL) for Android and iOS with memory improvement, support for attach/detach, and other extra features

Resources

Readme

License

View license
Activity

Stars

1 star

Watchers

3 watching

Forks

3 forks
Report repository

Releases

11 tags

Packages

No packages published

Contributors 40

+ 26 contributors

Languages