@capawesome/capacitor-libsql 0.1.0

package/android/src/main/java/io/capawesome/capacitorjs/plugins/libsql/LibsqlPlugin.java

@@ -0,0 +1,217 @@
+package io.capawesome.capacitorjs.plugins.libsql;
+
+import android.util.Log;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.getcapacitor.Plugin;
+import com.getcapacitor.PluginCall;
+import com.getcapacitor.PluginMethod;
+import com.getcapacitor.annotation.CapacitorPlugin;
+import io.capawesome.capacitorjs.plugins.libsql.classes.options.*;
+import io.capawesome.capacitorjs.plugins.libsql.classes.results.*;
+import io.capawesome.capacitorjs.plugins.libsql.interfaces.*;
+
+@CapacitorPlugin(name = "Libsql")
+public class LibsqlPlugin extends Plugin {
+
+    public static final String TAG = "Libsql";
+    private static final String ERROR_UNKNOWN_ERROR = "An unknown error occurred.";
+
+    private Libsql implementation;
+
+    @Override
+    public void load() {
+        implementation = new Libsql(this);
+    }
+
+    @PluginMethod
+    public void connect(PluginCall call) {
+        try {
+            ConnectOptions options = new ConnectOptions(call);
+            NonEmptyResultCallback<ConnectResult> callback = new NonEmptyResultCallback<ConnectResult>() {
+                @Override
+                public void success(@NonNull ConnectResult result) {
+                    resolveCall(call, result);
+                }
+
+                @Override
+                public void error(@NonNull Exception exception) {
+                    rejectCall(call, exception);
+                }
+            };
+
+            assert implementation != null;
+            implementation.connect(options, callback);
+        } catch (Exception exception) {
+            rejectCall(call, exception);
+        }
+    }
+
+    @PluginMethod
+    public void execute(PluginCall call) {
+        try {
+            ExecuteOptions options = new ExecuteOptions(call);
+            EmptyCallback callback = new EmptyCallback() {
+                @Override
+                public void success() {
+                    resolveCall(call);
+                }
+
+                @Override
+                public void error(@NonNull Exception exception) {
+                    rejectCall(call, exception);
+                }
+            };
+
+            assert implementation != null;
+            implementation.execute(options, callback);
+        } catch (Exception exception) {
+            rejectCall(call, exception);
+        }
+    }
+
+    @PluginMethod
+    public void executeBatch(PluginCall call) {
+        try {
+            ExecuteBatchOptions options = new ExecuteBatchOptions(call);
+            EmptyCallback callback = new EmptyCallback() {
+                @Override
+                public void success() {
+                    resolveCall(call);
+                }
+
+                @Override
+                public void error(@NonNull Exception exception) {
+                    rejectCall(call, exception);
+                }
+            };
+
+            assert implementation != null;
+            implementation.executeBatch(options, callback);
+        } catch (Exception exception) {
+            rejectCall(call, exception);
+        }
+    }
+
+    @PluginMethod
+    public void query(PluginCall call) {
+        try {
+            QueryOptions options = new QueryOptions(call);
+            NonEmptyResultCallback<QueryResult> callback = new NonEmptyResultCallback<QueryResult>() {
+                @Override
+                public void success(@NonNull QueryResult result) {
+                    resolveCall(call, result);
+                }
+
+                @Override
+                public void error(@NonNull Exception exception) {
+                    rejectCall(call, exception);
+                }
+            };
+
+            assert implementation != null;
+            implementation.query(options, callback);
+        } catch (Exception exception) {
+            rejectCall(call, exception);
+        }
+    }
+
+    @PluginMethod
+    public void beginTransaction(PluginCall call) {
+        try {
+            BeginTransactionOptions options = new BeginTransactionOptions(call);
+            NonEmptyResultCallback<BeginTransactionResult> callback = new NonEmptyResultCallback<BeginTransactionResult>() {
+                @Override
+                public void success(@NonNull BeginTransactionResult result) {
+                    resolveCall(call, result);
+                }
+
+                @Override
+                public void error(@NonNull Exception exception) {
+                    rejectCall(call, exception);
+                }
+            };
+
+            assert implementation != null;
+            implementation.beginTransaction(options, callback);
+        } catch (Exception exception) {
+            rejectCall(call, exception);
+        }
+    }
+
+    @PluginMethod
+    public void commitTransaction(PluginCall call) {
+        try {
+            CommitTransactionOptions options = new CommitTransactionOptions(call);
+            EmptyCallback callback = new EmptyCallback() {
+                @Override
+                public void success() {
+                    resolveCall(call);
+                }
+
+                @Override
+                public void error(@NonNull Exception exception) {
+                    rejectCall(call, exception);
+                }
+            };
+
+            assert implementation != null;
+            implementation.commitTransaction(options, callback);
+        } catch (Exception exception) {
+            rejectCall(call, exception);
+        }
+    }
+
+    @PluginMethod
+    public void rollbackTransaction(PluginCall call) {
+        try {
+            RollbackTransactionOptions options = new RollbackTransactionOptions(call);
+            EmptyCallback callback = new EmptyCallback() {
+                @Override
+                public void success() {
+                    resolveCall(call);
+                }
+
+                @Override
+                public void error(@NonNull Exception exception) {
+                    rejectCall(call, exception);
+                }
+            };
+
+            assert implementation != null;
+            implementation.rollbackTransaction(options, callback);
+        } catch (Exception exception) {
+            rejectCall(call, exception);
+        }
+    }
+
+    @PluginMethod
+    public void sync(PluginCall call) {
+        rejectCallAsUnavailable(call);
+    }
+
+    private void rejectCall(@NonNull PluginCall call, @NonNull Exception exception) {
+        String message = exception.getMessage();
+        if (message == null) {
+            message = ERROR_UNKNOWN_ERROR;
+        }
+        Log.e(TAG, message, exception);
+        call.reject(message);
+    }
+
+    private void rejectCallAsUnavailable(@NonNull PluginCall call) {
+        call.unimplemented("Not available on this platform.");
+    }
+
+    private void resolveCall(@NonNull PluginCall call) {
+        call.resolve();
+    }
+
+    private void resolveCall(@NonNull PluginCall call, @Nullable Result result) {
+        if (result == null) {
+            call.resolve();
+        } else {
+            call.resolve(result.toJSObject());
+        }
+    }
+}

