@capgo/capacitor-fast-sql 7.0.1

package/android/src/main/java/app/capgo/capacitor/fastsql/SQLDatabase.java

@@ -0,0 +1,231 @@
+package app.capgo.capacitor.fastsql;
+
+import android.database.Cursor;
+import android.database.sqlite.SQLiteDatabase;
+import android.database.sqlite.SQLiteStatement;
+import android.util.Base64;
+
+import com.getcapacitor.JSArray;
+import com.getcapacitor.JSObject;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * SQLite database wrapper for Android
+ */
+public class SQLDatabase {
+    private SQLiteDatabase db;
+    private boolean inTransaction = false;
+
+    public SQLDatabase(String path) {
+        this.db = SQLiteDatabase.openOrCreateDatabase(path, null);
+        // Enable foreign keys
+        db.execSQL("PRAGMA foreign_keys = ON");
+    }
+
+    public void close() {
+        if (db != null && db.isOpen()) {
+            db.close();
+        }
+    }
+
+    public JSObject execute(String statement, JSArray params) throws Exception {
+        if (db == null || !db.isOpen()) {
+            throw new Exception("Database is not open");
+        }
+
+        // Check if this is a query (SELECT) or a modification (INSERT/UPDATE/DELETE)
+        String trimmedStatement = statement.trim().toUpperCase();
+        boolean isQuery = trimmedStatement.startsWith("SELECT") ||
+                         trimmedStatement.startsWith("PRAGMA") ||
+                         trimmedStatement.startsWith("EXPLAIN");
+
+        if (isQuery) {
+            return executeQuery(statement, params);
+        } else {
+            return executeUpdate(statement, params);
+        }
+    }
+
+    private JSObject executeQuery(String statement, JSArray params) throws Exception {
+        Cursor cursor = null;
+        try {
+            // Prepare statement with parameters
+            String[] bindArgs = convertParamsToStringArray(params);
+            cursor = db.rawQuery(statement, bindArgs);
+
+            // Build result
+            JSArray rows = new JSArray();
+            while (cursor.moveToNext()) {
+                JSObject row = new JSObject();
+                for (int i = 0; i < cursor.getColumnCount(); i++) {
+                    String columnName = cursor.getColumnName(i);
+                    Object value = getColumnValue(cursor, i);
+                    row.put(columnName, value);
+                }
+                rows.put(row);
+            }
+
+            JSObject result = new JSObject();
+            result.put("rows", rows);
+            result.put("rowsAffected", 0);
+            return result;
+        } finally {
+            if (cursor != null) {
+                cursor.close();
+            }
+        }
+    }
+
+    private JSObject executeUpdate(String statement, JSArray params) throws Exception {
+        SQLiteStatement stmt = null;
+        try {
+            stmt = db.compileStatement(statement);
+
+            // Bind parameters
+            bindParams(stmt, params);
+
+            // Execute
+            long result;
+            if (statement.trim().toUpperCase().startsWith("INSERT")) {
+                result = stmt.executeInsert();
+            } else {
+                stmt.execute();
+                result = -1;
+            }
+
+            // Get affected rows
+            int changes = (int) db.compileStatement("SELECT changes()").simpleQueryForLong();
+
+            JSObject ret = new JSObject();
+            ret.put("rows", new JSArray());
+            ret.put("rowsAffected", changes);
+            if (result > 0) {
+                ret.put("insertId", result);
+            }
+            return ret;
+        } finally {
+            if (stmt != null) {
+                stmt.close();
+            }
+        }
+    }
+
+    public void beginTransaction() throws Exception {
+        if (inTransaction) {
+            throw new Exception("Transaction already active");
+        }
+        db.beginTransaction();
+        inTransaction = true;
+    }
+
+    public void commitTransaction() throws Exception {
+        if (!inTransaction) {
+            throw new Exception("No transaction active");
+        }
+        db.setTransactionSuccessful();
+        db.endTransaction();
+        inTransaction = false;
+    }
+
+    public void rollbackTransaction() throws Exception {
+        if (!inTransaction) {
+            throw new Exception("No transaction active");
+        }
+        db.endTransaction();
+        inTransaction = false;
+    }
+
+    private String[] convertParamsToStringArray(JSArray params) throws JSONException {
+        if (params == null || params.length() == 0) {
+            return null;
+        }
+
+        List<String> args = new ArrayList<>();
+        for (int i = 0; i < params.length(); i++) {
+            Object value = params.get(i);
+            if (value == null || value == JSONObject.NULL) {
+                args.add(null);
+            } else if (value instanceof JSONObject) {
+                JSONObject obj = (JSONObject) value;
+                if (obj.has("_type") && "binary".equals(obj.getString("_type"))) {
+                    // For queries, we can't bind binary data as string
+                    // This is a limitation - for binary data, use executeUpdate
+                    args.add(obj.getString("_data"));
+                } else {
+                    args.add(value.toString());
+                }
+            } else {
+                args.add(value.toString());
+            }
+        }
+        return args.toArray(new String[0]);
+    }
+
+    private void bindParams(SQLiteStatement stmt, JSArray params) throws Exception {
+        if (params == null || params.length() == 0) {
+            return;
+        }
+
+        for (int i = 0; i < params.length(); i++) {
+            Object value = params.get(i);
+            int index = i + 1; // SQLite parameters are 1-indexed
+
+            if (value == null || value == JSONObject.NULL) {
+                stmt.bindNull(index);
+            } else if (value instanceof String) {
+                stmt.bindString(index, (String) value);
+            } else if (value instanceof Integer) {
+                stmt.bindLong(index, ((Integer) value).longValue());
+            } else if (value instanceof Long) {
+                stmt.bindLong(index, (Long) value);
+            } else if (value instanceof Double) {
+                stmt.bindDouble(index, (Double) value);
+            } else if (value instanceof Float) {
+                stmt.bindDouble(index, ((Float) value).doubleValue());
+            } else if (value instanceof Boolean) {
+                stmt.bindLong(index, ((Boolean) value) ? 1 : 0);
+            } else if (value instanceof JSONObject) {
+                JSONObject obj = (JSONObject) value;
+                if (obj.has("_type") && "binary".equals(obj.getString("_type"))) {
+                    // Handle binary data
+                    String base64 = obj.getString("_data");
+                    byte[] bytes = Base64.decode(base64, Base64.DEFAULT);
+                    stmt.bindBlob(index, bytes);
+                } else {
+                    stmt.bindString(index, value.toString());
+                }
+            } else {
+                stmt.bindString(index, value.toString());
+            }
+        }
+    }
+
+    private Object getColumnValue(Cursor cursor, int index) {
+        int type = cursor.getType(index);
+        switch (type) {
+            case Cursor.FIELD_TYPE_NULL:
+                return JSONObject.NULL;
+            case Cursor.FIELD_TYPE_INTEGER:
+                return cursor.getLong(index);
+            case Cursor.FIELD_TYPE_FLOAT:
+                return cursor.getDouble(index);
+            case Cursor.FIELD_TYPE_STRING:
+                return cursor.getString(index);
+            case Cursor.FIELD_TYPE_BLOB:
+                byte[] blob = cursor.getBlob(index);
+                String base64 = Base64.encodeToString(blob, Base64.NO_WRAP);
+                JSObject blobObj = new JSObject();
+                blobObj.put("_type", "binary");
+                blobObj.put("_data", base64);
+                return blobObj;
+            default:
+                return JSONObject.NULL;
+        }
+    }
+}

