### Install with pnpm

Source: https://github.com/capacitor-community/sqlite/blob/master/README.md

Install the plugin and its dependencies with pnpm, then sync with Capacitor.

```bash
pnpm install --save @capacitor-community/sqlite
pnpm install --save jeep-sqlite
pnpm install --save sql.js
npx cap sync
```

--------------------------------

### Install with yarn

Source: https://github.com/capacitor-community/sqlite/blob/master/README.md

Install the plugin using yarn and sync with Capacitor.

```bash
yarn add @capacitor-community/sqlite
npx cap sync
```

--------------------------------

### Install with npm

Source: https://github.com/capacitor-community/sqlite/blob/master/README.md

Install the plugin using npm and sync with Capacitor.

```bash
npm install --save @capacitor-community/sqlite
npx cap sync
```

--------------------------------

### Install Project Dependencies

Source: https://github.com/capacitor-community/sqlite/blob/master/CONTRIBUTING.md

Run this command after cloning the repository to install all necessary project dependencies.

```shell
npm install
```

--------------------------------

### Install @capacitor-community/sqlite

Source: https://github.com/capacitor-community/sqlite/blob/master/docs/Biometric-Authentication.md

Install the latest version of the @capacitor-community/sqlite package using npm.

```bash
npm i --save @capacitor-community/sqlite@latest
```

--------------------------------

### Capacitor Configuration Example

Source: https://github.com/capacitor-community/sqlite/blob/master/README.md

Example configuration for the CapacitorSQLite plugin in capacitor.config.ts, including settings for iOS, Android, and Electron encryption and biometrics.

```typescript
import { CapacitorConfig } from '@capacitor/cli';

const config: CapacitorConfig = {
  appId: 'com.jeep.app.ionic7.angular.sqlite',
  appName: 'ionic7-angular-sqlite-starter',
  webDir: 'www',
  server: {
    androidScheme: 'https'
  },
  plugins: {
    CapacitorSQLite: {
      iosDatabaseLocation: 'Library/CapacitorDatabase',
      iosIsEncryption: true,
      iosKeychainPrefix: 'angular-sqlite-app-starter',
      iosBiometric: {
        biometricAuth: false,
        biometricTitle : "Biometric login for capacitor sqlite"
      },
      androidIsEncryption: true,
      androidBiometric: {
        biometricAuth : false,
        biometricTitle : "Biometric login for capacitor sqlite",
        biometricSubTitle : "Log in using your biometric"
      },
      electronIsEncryption: true,
      electronWindowsLocation: "C:\\ProgramData\\CapacitorDatabases",
      electronMacLocation: "/Volumes/Development_Lacie/Development/Databases",
      electronLinuxLocation: "Databases"
    }
  }
};
export default config;

```

--------------------------------

### Install @capacitor-community/sqlite and react-sqlite-hook

Source: https://github.com/capacitor-community/sqlite/blob/master/docs/Ionic-React-Usage.md

Install the necessary packages for native applications. Use `jeep-sqlite` for web browser compatibility.

```bash
npm i --save-dev @capacitor-community/sqlite@latest
npm i --save-dev react-sqlite-hook@latest
```

```bash
npm i --save-dev jeep-sqlite@latest
```

--------------------------------

### Partial Mode Import Example

Source: https://github.com/capacitor-community/sqlite/blob/master/docs/ImportExportJson.md

This example demonstrates a partial import, allowing for updates to existing tables, addition of new tables, and modification of indexes. It's useful for incremental data loading.

```javascript
const partialImport1: any = {
    database : "db-from-json",
    version: 1,
    encrypted : false,
    mode : "partial",
    tables :[
        {
          name: "users",
          values: [
              [5,"Addington.com","Addington",22,0,1601972413],
              [6,"Bannister.com","Bannister",59,0,1601983245],
              [2,"Jones@example.com","Jones",45,0,1601995473],
              [1, 'Whiteley.com', 'Whiteley', 30, 1, 1601995520],
          ]
        },
        {
          name: "messages",
          indexes: [
              {name: "index_messages_on_title", value: "title"}
          ],
          values: [
              [4,2,"test post 4","content test post 4",0,1601983742],
              [5,6,"test post 5","content test post 5",0,1601992872]
              [1,1,'test post 1', 'content test post 1',1,1601995520],
              [3,1,'test post 3', 'content test post 3',1,1601995520],
         ]
        },
        {
          name: 'fruits',
          schema: [
            { column: 'id', value: 'INTEGER PRIMARY KEY NOT NULL' },
            { column: 'name', value: 'TEXT UNIQUE NOT NULL' },
            { column: 'weight', value: 'REAL' },
            {column:"sql_deleted", value:"BOOLEAN DEFAULT 0 CHECK (sql_deleted IN (0, 1))"},
            {column:"last_modified", value:"INTEGER DEFAULT (strftime('%s', 'now'))"}
          ],
          indexes: [
            { name: 'index_fruits_on_name', value: 'name' },
            { name: "index_fruits_on_last_modified",value: "last_modified DESC"},
          ],
          values: [
            [1, 'orange', 200.3,0,1601995573],
            [2, 'apple', 450.0,0,1601995573],
            [2, 'banana', 120.5,0,1601995573],
          ],
        },
        {
          name: 'company',
          schema: [
            { column: 'id', value: 'INTEGER NOT NULL' },
            { column: 'name', value: 'TEXT NOT NULL' },
            { column: 'age', value: 'INTEGER NOT NULL' },
            { column: 'address', value: 'TEXT' },
            { column: 'salary', value: 'REAL'},
            {column:"sql_deleted", value:"BOOLEAN DEFAULT 0 CHECK (sql_deleted IN (0, 1))"},
            {column:"last_modified", value:"INTEGER DEFAULT (strftime('%s', 'now'))"},
            { constraint: 'PK_id_name', value: 'PRIMARY KEY (id,name)'},
          ],
        },
    ],
};
```

--------------------------------

### App.vue Setup with SQLite Hook