package/android/src/main/java/io/capawesome/capacitorjs/plugins/libsql/classes/options/BeginTransactionOptions.java

@@ -0,0 +1,28 @@
+package io.capawesome.capacitorjs.plugins.libsql.classes.options;
+
+import androidx.annotation.NonNull;
+import com.getcapacitor.PluginCall;
+
+public class BeginTransactionOptions {
+
+    @NonNull
+    private final String connectionId;
+
+    public BeginTransactionOptions(@NonNull PluginCall call) throws Exception {
+        this.connectionId = getConnectionIdFromCall(call);
+    }
+
+    @NonNull
+    public String getConnectionId() {
+        return connectionId;
+    }
+
+    @NonNull
+    private static String getConnectionIdFromCall(@NonNull PluginCall call) throws Exception {
+        String connectionId = call.getString("connectionId");
+        if (connectionId == null) {
+            throw new Exception("connectionId must be provided.");
+        }
+        return connectionId;
+    }
+}

package/android/src/main/java/io/capawesome/capacitorjs/plugins/libsql/classes/options/CommitTransactionOptions.java

@@ -0,0 +1,46 @@
+package io.capawesome.capacitorjs.plugins.libsql.classes.options;
+
+import androidx.annotation.NonNull;
+import com.getcapacitor.PluginCall;
+
+public class CommitTransactionOptions {
+
+    @NonNull
+    private final String connectionId;
+
+    @NonNull
+    private final String transactionId;
+
+    public CommitTransactionOptions(@NonNull PluginCall call) throws Exception {
+        this.connectionId = getConnectionIdFromCall(call);
+        this.transactionId = getTransactionIdFromCall(call);
+    }
+
+    @NonNull
+    public String getConnectionId() {
+        return connectionId;
+    }
+
+    @NonNull
+    public String getTransactionId() {
+        return transactionId;
+    }
+
+    @NonNull
+    private static String getConnectionIdFromCall(@NonNull PluginCall call) throws Exception {
+        String connectionId = call.getString("connectionId");
+        if (connectionId == null) {
+            throw new Exception("connectionId must be provided.");
+        }
+        return connectionId;
+    }
+
+    @NonNull
+    private static String getTransactionIdFromCall(@NonNull PluginCall call) throws Exception {
+        String transactionId = call.getString("transactionId");
+        if (transactionId == null) {
+            throw new Exception("transactionId must be provided.");
+        }
+        return transactionId;
+    }
+}