package/android/src/main/java/app/capgo/capacitor/fastsql/SQLHTTPServer.java

@@ -0,0 +1,229 @@
+package app.capgo.capacitor.fastsql;
+
+import com.getcapacitor.JSArray;
+import com.getcapacitor.JSObject;
+import com.google.gson.Gson;
+import com.google.gson.JsonArray;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
+
+import org.json.JSONArray;
+import org.json.JSONObject;
+
+import java.io.IOException;
+import java.security.SecureRandom;
+import java.util.Map;
+
+import fi.iki.elonen.NanoHTTPD;  // Note: org.nanohttpd:nanohttpd:2.3.1 still uses fi.iki.elonen package
+
+/**
+ * HTTP server for efficient SQL operations
+ *
+ * This server handles direct HTTP requests from JavaScript, bypassing Capacitor's
+ * bridge for better performance with large datasets and sync operations.
+ */
+public class SQLHTTPServer extends NanoHTTPD {
+    private final String token;
+    private final Map<String, SQLDatabase> databases;
+    private final Gson gson = new Gson();
+
+    public SQLHTTPServer(Map<String, SQLDatabase> databases) throws IOException {
+        super(findAvailablePort());
+        this.databases = databases;
+        this.token = generateToken();
+    }
+
+    public String getToken() {
+        return token;
+    }
+
+    public int getPort() {
+        return getListeningPort();
+    }
+
+    @Override
+    public Response serve(IHTTPSession session) {
+        // Check authentication
+        String authHeader = session.getHeaders().get("authorization");
+        if (authHeader == null || !authHeader.equals("Bearer " + token)) {
+            return newFixedLengthResponse(Response.Status.UNAUTHORIZED, "text/plain", "Unauthorized");
+        }
+
+        // Get database name
+        String database = session.getHeaders().get("x-database");
+        if (database == null) {
+            return newFixedLengthResponse(Response.Status.BAD_REQUEST, "text/plain", "Database header required");
+        }
+
+        // Check if database exists
+        SQLDatabase db = databases.get(database);
+        if (db == null) {
+            return newFixedLengthResponse(Response.Status.NOT_FOUND, "text/plain", "Database not found");
+        }
+
+        String uri = session.getUri();
+        Method method = session.getMethod();
+
+        try {
+            if (method == Method.POST && uri.equals("/execute")) {
+                return handleExecute(session, db);
+            } else if (method == Method.POST && uri.equals("/batch")) {
+                return handleBatch(session, db);
+            } else if (method == Method.POST && uri.equals("/transaction/begin")) {
+                return handleBeginTransaction(db);
+            } else if (method == Method.POST && uri.equals("/transaction/commit")) {
+                return handleCommitTransaction(db);
+            } else if (method == Method.POST && uri.equals("/transaction/rollback")) {
+                return handleRollbackTransaction(db);
+            } else {
+                return newFixedLengthResponse(Response.Status.NOT_FOUND, "text/plain", "Endpoint not found");
+            }
+        } catch (Exception e) {
+            return newFixedLengthResponse(Response.Status.INTERNAL_ERROR, "text/plain",
+                    "Error: " + e.getMessage());
+        }
+    }
+
+    private Response handleExecute(IHTTPSession session, SQLDatabase db) throws Exception {
+        // Read request body
+        String body = readRequestBody(session);
+        JsonObject request = JsonParser.parseString(body).getAsJsonObject();
+
+        String statement = request.get("statement").getAsString();
+        JsonArray paramsJson = request.has("params") ? request.getAsJsonArray("params") : new JsonArray();
+
+        // Convert to JSArray
+        JSArray params = new JSArray();
+        for (JsonElement param : paramsJson) {
+            if (param.isJsonNull()) {
+                params.put(JSONObject.NULL);
+            } else if (param.isJsonPrimitive()) {
+                if (param.getAsJsonPrimitive().isNumber()) {
+                    try {
+                        params.put(param.getAsLong());
+                    } catch (NumberFormatException e) {
+                        params.put(param.getAsDouble());
+                    }
+                } else if (param.getAsJsonPrimitive().isBoolean()) {
+                    params.put(param.getAsBoolean());
+                } else {
+                    params.put(param.getAsString());
+                }
+            } else if (param.isJsonObject()) {
+                JsonObject obj = param.getAsJsonObject();
+                JSONObject jsonObj = new JSONObject();
+                for (String key : obj.keySet()) {
+                    jsonObj.put(key, obj.get(key).getAsString());
+                }
+                params.put(jsonObj);
+            }
+        }
+
+        // Execute query
+        JSObject result = db.execute(statement, params);
+
+        // Convert result to JSON
+        String resultJson = result.toString();
+        return newFixedLengthResponse(Response.Status.OK, "application/json", resultJson);
+    }
+
+    private Response handleBatch(IHTTPSession session, SQLDatabase db) throws Exception {
+        // Read request body
+        String body = readRequestBody(session);
+        JsonObject request = JsonParser.parseString(body).getAsJsonObject();
+        JsonArray operations = request.getAsJsonArray("operations");
+
+        JSONArray results = new JSONArray();
+        for (JsonElement opElement : operations) {
+            JsonObject operation = opElement.getAsJsonObject();
+            String statement = operation.get("statement").getAsString();
+            JsonArray paramsJson = operation.has("params") ? operation.getAsJsonArray("params") : new JsonArray();
+
+            // Convert to JSArray
+            JSArray params = new JSArray();
+            for (JsonElement param : paramsJson) {
+                if (param.isJsonNull()) {
+                    params.put(JSONObject.NULL);
+                } else if (param.isJsonPrimitive()) {
+                    if (param.getAsJsonPrimitive().isNumber()) {
+                        try {
+                            params.put(param.getAsLong());
+                        } catch (NumberFormatException e) {
+                            params.put(param.getAsDouble());
+                        }
+                    } else if (param.getAsJsonPrimitive().isBoolean()) {
+                        params.put(param.getAsBoolean());
+                    } else {
+                        params.put(param.getAsString());
+                    }
+                } else if (param.isJsonObject()) {
+                    JsonObject obj = param.getAsJsonObject();
+                    JSONObject jsonObj = new JSONObject();
+                    for (String key : obj.keySet()) {
+                        jsonObj.put(key, obj.get(key).getAsString());
+                    }
+                    params.put(jsonObj);
+                }
+            }
+
+            JSObject result = db.execute(statement, params);
+            results.put(new JSONObject(result.toString()));
+        }
+
+        return newFixedLengthResponse(Response.Status.OK, "application/json", results.toString());
+    }
+
+    private Response handleBeginTransaction(SQLDatabase db) throws Exception {
+        db.beginTransaction();
+        return newFixedLengthResponse(Response.Status.OK, "application/json", "{}");
+    }
+
+    private Response handleCommitTransaction(SQLDatabase db) throws Exception {
+        db.commitTransaction();
+        return newFixedLengthResponse(Response.Status.OK, "application/json", "{}");
+    }
+
+    private Response handleRollbackTransaction(SQLDatabase db) throws Exception {
+        db.rollbackTransaction();
+        return newFixedLengthResponse(Response.Status.OK, "application/json", "{}");
+    }
+
+    private String readRequestBody(IHTTPSession session) throws IOException {
+        int contentLength = Integer.parseInt(session.getHeaders().get("content-length"));
+        byte[] buffer = new byte[contentLength];
+        session.getInputStream().read(buffer, 0, contentLength);
+        return new String(buffer);
+    }
+
+    private static String generateToken() {
+        SecureRandom random = new SecureRandom();
+        byte[] bytes = new byte[32];
+        random.nextBytes(bytes);
+        StringBuilder sb = new StringBuilder();
+        for (byte b : bytes) {
+            sb.append(String.format("%02x", b));
+        }
+        return sb.toString();
+    }
+
+    private static int findAvailablePort() {
+        // Try ports in the range 9000-9100
+        for (int port = 9000; port < 9100; port++) {
+            try {
+                NanoHTTPD testServer = new NanoHTTPD(port) {
+                    @Override
+                    public Response serve(IHTTPSession session) {
+                        return null;
+                    }
+                };
+                testServer.start(NanoHTTPD.SOCKET_READ_TIMEOUT, false);
+                testServer.stop();
+                return port;
+            } catch (IOException e) {
+                // Port not available, try next one
+            }
+        }
+        return 9000; // Fallback
+    }
+}