Source: https://github.com/capacitor-community/sqlite/blob/master/docs/Ionic-Vue-Usage.md

This snippet shows the App.vue file setup, demonstrating how to integrate the useSQLite hook and access global properties for managing modal states and messages.

```vue
<template>
  <ion-app>
    <ion-router-outlet />
  </ion-app>
</template>

<script lang="ts">
import { IonApp, IonRouterOutlet } from '@ionic/vue';
import { defineComponent, getCurrentInstance} from 'vue';
import { useSQLite} from 'vue-sqlite-hook';

export default defineComponent({
  name: 'App',
  components: {
    IonApp,
    IonRouterOutlet,
  },
  setup() {
    const app = getCurrentInstance();
    const isModalOpen = app?.appContext.config.globalProperties.$isModalOpen;
    const contentMessage = app?.appContext.config.globalProperties.$messageContent;
    const jsonListeners = app?.appContext.config.globalProperties.$isJsonListeners;
      const onProgressImport = async (progress: string) => {
        if(jsonListeners.jsonListeners.value) {
          if(!isModalOpen.isModal.value) isModalOpen.setIsModal(true);
          contentMessage.setMessage(
              contentMessage.message.value.concat(`${progress}\n`));
        }
      }
      const onProgressExport = async (progress: string) => {
        if(jsonListeners.jsonListeners.value) {
          if(!isModalOpen.isModal.value) isModalOpen.setIsModal(true);
          contentMessage.setMessage(
            contentMessage.message.value.concat(`${progress}\n`));
        }
      }
      if( app != null) { 
        // !!!!! if you do not want to use the progress events !!!!!
        // since vue-sqlite-hook 2.1.1
        // app.appContext.config.globalProperties.$sqlite = useSQLite()
        // before

```

--------------------------------

### Install Capacitor Community SQLite v2.4.x (Initial)

Source: https://github.com/capacitor-community/sqlite/blob/master/docs/info_releases.md

Install the older, unmaintained 2.4.x version of the plugin. Use this version only if you have specific reasons to avoid the refactored version.

```bash
npm i --save @capacitor-community/sqlite@initial
```

--------------------------------

### Install Buffer Dependency

Source: https://github.com/capacitor-community/sqlite/blob/master/docs/SQLiteBlob.md

Before using blob functionalities, ensure the 'buffer' package is installed as a dependency.

```bash
npm i --save buffer
```

--------------------------------

### Install CRACO and CRACO-SWC for React Projects

Source: https://github.com/capacitor-community/sqlite/blob/master/docs/TypeORM-Usage.md

Install the necessary packages as development dependencies for customizing Create React App's build process.

```bash
npm i -D @craco/craco craco-swc
```

--------------------------------

### Install reflect-metadata Package

Source: https://github.com/capacitor-community/sqlite/blob/master/docs/TypeORM-Usage.md

Install the reflect-metadata package using npm. This is a required dependency for TypeORM.

```bash
npm i reflect-metadata
```

--------------------------------

### Install Capacitor Community SQLite v2.9.x (Refactored)

Source: https://github.com/capacitor-community/sqlite/blob/master/docs/info_releases.md

Install the refactored version of the plugin, which includes multiple database connections and improved performance. This version is recommended for new projects.

```bash
npm i --save @capacitor-community/sqlite
```

--------------------------------

### Install Electron Dependencies

Source: https://github.com/capacitor-community/sqlite/blob/master/README.md

Install necessary npm packages for Electron development, including better-sqlite3 and electron-json-storage. Ensure node-fetch is version 2.6.7 or lower.

```bash
cd electron
npm install --save better-sqlite3-multiple-ciphers
npm install --save electron-json-storage
npm install --save jszip
npm install --save node-fetch@2.6.7
npm install --save crypto
npm install --save crypto-js
npm install --save-dev @types/better-sqlite3
npm install --save-dev @types/electron-json-storage
npm install --save-dev @types/crypto-js
```

--------------------------------

### Install @capacitor-community/sqlite and vue-sqlite-hook

Source: https://github.com/capacitor-community/sqlite/blob/master/docs/Ionic-Vue-Usage.md

Install the necessary packages for using the SQLite plugin and its Vue hook in your project.

```bash
npm i --save-dev @capacitor-community/sqlite@latest
npm i --save-dev vue-sqlite-hook@latest
```

--------------------------------

### Capacitor Build Process

Source: https://github.com/capacitor-community/sqlite/blob/master/docs/Web-Usage.md

Follow these commands to build and run your Capacitor application. This sequence ensures all dependencies are synced, the web build is copied, and the development server is started.

```bash
npx cap sync
npm run build
npx cap copy web
npm run start
```

--------------------------------

### Install SwiftLint on macOS

Source: https://github.com/capacitor-community/sqlite/blob/master/CONTRIBUTING.md

If you are developing on macOS, install SwiftLint using Homebrew to enforce Swift code style.

```shell
brew install swiftlint
```

--------------------------------

### Create and Open Database Connection

Source: https://github.com/capacitor-community/sqlite/blob/master/docs/Web-Usage.md

Checks for existing connections, creates a new one if necessary, and opens the database connection. This example demonstrates creating a database with a standard SQLite statement.

```javascript
    // example: database creation with standard SQLite statements 
    const ret = await sqlite.checkConnectionsConsistency();
    const isConn = (await sqlite.isConnection("db_tab3")).result;
    let db: SQLiteDBConnection
    if (ret.result && isConn) {
      db = await sqlite.retrieveConnection("db_tab3");
    } else {
      db = await sqlite.createConnection("db_tab3", false, "no-encryption", 1);
    }
    await db.open();
    const query = `
    CREATE TABLE IF NOT EXISTS test (
      id INTEGER PRIMARY KEY NOT NULL,
      name TEXT NOT NULL
    );
    `
    const res = await db.execute(query);
    if(res.changes && res.changes.changes && res.changes.changes < 0) {
      throw new Error(`Error: execute failed`);
    }
    await sqlite.closeConnection("db_tab3");

```

--------------------------------

### Install Latest Capacitor Community SQLite (Capacitor 4)