package/android/src/main/java/io/capawesome/capacitorjs/plugins/libsql/classes/options/ConnectOptions.java

@@ -0,0 +1,37 @@
+package io.capawesome.capacitorjs.plugins.libsql.classes.options;
+
+import androidx.annotation.Nullable;
+import com.getcapacitor.PluginCall;
+
+public class ConnectOptions {
+
+    @Nullable
+    private final String authToken;
+
+    @Nullable
+    private final String path;
+
+    @Nullable
+    private final String url;
+
+    public ConnectOptions(PluginCall call) throws Exception {
+        this.authToken = call.getString("authToken");
+        this.path = call.getString("path");
+        this.url = call.getString("url");
+    }
+
+    @Nullable
+    public String getAuthToken() {
+        return authToken;
+    }
+
+    @Nullable
+    public String getPath() {
+        return path;
+    }
+
+    @Nullable
+    public String getUrl() {
+        return url;
+    }
+}

package/android/src/main/java/io/capawesome/capacitorjs/plugins/libsql/classes/options/ExecuteBatchOptions.java

@@ -0,0 +1,103 @@
+package io.capawesome.capacitorjs.plugins.libsql.classes.options;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.getcapacitor.JSArray;
+import com.getcapacitor.PluginCall;
+import java.util.ArrayList;
+import java.util.List;
+import org.json.JSONArray;
+
+public class ExecuteBatchOptions {
+
+    @NonNull
+    private final String connectionId;
+
+    @NonNull
+    private final List<String> statement;
+
+    @Nullable
+    private final List<List<Object>> values;
+
+    public ExecuteBatchOptions(@NonNull PluginCall call) throws Exception {
+        this.connectionId = getConnectionIdFromCall(call);
+        this.statement = getStatementFromCall(call);
+        this.values = getValuesFromCall(call);
+    }
+
+    @NonNull
+    public String getConnectionId() {
+        return connectionId;
+    }
+
+    @NonNull
+    public List<String> getStatement() {
+        return statement;
+    }
+
+    @Nullable
+    public List<List<Object>> getValues() {
+        return values;
+    }
+
+    @NonNull
+    private static String getConnectionIdFromCall(@NonNull PluginCall call) throws Exception {
+        String connectionId = call.getString("connectionId");
+        if (connectionId == null) {
+            throw new Exception("connectionId must be provided.");
+        }
+        return connectionId;
+    }
+
+    @NonNull
+    private static List<String> getStatementFromCall(@NonNull PluginCall call) throws Exception {
+        JSArray statementArray = call.getArray("statement");
+        if (statementArray == null) {
+            throw new Exception("statement must be provided.");
+        }
+
+        List<String> statements = new ArrayList<>();
+        for (int i = 0; i < statementArray.length(); i++) {
+            Object item = statementArray.get(i);
+            if (item instanceof String) {
+                statements.add((String) item);
+            } else {
+                throw new Exception("All statements must be strings.");
+            }
+        }
+        return statements;
+    }
+
+    @Nullable
+    private List<List<Object>> getValuesFromCall(@NonNull PluginCall call) throws Exception {
+        JSArray valuesArray = call.getArray("values");
+        if (valuesArray == null) {
+            return null;
+        }
+
+        List<List<Object>> allValues = new ArrayList<>();
+        for (int i = 0; i < valuesArray.length(); i++) {
+            Object item = valuesArray.get(i);
+            if (item instanceof JSONArray) {
+                JSArray subArray = convertToJSArray((JSONArray) item);
+                List<Object> subValues = new ArrayList<>();
+                for (int j = 0; j < subArray.length(); j++) {
+                    subValues.add(subArray.get(j));
+                }
+                allValues.add(subValues);
+            } else {
+                throw new Exception("All values must be arrays.");
+            }
+        }
+        return allValues;
+    }
+
+    private JSArray convertToJSArray(JSONArray jsonArray) throws Exception {
+        JSArray jsArray = new JSArray();
+        for (int i = 0; i < jsonArray.length(); i++) {
+            Object item = jsonArray.get(i);
+            jsArray.put(item);
+        }
+        return jsArray;
+    }
+}