package/dist/esm/definitions.d.ts

@@ -0,0 +1,225 @@
+/**
+ * SQL value types supported by the plugin
+ */
+export type SQLValue = string | number | boolean | null | Uint8Array;
+/**
+ * SQL row result - values indexed by column name
+ */
+export interface SQLRow {
+    [column: string]: SQLValue;
+}
+/**
+ * Result of a SQL query execution
+ */
+export interface SQLResult {
+    /**
+     * Rows returned by the query (for SELECT statements)
+     */
+    rows: SQLRow[];
+    /**
+     * Number of rows affected by the query (for INSERT/UPDATE/DELETE)
+     */
+    rowsAffected: number;
+    /**
+     * ID of the last inserted row (for INSERT statements with auto-increment)
+     */
+    insertId?: number;
+}
+/**
+ * Batch SQL operation
+ */
+export interface SQLBatchOperation {
+    /**
+     * SQL statement to execute
+     */
+    statement: string;
+    /**
+     * Parameters to bind to the statement
+     */
+    params?: SQLValue[];
+}
+/**
+ * Database connection options
+ */
+export interface SQLConnectionOptions {
+    /**
+     * Database name (file will be created in app data directory)
+     */
+    database: string;
+    /**
+     * Enable encryption (iOS/Android only)
+     */
+    encrypted?: boolean;
+    /**
+     * Encryption key (required if encrypted is true)
+     */
+    encryptionKey?: string;
+    /**
+     * Read-only mode
+     */
+    readOnly?: boolean;
+}
+/**
+ * Transaction isolation levels
+ */
+export declare enum IsolationLevel {
+    ReadUncommitted = "READ UNCOMMITTED",
+    ReadCommitted = "READ COMMITTED",
+    RepeatableRead = "REPEATABLE READ",
+    Serializable = "SERIALIZABLE"
+}
+/**
+ * Native SQL Plugin for high-performance SQLite database access.
+ *
+ * This plugin uses a custom HTTP-based protocol for efficient data transfer,
+ * bypassing Capacitor's standard bridge for better performance with sync operations.
+ *
+ * @since 0.0.1
+ */
+export interface CapgoCapacitorNativeSqlPlugin {
+    /**
+     * Initialize the database connection and start the HTTP server.
+     *
+     * @param options - Connection options
+     * @returns Connection information including server port and auth token
+     * @throws Error if connection fails
+     * @since 0.0.1
+     * @example
+     * ```typescript
+     * const conn = await CapgoCapacitorNativeSql.connect({ database: 'myapp' });
+     * console.log('Connected on port:', conn.port);
+     * ```
+     */
+    connect(options: SQLConnectionOptions): Promise<{
+        port: number;
+        token: string;
+        database: string;
+    }>;
+    /**
+     * Close database connection and stop the HTTP server.
+     *
+     * @param options - Database name to close
+     * @returns Promise that resolves when disconnected
+     * @throws Error if database is not connected or disconnect fails
+     * @since 0.0.1
+     * @example
+     * ```typescript
+     * await CapgoCapacitorNativeSql.disconnect({ database: 'myapp' });
+     * ```
+     */
+    disconnect(options: {
+        database: string;
+    }): Promise<void>;
+    /**
+     * Get the HTTP server port and token for direct communication.
+     *
+     * @param options - Database name
+     * @returns Server port and auth token
+     * @throws Error if database is not connected
+     * @since 0.0.1
+     * @example
+     * ```typescript
+     * const info = await CapgoCapacitorNativeSql.getServerInfo({ database: 'myapp' });
+     * console.log('Server port:', info.port);
+     * ```
+     */
+    getServerInfo(options: {
+        database: string;
+    }): Promise<{
+        port: number;
+        token: string;
+    }>;
+    /**
+     * Execute a SQL query via Capacitor bridge (for simple queries).
+     * For better performance with large datasets, use the HTTP protocol directly via SQLConnection class.
+     *
+     * @param options - Query parameters
+     * @returns Query results
+     * @throws Error if execution fails
+     * @since 0.0.1
+     * @example
+     * ```typescript
+     * const result = await CapgoCapacitorNativeSql.execute({
+     *   database: 'myapp',
+     *   statement: 'SELECT * FROM users WHERE age > ?',
+     *   params: [18]
+     * });
+     * console.log('Rows:', result.rows);
+     * ```
+     */
+    execute(options: {
+        database: string;
+        statement: string;
+        params?: SQLValue[];
+    }): Promise<SQLResult>;
+    /**
+     * Begin a database transaction.
+     *
+     * @param options - Transaction options
+     * @returns Promise that resolves when transaction begins
+     * @throws Error if transaction fails to start
+     * @since 0.0.1
+     * @example
+     * ```typescript
+     * await CapgoCapacitorNativeSql.beginTransaction({ database: 'myapp' });
+     * // Execute multiple operations
+     * await CapgoCapacitorNativeSql.commitTransaction({ database: 'myapp' });
+     * ```
+     */
+    beginTransaction(options: {
+        database: string;
+        isolationLevel?: IsolationLevel;
+    }): Promise<void>;
+    /**
+     * Commit the current transaction.
+     *
+     * @param options - Database name
+     * @returns Promise that resolves when transaction is committed
+     * @throws Error if no transaction is active or commit fails
+     * @since 0.0.1
+     * @example
+     * ```typescript
+     * await CapgoCapacitorNativeSql.commitTransaction({ database: 'myapp' });
+     * ```
+     */
+    commitTransaction(options: {
+        database: string;
+    }): Promise<void>;
+    /**
+     * Rollback the current transaction.
+     *
+     * @param options - Database name
+     * @returns Promise that resolves when transaction is rolled back
+     * @throws Error if no transaction is active or rollback fails
+     * @since 0.0.1
+     * @example
+     * ```typescript
+     * try {
+     *   await CapgoCapacitorNativeSql.beginTransaction({ database: 'myapp' });
+     *   // Operations...
+     *   await CapgoCapacitorNativeSql.commitTransaction({ database: 'myapp' });
+     * } catch (error) {
+     *   await CapgoCapacitorNativeSql.rollbackTransaction({ database: 'myapp' });
+     * }
+     * ```
+     */
+    rollbackTransaction(options: {
+        database: string;
+    }): Promise<void>;
+    /**
+     * Get the native Capacitor plugin version.
+     *
+     * @returns Promise that resolves with the plugin version
+     * @throws Error if getting the version fails
+     * @since 0.0.1
+     * @example
+     * ```typescript
+     * const { version } = await CapgoCapacitorNativeSql.getPluginVersion();
+     * console.log('Plugin version:', version);
+     * ```
+     */
+    getPluginVersion(): Promise<{
+        version: string;
+    }>;
+}
+//# sourceMappingURL=definitions.d.ts.map