Source: https://github.com/capacitor-community/sqlite/blob/master/docs/info_releases.md

Install the latest stable version of the Capacitor Community SQLite plugin for Capacitor 4. This is the recommended version for production use.

```bash
npm install @capacitor-community/sqlite@latest
```

--------------------------------

### Install Capacitor SQLite and Jeep SQLite

Source: https://github.com/capacitor-community/sqlite/blob/master/docs/Web-Usage.md

Install the latest versions of @capacitor-community/sqlite and jeep-sqlite using npm. These packages are essential for integrating SQLite functionality into your web application.

```bash
npm i --save @capacitor-community/sqlite@latest
npm i --save jeep-sqlite@latest
```

--------------------------------

### Install Next Capacitor Community SQLite (Capacitor 4)

Source: https://github.com/capacitor-community/sqlite/blob/master/docs/info_releases.md

Install the next development version of the Capacitor Community SQLite plugin for Capacitor 4. Use this version for testing new features or reporting issues.

```bash
npm install @capacitor-community/sqlite@next
```

--------------------------------

### Capacitor SQLite Parameters Setup

Source: https://github.com/capacitor-community/sqlite/blob/master/docs/TypeORM-Usage-From-5.6.0.md

Initializes and exports SQLite connection and plugin parameters for use with Capacitor. This includes the SQLiteConnection instance, the plugin itself, and the current platform.

```typescript
import { Capacitor } from '@capacitor/core';
import { CapacitorSQLite, SQLiteConnection } from '@capacitor-community/sqlite';
const sqliteConnection: SQLiteConnection = new SQLiteConnection(CapacitorSQLite);
const sqlitePlugin = CapacitorSQLite;
const platform: string = Capacitor.getPlatform();
const sqliteParams = {
    connection: sqliteConnection,
    plugin: sqlitePlugin,
    platform: platform
}
export default sqliteParams;
```

--------------------------------

### Get Database from HTTP Request

Source: https://github.com/capacitor-community/sqlite/blob/master/docs/API.md

Fetches a database or zipped databases from a URL. Requires `capSQLiteHTTPOptions`.

```typescript
getFromHTTPRequest(options: capSQLiteHTTPOptions) => Promise<void>
```

--------------------------------

### App Component Setup with React SQLite Hook

Source: https://github.com/capacitor-community/sqlite/blob/master/docs/Web-Usage.md

This React component setup demonstrates the integration of the `react-sqlite-hook` for managing SQLite connections within an Ionic/React application. It includes state management for existing connections and JSON listeners, and defines progress handlers for import and export operations.

```typescript
import React, { useState, useRef }  from 'react';
import { Redirect, Route } from 'react-router-dom';
import {
  IonApp,
  IonIcon,
  IonLabel,
  IonRouterOutlet,
  IonTabBar,
  IonTabButton,
  IonTabs
} from '@ionic/react';
import { IonReactRouter } from '@ionic/react-router';
import { ellipse, square, triangle } from 'ionicons/icons';
import Tab1 from './pages/Tab1';
import Tab2 from './pages/Tab2';
import Tab3 from './pages/Tab3';
import { useSQLite } from 'react-sqlite-hook/dist';
import ModalJsonMessages from './components/ModalJsonMessages';

/* Core CSS required for Ionic components to work properly */
import '@ionic/react/css/core.css';

/* Basic CSS for apps built with Ionic */
import '@ionic/react/css/normalize.css';
import '@ionic/react/css/structure.css';
import '@ionic/react/css/typography.css';

/* Optional CSS utils that can be commented out */
import '@ionic/react/css/padding.css';
import '@ionic/react/css/float-elements.css';
import '@ionic/react/css/text-alignment.css';
import '@ionic/react/css/text-transformation.css';
import '@ionic/react/css/flex-utils.css';
import '@ionic/react/css/display.css';

/* Theme variables */
import './theme/variables.css';


// Singleton SQLite Hook
export let sqlite: any;
// Existing Connections Store
export let existingConn: any;
// Is Json Listeners used
export let isJsonListeners: any;

const App: React.FC = () => {
  const [existConn, setExistConn] = useState(false);
  existingConn = {existConn: existConn, setExistConn: setExistConn};
  const [jsonListeners, setJsonListeners] = useState(false);
  isJsonListeners = {jsonListeners: jsonListeners, setJsonListeners: setJsonListeners};
  const [isModal,setIsModal] = useState(false);
  const message = useRef("");
  const onProgressImport = async (progress: string) => {
    if(isJsonListeners.jsonListeners) {
      if(!isModal) setIsModal(true);
      message.current = message.current.concat(`${progress}\n`);
    }
  }
  const onProgressExport = async (progress: string) => {
    if(isJsonListeners.jsonListeners) {
      if(!isModal) setIsModal(true);
      message.current = message.current.concat(`${progress}\n`);
    }
  }

```

--------------------------------

### Get Database List

Source: https://github.com/capacitor-community/sqlite/blob/master/docs/Web-Usage.md

Retrieves a list of all available databases. An active connection is necessary.

```typescript
async getDatabaseList() : Promise<capSQLiteValues> {
        if(this.sqlite != null) {
            try {
                return Promise.resolve(await this.sqlite.getDatabaseList());
            } catch (err) {
                return Promise.reject(new Error(err));
            }
        } else {
            return Promise.reject(new Error(`no connection open`));
        }
    }
```

--------------------------------

### Get Migratable Database List

Source: https://github.com/capacitor-community/sqlite/blob/master/docs/Web-Usage.md

Fetches a list of databases that can be migrated. Requires a folder path and an open connection. Not implemented for all platforms.

```typescript
async getMigratableDbList(folderPath?: string): Promise<capSQLiteValues>{
        if(!this.native) {
            return Promise.reject(new Error(`Not implemented for ${this.platform} platform`));
        }
        if(this.sqlite != null) {
            try {
                if(!folderPath || folderPath.length === 0) {
                    return Promise.reject(new Error(`You must provide a folder path`));
                }
                return Promise.resolve(await this.sqlite.getMigratableDbList(folderPath));
            } catch (err) {
                return Promise.reject(new Error(err));
            }
        } else {
            return Promise.reject(new Error(`no connection open`));
        }
    }
```