package/android/src/main/java/io/capawesome/capacitorjs/plugins/libsql/classes/options/ExecuteOptions.java

@@ -0,0 +1,82 @@
+package io.capawesome.capacitorjs.plugins.libsql.classes.options;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.getcapacitor.JSArray;
+import com.getcapacitor.PluginCall;
+import java.util.ArrayList;
+import java.util.List;
+
+public class ExecuteOptions {
+
+    @NonNull
+    private final String connectionId;
+
+    @NonNull
+    private final String statement;
+
+    @Nullable
+    private final String transactionId;
+
+    @Nullable
+    private final List<Object> values;
+
+    public ExecuteOptions(@NonNull PluginCall call) throws Exception {
+        this.connectionId = getConnectionIdFromCall(call);
+        this.statement = getStatementFromCall(call);
+        this.transactionId = call.getString("transactionId");
+        this.values = getValuesFromCall(call);
+    }
+
+    @NonNull
+    public String getConnectionId() {
+        return connectionId;
+    }
+
+    @NonNull
+    public String getStatement() {
+        return statement;
+    }
+
+    @Nullable
+    public String getTransactionId() {
+        return transactionId;
+    }
+
+    @Nullable
+    public List<Object> getValues() {
+        return values;
+    }
+
+    @NonNull
+    private static String getConnectionIdFromCall(@NonNull PluginCall call) throws Exception {
+        String connectionId = call.getString("connectionId");
+        if (connectionId == null) {
+            throw new Exception("connectionId must be provided.");
+        }
+        return connectionId;
+    }
+
+    @NonNull
+    private static String getStatementFromCall(@NonNull PluginCall call) throws Exception {
+        String statement = call.getString("statement");
+        if (statement == null) {
+            throw new Exception("statement must be provided.");
+        }
+        return statement;
+    }
+
+    @Nullable
+    private static List<Object> getValuesFromCall(@NonNull PluginCall call) throws Exception {
+        JSArray valuesArray = call.getArray("values");
+        if (valuesArray == null) {
+            return null;
+        }
+
+        List<Object> values = new ArrayList<>();
+        for (int i = 0; i < valuesArray.length(); i++) {
+            values.add(valuesArray.get(i));
+        }
+        return values;
+    }
+}

package/android/src/main/java/io/capawesome/capacitorjs/plugins/libsql/classes/options/QueryOptions.java

@@ -0,0 +1,82 @@
+package io.capawesome.capacitorjs.plugins.libsql.classes.options;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.getcapacitor.JSArray;
+import com.getcapacitor.PluginCall;
+import java.util.ArrayList;
+import java.util.List;
+
+public class QueryOptions {
+
+    @NonNull
+    private final String connectionId;
+
+    @NonNull
+    private final String statement;
+
+    @Nullable
+    private final String transactionId;
+
+    @Nullable
+    private final List<Object> values;
+
+    public QueryOptions(@NonNull PluginCall call) throws Exception {
+        this.connectionId = getConnectionIdFromCall(call);
+        this.statement = getStatementFromCall(call);
+        this.transactionId = call.getString("transactionId");
+        this.values = getValuesFromCall(call);
+    }
+
+    @NonNull
+    public String getConnectionId() {
+        return connectionId;
+    }
+
+    @NonNull
+    public String getStatement() {
+        return statement;
+    }
+
+    @Nullable
+    public String getTransactionId() {
+        return transactionId;
+    }
+
+    @Nullable
+    public List<Object> getValues() {
+        return values;
+    }
+
+    @NonNull
+    private static String getConnectionIdFromCall(@NonNull PluginCall call) throws Exception {
+        String connectionId = call.getString("connectionId");
+        if (connectionId == null) {
+            throw new Exception("connectionId must be provided.");
+        }
+        return connectionId;
+    }
+
+    @NonNull
+    private static String getStatementFromCall(@NonNull PluginCall call) throws Exception {
+        String statement = call.getString("statement");
+        if (statement == null) {
+            throw new Exception("statement must be provided.");
+        }
+        return statement;
+    }
+
+    @Nullable
+    private static List<Object> getValuesFromCall(@NonNull PluginCall call) throws Exception {
+        JSArray valuesArray = call.getArray("values");
+        if (valuesArray == null) {
+            return null;
+        }
+
+        List<Object> values = new ArrayList<>();
+        for (int i = 0; i < valuesArray.length(); i++) {
+            values.add(valuesArray.get(i));
+        }
+        return values;
+    }
+}