package/dist/esm/definitions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definitions.d.ts","sourceRoot":"","sources":["../../src/definitions.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,UAAU,CAAC;AAErE;;GAEG;AACH,MAAM,WAAW,MAAM;IACrB,CAAC,MAAM,EAAE,MAAM,GAAG,QAAQ,CAAC;CAC5B;AAED;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB;;OAEG;IACH,IAAI,EAAE,MAAM,EAAE,CAAC;IAEf;;OAEG;IACH,YAAY,EAAE,MAAM,CAAC;IAErB;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC;;OAEG;IACH,SAAS,EAAE,MAAM,CAAC;IAElB;;OAEG;IACH,MAAM,CAAC,EAAE,QAAQ,EAAE,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAC;IAEjB;;OAEG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IAEpB;;OAEG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IAEvB;;OAEG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED;;GAEG;AACH,oBAAY,cAAc;IACxB,eAAe,qBAAqB;IACpC,aAAa,mBAAmB;IAChC,cAAc,oBAAoB;IAClC,YAAY,iBAAiB;CAC9B;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,6BAA6B;IAC5C;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,OAAO,EAAE,oBAAoB,GAAG,OAAO,CAAC;QAC9C,IAAI,EAAE,MAAM,CAAC;QACb,KAAK,EAAE,MAAM,CAAC;QACd,QAAQ,EAAE,MAAM,CAAC;KAClB,CAAC,CAAC;IAEH;;;;;;;;;;;OAWG;IACH,UAAU,CAAC,OAAO,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEzD;;;;;;;;;;;;OAYG;IACH,aAAa,CAAC,OAAO,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC;QACpD,IAAI,EAAE,MAAM,CAAC;QACb,KAAK,EAAE,MAAM,CAAC;KACf,CAAC,CAAC;IAEH;;;;;;;;;;;;;;;;;OAiBG;IACH,OAAO,CAAC,OAAO,EAAE;QACf,QAAQ,EAAE,MAAM,CAAC;QACjB,SAAS,EAAE,MAAM,CAAC;QAClB,MAAM,CAAC,EAAE,QAAQ,EAAE,CAAC;KACrB,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC;IAEvB;;;;;;;;;;;;;OAaG;IACH,gBAAgB,CAAC,OAAO,EAAE;QACxB,QAAQ,EAAE,MAAM,CAAC;QACjB,cAAc,CAAC,EAAE,cAAc,CAAC;KACjC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAElB;;;;;;;;;;;OAWG;IACH,iBAAiB,CAAC,OAAO,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEhE;;;;;;;;;;;;;;;;;OAiBG;IACH,mBAAmB,CAAC,OAAO,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAElE;;;;;;;;;;;OAWG;IACH,gBAAgB,IAAI,OAAO,CAAC;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAClD"}

package/dist/esm/definitions.js

@@ -0,0 +1,10 @@
+/**
+ * Transaction isolation levels
+ */
+export var IsolationLevel;
+(function (IsolationLevel) {
+    IsolationLevel["ReadUncommitted"] = "READ UNCOMMITTED";
+    IsolationLevel["ReadCommitted"] = "READ COMMITTED";
+    IsolationLevel["RepeatableRead"] = "REPEATABLE READ";
+    IsolationLevel["Serializable"] = "SERIALIZABLE";
+})(IsolationLevel || (IsolationLevel = {}));