--------------------------------

### Initialize Jeep-SQLite and React App

Source: https://github.com/capacitor-community/sqlite/blob/master/docs/Ionic-React-Usage.md

This snippet shows the initialization of jeep-sqlite for the Web platform and the subsequent setup of the React application. It includes checking and creating SQLite connections, executing a table creation query, and rendering the main App component.

```typescript
import React from 'react';
import { createRoot } from 'react-dom/client';
import App from './App';
import * as serviceWorkerRegistration from './serviceWorkerRegistration';
import reportWebVitals from './reportWebVitals';
import { defineCustomElements as jeepSqlite, applyPolyfills, JSX as LocalJSX  } from "jeep-sqlite/loader";
import { HTMLAttributes } from 'react';
import { Capacitor } from '@capacitor/core';
import { CapacitorSQLite, SQLiteConnection, SQLiteDBConnection } from '@capacitor-community/sqlite';

type StencilToReact<T> = {
  [P in keyof T]?: T[P] & Omit<HTMLAttributes<Element>, 'className'> & {
    class?: string;
  };
} ;

declare global {
  export namespace JSX {
    interface IntrinsicElements extends StencilToReact<LocalJSX.IntrinsicElements> {
    }
  }
}

applyPolyfills().then(() => {
  jeepSqlite(window);
});
window.addEventListener('DOMContentLoaded', async () => {
  console.log('$$$ in index $$$');
  const platform = Capacitor.getPlatform();
  const sqlite: SQLiteConnection = new SQLiteConnection(CapacitorSQLite)
  try {
    if(platform === "web") {
      const jeepEl = document.createElement("jeep-sqlite");
      document.body.appendChild(jeepEl);
      await customElements.whenDefined('jeep-sqlite');
      await sqlite.initWebStore();
    }
    const ret = await sqlite.checkConnectionsConsistency();
    const isConn = (await sqlite.isConnection("db_issue9", false)).result;
    var db: SQLiteDBConnection
    if (ret.result && isConn) {
      db = await sqlite.retrieveConnection("db_issue9", false);
    } else {
      db = await sqlite.createConnection("db_issue9", false, "no-encryption", 1, false);
    }

    await db.open();
    let query = `
    CREATE TABLE IF NOT EXISTS test (
      id INTEGER PRIMARY KEY NOT NULL,
      name TEXT NOT NULL
    );
    `

    const res: any = await db.execute(query);
    console.log(`res: ${JSON.stringify(res)}`);
    await db.close();
    await sqlite.closeConnection("db_issue9", false);
    const container = document.getElementById('root');
    const root = createRoot(container!);
    root.render(
      <React.StrictMode>
        <App />
      </React.StrictMode>
    );
    
    // If you want your app to work offline and load faster, you can change
    // unregister() to register() below. Note this comes with some pitfalls.
    // Learn more about service workers: https://cra.link/PWA
    serviceWorkerRegistration.unregister();
    
    // If you want to start measuring performance in your app, pass a function
    // to log results (for example: reportWebVitals(console.log))
    // or send to an analytics endpoint. Learn more: https://bit.ly/CRA-vitals
    reportWebVitals();
  } catch (err) {
    console.log(`Error: ${err}`);
    throw new Error(`Error: ${err}`)
  }
});

```

--------------------------------

### Get List of Databases

Source: https://github.com/capacitor-community/sqlite/blob/master/docs/Ionic-Angular-Usage.md

Retrieves a list of all available database files. This operation requires an open connection.

```typescript
/**
     * Get the list of databases
     */
    async getDatabaseList(): Promise<capSQLiteValues> {
        this.ensureConnectionIsOpen();
        return this.sqlite.getDatabaseList();
    }
```

--------------------------------

### Get the list of databases

Source: https://github.com/capacitor-community/sqlite/blob/master/docs/Ionic-Angular-Usage.md

Retrieves a list of all available database files. Ensures a connection is open before retrieving the list.

```APIDOC
## getDatabaseList

### Description
Retrieves a list of all available database files.

### Method
POST

### Endpoint
/getDatabaseList

### Response
#### Success Response (200)
- **values** (capSQLiteValues) - An object containing the list of database names.

#### Response Example
```json
{
  "values": {
    "values": ["db1.sqlite", "db2.sqlite"]
  }
}
```
```

--------------------------------

### Get List of Available Databases

Source: https://github.com/capacitor-community/sqlite/blob/master/docs/APIConnection.md

Retrieve a list of all available database files in the application's database directory. Returns a capSQLiteValues object.

```typescript
getDatabaseList() => Promise<capSQLiteValues>
```

--------------------------------

### Get Migratable Databases List

Source: https://github.com/capacitor-community/sqlite/blob/master/docs/Ionic-Angular-Usage.md

Retrieves a list of databases that can be migrated. Requires the platform to be native and a connection to be open. A folder path must be provided.

```typescript
/**
     * Get Migratable databases List
     */
    async getMigratableDbList(folderPath?: string): Promise<capSQLiteValues> {
        this.ensureIsNativePlatform();
        this.ensureConnectionIsOpen();

        if ( !folderPath || folderPath.length === 0 ) {
            throw new Error(`You must provide a folder path`);
        }
        return this.sqlite.getMigratableDbList(folderPath);
    }
```

--------------------------------

### Get from Local Disk to Store

Source: https://github.com/capacitor-community/sqlite/blob/master/docs/API.md

Retrieves a database from local disk and saves it to the store. Requires a capSQLiteLocalDiskOptions object. This method is available since version 4.6.3.

```typescript
getFromLocalDiskToStore(options: capSQLiteLocalDiskOptions) => Promise<void>
```

--------------------------------

### Get Database From HTTP Request

Source: https://github.com/capacitor-community/sqlite/blob/master/docs/APIConnection.md