package/android/src/main/java/io/capawesome/capacitorjs/plugins/libsql/classes/options/RollbackTransactionOptions.java

@@ -0,0 +1,46 @@
+package io.capawesome.capacitorjs.plugins.libsql.classes.options;
+
+import androidx.annotation.NonNull;
+import com.getcapacitor.PluginCall;
+
+public class RollbackTransactionOptions {
+
+    @NonNull
+    private final String connectionId;
+
+    @NonNull
+    private final String transactionId;
+
+    public RollbackTransactionOptions(@NonNull PluginCall call) throws Exception {
+        this.connectionId = getConnectionIdFromCall(call);
+        this.transactionId = getTransactionIdFromCall(call);
+    }
+
+    @NonNull
+    public String getConnectionId() {
+        return connectionId;
+    }
+
+    @NonNull
+    public String getTransactionId() {
+        return transactionId;
+    }
+
+    @NonNull
+    private static String getConnectionIdFromCall(@NonNull PluginCall call) throws Exception {
+        String connectionId = call.getString("connectionId");
+        if (connectionId == null) {
+            throw new Exception("connectionId must be provided.");
+        }
+        return connectionId;
+    }
+
+    @NonNull
+    private static String getTransactionIdFromCall(@NonNull PluginCall call) throws Exception {
+        String transactionId = call.getString("transactionId");
+        if (transactionId == null) {
+            throw new Exception("transactionId must be provided.");
+        }
+        return transactionId;
+    }
+}

package/android/src/main/java/io/capawesome/capacitorjs/plugins/libsql/classes/options/SyncOptions.java

@@ -0,0 +1,28 @@
+package io.capawesome.capacitorjs.plugins.libsql.classes.options;
+
+import androidx.annotation.NonNull;
+import com.getcapacitor.PluginCall;
+
+public class SyncOptions {
+
+    @NonNull
+    private final String connectionId;
+
+    public SyncOptions(@NonNull PluginCall call) throws Exception {
+        this.connectionId = getConnectionIdFromCall(call);
+    }
+
+    @NonNull
+    public String getConnectionId() {
+        return connectionId;
+    }
+
+    @NonNull
+    private static String getConnectionIdFromCall(@NonNull PluginCall call) throws Exception {
+        String connectionId = call.getString("connectionId");
+        if (connectionId == null) {
+            throw new Exception("connectionId must be provided.");
+        }
+        return connectionId;
+    }
+}

package/android/src/main/java/io/capawesome/capacitorjs/plugins/libsql/classes/results/BeginTransactionResult.java

@@ -0,0 +1,23 @@
+package io.capawesome.capacitorjs.plugins.libsql.classes.results;
+
+import androidx.annotation.NonNull;
+import com.getcapacitor.JSObject;
+import io.capawesome.capacitorjs.plugins.libsql.interfaces.Result;
+
+public class BeginTransactionResult implements Result {
+
+    @NonNull
+    private final String transactionId;
+
+    public BeginTransactionResult(@NonNull String transactionId) {
+        this.transactionId = transactionId;
+    }
+
+    @Override
+    @NonNull
+    public JSObject toJSObject() {
+        JSObject result = new JSObject();
+        result.put("transactionId", transactionId);
+        return result;
+    }
+}