Fetch and copy a database from a specified URL to the application's database directory. Supports overwriting existing files.

```typescript
getFromHTTPRequest(url?: string | undefined, overwrite?: boolean | undefined) => Promise<void>
```

--------------------------------

### Get Database from Local Disk to Store

Source: https://github.com/capacitor-community/sqlite/blob/master/docs/APIConnection.md

Retrieves a database from the local disk and saves it to the web store. The overwrite parameter determines if existing store data should be replaced.

```typescript
getFromLocalDiskToStore(overwrite: boolean) => Promise<void>
```

--------------------------------

### Initialize Vue App with SQLite Hook

Source: https://github.com/capacitor-community/sqlite/blob/master/docs/Ionic-Vue-Usage.md

This snippet shows the main.ts file configuration for initializing the Vue app with SQLite capabilities, including custom element loading and database setup for web platforms.

```js
import { defineCustomElements as jeepSqlite, applyPolyfills } from "jeep-sqlite/loader";
import { Capacitor } from '@capacitor/core';
import { CapacitorSQLite, SQLiteConnection, SQLiteDBConnection } from '@capacitor-community/sqlite';
import { useState } from '@/composables/state';
import { schemaToImport179 } from '@/utils/utils-import-from-json';

applyPolyfills().then(() => {
    jeepSqlite(window);
});
window.addEventListener('DOMContentLoaded', async () => {
  const platform = Capacitor.getPlatform();
  const sqlite: SQLiteConnection = new SQLiteConnection(CapacitorSQLite)

  const app = createApp(App)
    .use(IonicVue)
    .use(router);

  /* SQLite Global Variables*/

  // Only if you want to use the onProgressImport/Export events
  const [jsonListeners, setJsonListeners] = useState(false);
  const [isModal, setIsModal] = useState(false);
  const [message, setMessage] = useState("");
  app.config.globalProperties.$isModalOpen = {isModal: isModal, setIsModal: setIsModal};
  app.config.globalProperties.$isJsonListeners = {jsonListeners: jsonListeners, setJsonListeners: setJsonListeners};
  app.config.globalProperties.$messageContent = {message: message, setMessage: setMessage};

  //  Existing Connections Store
  const [existConn, setExistConn] = useState(false);
  app.config.globalProperties.$existingConn = {existConn: existConn, setExistConn: setExistConn};

  try {
    if(platform === "web") {
      // Create the 'jeep-sqlite' Stencil component
      const jeepSqlite = document.createElement('jeep-sqlite');
      document.body.appendChild(jeepSqlite);
      await customElements.whenDefined('jeep-sqlite');
      // Initialize the Web store
      await sqlite.initWebStore();
    }
    // here you can initialize some database schema if required

    // example: database creation with standard SQLite statements 
    const ret = await sqlite.checkConnectionsConsistency();
    const isConn = (await sqlite.isConnection("db_tab3")).result;
    let db: SQLiteDBConnection
    if (ret.result && isConn) {
      db = await sqlite.retrieveConnection("db_tab3");
    } else {
      db = await sqlite.createConnection("db_tab3", false, "no-encryption", 1);
    }
    await db.open();
    const query = `
    CREATE TABLE IF NOT EXISTS test (
      id INTEGER PRIMARY KEY NOT NULL,
      name TEXT NOT NULL
    );
    `
    const res = await db.execute(query);
    if(res.changes && res.changes.changes && res.changes.changes < 0) {
      throw new Error(`Error: execute failed`);
    }
    await sqlite.closeConnection("db_tab3");

    // example: database creation from importFromJson 
    const result = await sqlite.isJsonValid(JSON.stringify(schemaToImport179));
    if(!result.result) {
      throw new Error(`isJsonValid: "schemaToImport179" is not valid`);
    }
    // full import
    const resJson = await sqlite.importFromJson(JSON.stringify(schemaToImport179));    
    if(resJson.changes && resJson.changes.changes && resJson.changes.changes < 0) {
      throw new Error(`importFromJson: "full" failed`);
    }

    router.isReady().then(() => {
      app.mount('#app');
    });
  } catch (err) {
    console.log(`Error: ${err}`);
    throw new Error(`Error: ${err}`)
  }
});

```

--------------------------------

### Capacitor Build Process

Source: https://github.com/capacitor-community/sqlite/blob/master/docs/Web-Usage.md

Follow these commands to sync, build, copy web assets, and serve your Capacitor application.

```bash
npx cap sync
npm run build
npx cap copy web
npm run serve
```

--------------------------------

### Using RUN with RETURNING for INSERT, UPDATE, and DELETE

Source: https://github.com/capacitor-community/sqlite/blob/master/docs/Returning.md

Demonstrates the usage of the RUN method with different RETURNING modes ('all', 'one', 'no') for INSERT, UPDATE, and DELETE operations. Shows how to create a schema, open a connection, execute statements, and query the database.

```typescript
const createSchemaTest: string = "
  CREATE TABLE IF NOT EXISTS test (
    id INTEGER PRIMARY KEY NOT NULL,
    name TEXT NOT NULL,
    email TEXT NOT NULL
  );
  ";

// Create the connection
const db = await this.sqliteService.createConnection("test", false,
                                               "no-encryption", 1);
// Open the database
await db.open();

// Create the database schema
const res: any = await db.execute(createSchemaTest);
console.log(`>>> res: ${JSON.stringify(res)}`);
// mode 'no' INSERT
const resI0:any = await db.run("INSERT INTO test (name,email) VALUES ('Ackerman','ackerman@example.com') , ('Jefferson','jefferson@example.com');",[],true,'no');
console.log(`>>> resI0: ${JSON.stringify(resI0)}`);
// mode 'all' INSERT
const resI:any = await db.run("INSERT INTO test (name,email) VALUES ('Jeepq','jeepq@example.com') , ('Brown','brown@example.com') RETURNING *;",[],true,'all');
console.log(`>>> resI: ${JSON.stringify(resI)}`);
// mode 'one' INSERT
const resI1:any = await db.run("INSERT INTO test (name,email) VALUES ('Jones','jones@example.com') , ('Davison','davison@example.com') RETURNING email;",[],true,'one');
console.log(`>>> resI1: ${JSON.stringify(resI1)}`);
// mode 'no' INSERT
const resI2:any = await db.run("INSERT INTO test (name,email) VALUES ('White','white@example.com') , ('Johnson','Johnson@example.com') RETURNING name;",[],true,'no');
console.log(`>>> resI2: ${JSON.stringify(resI2)}`);
// mode 'all' INSERT with values
const resI3:any = await db.run("INSERT INTO test (name,email) VALUES (?,?) , (?,?) RETURNING name;",['Dupond','dupond@example.com','Toto','toto@example.com'],true,'all');
console.log(`>>> resI3: ${JSON.stringify(resI3)}`);
// mode 'one' UPDATE
const resU1:any = await db.run("UPDATE test SET email='jeepq.@company.com' WHERE name='Jeepq' RETURNING id,email;",[],true,'one');
console.log(`>>> resU1: ${JSON.stringify(resU1)}`);
// mode 'all' DELETE
const resD1:any = await db.run("DELETE FROM test WHERE id IN (2,4,6) RETURNING id,name;",[],true,'all');
console.log(`>>> resD1: ${JSON.stringify(resD1)}`);
// Query the database
const resQ1: any = await db.query('SELECT * FROM test;');
console.log(`>>> resQ1: ${JSON.stringify(resQ1)}`);
// Close the connection
await this.sqliteService.closeConnection("test");
console.log(`after closeConnection`);

```

--------------------------------

### Capacitor Build Process

Source: https://github.com/capacitor-community/sqlite/blob/master/docs/Web-Usage.md

Steps to sync, build, and copy the web application for Capacitor. This is the standard procedure for preparing a web build for Capacitor deployment.

```bash
npx cap sync
npm run build
npx cap copy web
ionic serve
```

--------------------------------

### initWebStore()

Source: https://github.com/capacitor-community/sqlite/blob/master/docs/API.md

Initializes the web store for database operations. This method is used to set up the necessary components for storing database information in the web environment.

```APIDOC
## initWebStore()

### Description
Initialize the web store

### Method
(Not specified, likely a method call)

### Endpoint
(Not applicable, SDK method)

### Parameters
None

### Request Example
```typescript
await CapacitorSQLite.initWebStore();
```

### Response
#### Success Response
- **void**: The operation completes without returning specific data.

#### Response Example
(No specific data returned on success)
```

--------------------------------

### Initialize Capacitor SQLite in main.ts

Source: https://github.com/capacitor-community/sqlite/blob/master/docs/Web-Usage.md

Import and apply polyfills for `jeep-sqlite`, set up the `SQLiteConnection` instance, and initialize the Web store if the platform is 'web'.

```javascript
... import { defineCustomElements as jeepSqlite, applyPolyfills } from "jeep-sqlite/loader";
import { Capacitor } from '@capacitor/core';
import { CapacitorSQLite, SQLiteConnection, SQLiteDBConnection } from '@capacitor-community/sqlite';
import { useState } from '@/composables/state';


... 
applyPolyfills().then(() => {
    jeepSqlite(window);
});

window.addEventListener('DOMContentLoaded', async () => {
  const platform = Capacitor.getPlatform();
  const sqlite: SQLiteConnection = new SQLiteConnection(CapacitorSQLite)

  const app = createApp(App)
    .use(IonicVue)
    .use(router);

  /* SQLite Global Variables*/

  // Only if you want to use the onProgressImport/Export events
  const [jsonListeners, setJsonListeners] = useState(false);
  const [isModal, setIsModal] = useState(false);
  const [message, setMessage] = useState("");
  app.config.globalProperties.$isModalOpen = {isModal: isModal, setIsModal: setIsModal};
  app.config.globalProperties.$isJsonListeners = {jsonListeners: jsonListeners, setJsonListeners: setJsonListeners};
  app.config.globalProperties.$messageContent = {message: message, setMessage: setMessage};

  //  Existing Connections Store
  const [existConn, setExistConn] = useState(false);
  app.config.globalProperties.$existingConn = {existConn: existConn, setExistConn: setExistConn};

  try {
    if(platform === "web") {
      // Create the 'jeep-sqlite' Stencil component
      const jeepSqlite = document.createElement('jeep-sqlite');
      document.body.appendChild(jeepSqlite);
      await customElements.whenDefined('jeep-sqlite');
      // Initialize the Web store
      await sqlite.initWebStore();
    }
    // here you can initialize some database schema if required

```

--------------------------------

### initWebStore()

Source: https://github.com/capacitor-community/sqlite/blob/master/docs/APIConnection.md

Initializes the web store for SQLite database operations. This method is available since version 3.2.3-1.

```APIDOC
## initWebStore()

### Description
Init the web store.

### Method
<code>Promise&lt;void&gt;</code>

### Endpoint
N/A (SDK Method)

### Parameters
None

### Response
#### Success Response
- **void**: Indicates successful initialization.

### Response Example
(No specific example provided, returns void on success)
```

--------------------------------

### Initialize Web Store

Source: https://github.com/capacitor-community/sqlite/blob/master/docs/Ionic-Angular-Usage.md

Initializes the web store for database operations. This is specific to the web platform and requires an open connection.

```typescript
async initWebStore(): Promise<void> {
        this.ensureIsWebPlatform();
        this.ensureConnectionIsOpen();
        return this.sqlite.initWebStore();
    }
```

--------------------------------

### Initialize Web Store

Source: https://github.com/capacitor-community/sqlite/blob/master/docs/Ionic-Angular-Usage.md

Initializes the web store for database operations. This method is only available on the web platform and requires an open connection.

```APIDOC
## initWebStore

### Description
Initializes the web store for database operations. This method is only available on the web platform.

### Method
POST

### Endpoint
/initWebStore

### Response
#### Success Response (200)
- **result** (void) - Indicates the web store was successfully initialized.

#### Response Example
```json
{
  "result": null
}
```
```

--------------------------------

### Initialize Web Store

Source: https://github.com/capacitor-community/sqlite/blob/master/docs/APIConnection.md

Initializes the web store for SQLite databases. Use this method to prepare the storage mechanism for web environments.

```typescript
initWebStore() => Promise<void>
```

--------------------------------

### getVersion

Source: https://github.com/capacitor-community/sqlite/blob/master/docs/APIDBConnection.md

Get the version of the SQLite database.

```APIDOC
## getVersion

### Description
Get the version of the SQLite database.

### Method
GET

### Endpoint
getVersion

### Parameters

### Response
#### Success Response (200)
- **return value** (<a href="#capversionresult">capVersionResult</a>) - An object containing the database version.

### Response Example
```json
{
  "version": 3
}
```
```

--------------------------------

### Database List Configuration

Source: https://github.com/capacitor-community/sqlite/blob/master/docs/Web-Usage.md

Create a databases.json file in the assets folder to list non-encrypted database names if you have databases in src/assets/databases.

```json
{
  "databaseList" : [
    "YOUR_DB1.db",
    "YOUR_DB2.db",
    ...
  ]
}
```

--------------------------------

### getUrl

Source: https://github.com/capacitor-community/sqlite/blob/master/docs/APIDBConnection.md

Get the URL of the database connection.

```APIDOC
## getUrl

### Description
Get the URL of the database connection.

### Method
GET

### Endpoint
getUrl

### Parameters

### Response
#### Success Response (200)
- **return value** (<a href="#capsqliteurl">capSQLiteUrl</a>) - An object containing the database URL.

### Response Example
```json
{
  "url": "file:///path/to/database.db"
}
```
```

--------------------------------

### getConnectionReadOnly

Source: https://github.com/capacitor-community/sqlite/blob/master/docs/APIDBConnection.md

Get the read-only status of the SQLite DB Connection.

```APIDOC
## getConnectionReadOnly

### Description
Get the read-only status of the SQLite DB Connection.

### Method
GET

### Endpoint
getConnectionReadOnly

### Parameters

### Response
#### Success Response (200)
- **return value** (boolean) - True if the connection is read-only, false otherwise.

### Response Example
```json
false
```
```

--------------------------------

### getConnectionDBName

Source: https://github.com/capacitor-community/sqlite/blob/master/docs/APIDBConnection.md

Get the database name of the SQLite DB Connection.

```APIDOC
## getConnectionDBName

### Description
Get the database name of the SQLite DB Connection.

### Method
GET

### Endpoint
getConnectionDBName

### Parameters

### Response
#### Success Response (200)
- **return value** (string) - The name of the database connection.

### Response Example
```json
"myDatabase.db"
```
```

--------------------------------

### Initialize TypeORM DataSources

Source: https://github.com/capacitor-community/sqlite/blob/master/docs/TypeORM-Usage-From-5.6.0.md

This snippet shows how to initialize multiple TypeORM DataSources, run migrations, and save data to the store on the web platform. It includes checks for connection consistency and handles platform-specific logic.

```typescript
import { JeepSqlite } from 'jeep-sqlite/dist/components/jeep-sqlite';
import sqliteParams from './databases/sqliteParams';
import authorDataSource from './databases/datasources/AuthorDataSource';

customElements.define('jeep-sqlite', JeepSqlite);

const initializeDataSources = async () => {
  //check sqlite connections consistency
  await sqliteParams.connection.checkConnectionsConsistency()
  .catch((e) => {
    console.log(e);
    return {};
  });

  // Loop through the DataSources
  for (const mDataSource of [authorDataSource , userDataSource]) {
    // initialize
    await mDataSource.dataSource.initialize();
    if (mDataSource.dataSource.isInitialized) {
      // run the migrations
      await mDataSource.dataSource.runMigrations();
    }
    if( sqliteParams.platform === 'web') {
      await sqliteParams.connection.saveToStore(mDataSource.dbName);
    }                    
  }
}

if (sqliteParams.platform !== "web") {
  initializeDataSources();
  // Now depending on the Framework render your APP
  ...
} else {
  window.addEventListener('DOMContentLoaded', async () => {
      const jeepEl = document.createElement("jeep-sqlite");
      document.body.appendChild(jeepEl);
      customElements.whenDefined('jeep-sqlite').then(async () => {
        await sqliteParams.connection.initWebStore();
        await initializeDataSources();
        // Now depending on the Framework render your APP
        ...
     })
      .catch ((err) => {
        console.log(`Error: ${err}`);
        throw new Error(`Error: ${err}`)
      });
  });

}
```

--------------------------------

### Ionic/React App Initialization with Capacitor SQLite

Source: https://github.com/capacitor-community/sqlite/blob/master/docs/Web-Usage.md

This TypeScript code snippet demonstrates the initialization process for Capacitor SQLite in a web environment within an Ionic/React application. It includes setting up the Stencil component, initializing the web store, checking connection consistency, creating or retrieving a database connection, executing a table creation query, and finally launching the React app.

```typescript
... 
import { defineCustomElements as jeepSqlite, applyPolyfills, JSX as LocalJSX  } from "jeep-sqlite/loader";
import { HTMLAttributes } from 'react';
import { Capacitor } from '@capacitor/core';
import { CapacitorSQLite, SQLiteConnection, SQLiteDBConnection } from '@capacitor-community/sqlite';

type StencilToReact<T> = {
  [P in keyof T]?:
    T[P] & Omit<HTMLAttributes<Element>, 'className'> & {
      class?: string;
    };
} ;

declare global {
  export namespace JSX {
    interface IntrinsicElements extends StencilToReact<LocalJSX.IntrinsicElements> {
    }
  }
}

applyPolyfills().then(() => {
    jeepSqlite(window);
});

window.addEventListener('DOMContentLoaded', async () => {
  const platform = Capacitor.getPlatform();
  const sqlite: SQLiteConnection = new SQLiteConnection(CapacitorSQLite)
  try {
    if(platform === "web") {
      // add 'jeep-sqlite' Stencil component to the DOM
      const jeepEl = document.createElement("jeep-sqlite");
      document.body.appendChild(jeepEl);
      await customElements.whenDefined('jeep-sqlite');
      // initialize the web store
      await sqlite.initWebStore();
    }
    // initialize some database schema if needed
    const ret = await sqlite.checkConnectionsConsistency();
    const isConn = (await sqlite.isConnection("db_issue10")).result;
    var db: SQLiteDBConnection
    if (ret.result && isConn) {
      db = await sqlite.retrieveConnection("db_issue10");
    } else {
      db = await sqlite.createConnection("db_issue10", false, "no-encryption", 1);
    }
    await db.open();
    let query = `
    CREATE TABLE IF NOT EXISTS test (
      id INTEGER PRIMARY KEY NOT NULL,
      name TEXT NOT NULL
    );
    `
    const res: any = await db.execute(query);
    await db.close();
     await sqlite.closeConnection("db_issue10");
    
    // launch the React App
    ReactDOM.render(
      <React.StrictMode>
        <App /> 
      </React.StrictMode>,
      document.getElementById('root')
    );

    // If you want your app to work offline and load faster, you can change
    // unregister() to register() below. Note this comes with some pitfalls.
    // Learn more about service workers: https://bit.ly/CRA-PWA
    serviceWorker.unregister();

  } catch (err) {
    console.log(`Error: ${err}`);
    throw new Error(`Error: ${err}`)
  }

});

```

--------------------------------

### Get Synchronization Date

Source: https://github.com/capacitor-community/sqlite/blob/master/docs/API.md

Retrieves the synchronization date. Requires `capSQLiteOptions` and returns `capSQLiteSyncDate`.

```typescript
getSyncDate(options: capSQLiteOptions) => Promise<capSQLiteSyncDate>
```

--------------------------------

### initializePlugin

Source: https://github.com/capacitor-community/sqlite/blob/master/docs/Ionic-Angular-Usage.md

Initializes the SQLite plugin and sets up the connection. This method should be called before any other SQLite operations.

```APIDOC
## initializePlugin

### Description
Initializes the SQLite plugin and determines the platform. It sets up the `SQLiteConnection` instance.

### Method
`async initializePlugin(): Promise<boolean>`

### Returns
- `Promise<boolean>`: Returns `true` if the plugin was successfully initialized.
```

--------------------------------

### Get Synchronization Date

Source: https://github.com/capacitor-community/sqlite/blob/master/docs/APIDBConnection.md

Use this method to retrieve the current synchronization date of the database.

```typescript
getSyncDate() => Promise<string>
```

--------------------------------

### Initialize TypeORM Data Source with CapacitorSQLite

Source: https://github.com/capacitor-community/sqlite/blob/master/docs/TypeORM-Usage.md

This snippet demonstrates how to set up and initialize a TypeORM DataSource using the capacitor-sqlite driver. It includes checking connection consistency and passing the SQLiteConnection wrapper to the DataSource configuration. Ensure 'YOUR_DB_NAME' is replaced with your actual database name.

```typescript
import { CapacitorSQLite, SQLiteConnection } from '@capacitor-community/sqlite';
import { DataSource } from 'typeorm';

// when using Capacitor, you might want to close existing connections, 
// otherwise new connections will fail when using dev-live-reload
// see https://github.com/capacitor-community/sqlite/issues/106
this.pSqliteConsistent = CapacitorSQLite.checkConnectionsConsistency({
    dbNames: [], // i.e. "i expect no connections to be open"
}).catch((e) => {
    // the plugin throws an error when closing connections. we can ignore
    // that since it is expected behaviour
    console.log(e);
    return {};
});

// create a SQLite Connection Wrapper
const sqliteConnection = new SQLiteConnection(CapacitorSQLite);

// copy preloaded dbs (optional, not TypeORM related):
// the preloaded dbs must have the `YOUR_DB_NAME.db` format (i.e. including 
// the `.db` suffix, NOT including the internal `SQLITE` suffix from the plugin)
await sqliteConnection.copyFromAssets();

// create the TypeORM connection
// For more information see https://typeorm.io/data-source#creating-a-new-datasource
const AppDataSource = new DataSource({
    type: 'capacitor',
    driver: sqliteConnection, // pass the connection wrapper here
    database: 'YOUR_DB_NAME' // database name without the `.db` suffix
});

AppDataSource.initialize()
    .then(() => {
        console.log("Data Source has been initialized!")
    })
    .catch((err) => {
        console.error("Error during Data Source initialization", err)
    });
    
```

--------------------------------

### Publish Plugin

Source: https://github.com/capacitor-community/sqlite/blob/master/CONTRIBUTING.md

Use this command to publish the plugin to npm. A pre-publish hook ensures the plugin is prepared before publishing.

```shell
npm publish
```

--------------------------------

### Get List of Tables in Database

Source: https://github.com/capacitor-community/sqlite/blob/master/docs/APIDBConnection.md

Use this method to retrieve a list of all tables present in the SQLite database.

```typescript
getTableList() => Promise<DBSQLiteValues>
```

--------------------------------

### Initialize Web Store for Jeep-SQLite

Source: https://github.com/capacitor-community/sqlite/blob/master/docs/info_releases.md

Mandatory initialization for the Web platform using jeep-sqlite. Ensure the 'jeep-sqlite' custom element is defined before calling initWebStore.

```javascript
... 
  if(platform === "web") {
    await customElements.whenDefined('jeep-sqlite');
    const jeepSqliteEl = document.querySelector('jeep-sqlite');
    if(jeepSqliteEl != null) {
      await sqliteConnection.initWebStore()
      ...
    }
  }
...
```

--------------------------------

### Get Table List

Source: https://github.com/capacitor-community/sqlite/blob/master/docs/API.md

Retrieves the list of tables within a specific database. Requires `capSQLiteOptions` and returns `capSQLiteValues`.

```typescript
getTableList(options: capSQLiteOptions) => Promise<capSQLiteValues>
```