Implement SQLite functions and aggregates, update SQLite encoder and decoder APIs

gren.json

@@ -20,7 +20,11 @@
         "WebSocketServer.Connection",
         "Sqlite",
         "Sqlite.Decode",
-        "Sqlite.Encode"
+        "Sqlite.Decode.Row",
+        "Sqlite.Encode",
+        "Sqlite.Encode.Row",
+        "Sqlite.Function",
+        "Sqlite.Aggregate"
     ],
     "gren-version": "0.6.0 <= v < 0.7.0",
     "dependencies": {

src/Gren/Kernel/Sqlite.js

@@ -7,7 +7,9 @@ import Gren.Kernel.Json exposing (wrap, unwrap)
 import Json.Decode as Decode exposing (decodeValue)
 import Result exposing (isOk)
 import Sqlite.Encode as SqliteEncode exposing (toJson)
+import Sqlite.Encode.Row as SqliteEncodeRow exposing (toJson)
 import Sqlite.Decode as SqliteDecode exposing (toJson)
+import Sqlite.Aggregate as SqliteAggregate exposing (Entering, Exiting)
 import Maybe exposing (Just, Nothing)
 
 */
@@ -52,6 +54,75 @@ var _Sqlite_close = function (db) {
   });
 };
 
+var _Sqlite_function = F3(function (name, func, db) {
+  return __Scheduler_binding(function (callback) {
+    try {
+      const options = {
+        deterministic: true,
+        directOnly: true,
+        useBigIntArguments: false,
+        varargs: true,
+      };
+      const wrappedFunc = function (...args) {
+        const jsonArgs = args.map((v) => __Json_wrap(v));
+        const result = func(jsonArgs);
+        if (__Result_isOk(result)) {
+          // The triple `.a` gets the OK result, the SQLite encode
+          // value, and then grabs the actual value that needs to
+          // be returned
+          return result.a.a.a;
+        } else {
+          return null;
+        }
+      };
+      db.function(name, options, wrappedFunc);
+      callback(__Scheduler_succeed({}));
+    } catch (e) {
+      callback(_Sqlite_constructError(e));
+    }
+  });
+});
+
+var _Sqlite_aggregate = F5(function (name, init, func, result, db) {
+  return __Scheduler_binding(function (callback) {
+    try {
+      const wrappedFunc = function (direction) {
+        var env = __SqliteAggregate_Entering;
+        if (direction == "inverse") {
+          env = __SqliteAggregate_Exiting;
+        }
+        return function (state, ...args) {
+          const jsonArgs = args.map((v) => __Json_wrap(v));
+          const result = A3(func, env, state, jsonArgs);
+          if (__Result_isOk(result)) {
+            return result.a;
+          } else {
+            return null;
+          }
+        };
+      };
+      const options = {
+        deterministic: true,
+        directOnly: true,
+        useBigIntArguments: false,
+        varargs: true,
+        start: () => {
+          return init;
+        },
+        step: wrappedFunc("step"),
+        result: (state) => {
+          return result(state).a.a;
+        },
+        inverse: wrappedFunc("inverse"),
+      };
+      db.aggregate(name, options);
+      callback(__Scheduler_succeed({}));
+    } catch (e) {
+      callback(_Sqlite_constructError(e));
+    }
+  });
+});
+
 var _Sqlite_backup = F3(function (destination, pages, db) {
   return __Scheduler_binding(function (callback) {
     try {
@@ -78,7 +149,9 @@ var _Sqlite_foldl = F4(function (query, db, func, acc) {
     try {
       var acc_ = acc;
       const prepped = db.prepare(query.__$query);
-      const params = __Json_unwrap(__SqliteEncode_toJson(query.__$parameters));
+      const params = __Json_unwrap(
+        __SqliteEncodeRow_toJson(query.__$parameters),
+      );
       const rowDecoder = __SqliteDecode_toJson(query.__$rowDecoder);
 
       for (const value of prepped.iterate(params)) {
@@ -107,7 +180,9 @@ var _Sqlite_getMaybeOne = F2(function (query, db) {
   return __Scheduler_binding(function (callback) {
     try {
       const prepped = db.prepare(query.__$query);
-      const params = __Json_unwrap(__SqliteEncode_toJson(query.__$parameters));
+      const params = __Json_unwrap(
+        __SqliteEncodeRow_toJson(query.__$parameters),
+      );
       const rowDecoder = __SqliteDecode_toJson(query.__$rowDecoder);
       const iterator = prepped.iterate(params);
 
@@ -149,7 +224,9 @@ var _Sqlite_executeMany = F3(function (statement, values, db) {
       } else {
         for (const val of values) {
           lastResult = prepped.run(
-            __Json_unwrap(__SqliteEncode_toJson(statement.__$parameters(val))),
+            __Json_unwrap(
+              __SqliteEncodeRow_toJson(statement.__$parameters(val)),
+            ),
           );
         }
       }

src/Sqlite.gren

@@ -6,7 +6,9 @@ import FileSystem
 import FileSystem.Path exposing (Path)
 import Json.Decode as Decode
 import Sqlite.Decode
+import Sqlite.Decode.Row
 import Sqlite.Encode
+import Sqlite.Encode.Row
 import Task exposing (Task)
 import Gren.Kernel.Sqlite
 
@@ -103,8 +105,8 @@ runBackup (Backup { destination, pages, db }) =
 
 type alias Query value =
     { query : String
-    , parameters : Array Sqlite.Encode.Value
-    , rowDecoder : Sqlite.Decode.Decoder value
+    , parameters : Array Sqlite.Encode.Row.Value
+    , rowDecoder : Sqlite.Decode.Row.Decoder value
     }
 
 
@@ -143,7 +145,7 @@ foldl func acc db query =
 
 type alias Statement =
     { statement : String
-    , parameters : Array Sqlite.Encode.Value
+    , parameters : Array Sqlite.Encode.Row.Value
     }
 
 
@@ -178,7 +180,7 @@ executeAll db statements =
 executeForEach :
     Database
     -> { statement : String
-       , parameters : value -> Array Sqlite.Encode.Value
+       , parameters : value -> Array Sqlite.Encode.Row.Value
        }
     -> Array value
     -> Task Error ExecutionSummary

src/Sqlite/Aggregate.gren

@@ -0,0 +1,88 @@
+module Sqlite.Aggregate exposing ( .. )
+
+{-|-}
+
+import Sqlite
+import Sqlite.Decode as Decode
+import Sqlite.Encode as Encode
+import Json.Encode
+import Json.Decode
+import Task exposing ( Task )
+
+
+type Function state =
+    Function (Direction -> state -> Array Json.Encode.Value -> Result String state)
+
+
+{-|-}
+type Direction
+    = Entering
+    | Exiting
+
+
+{-|-}
+type Aggregate state
+    = Aggregate
+        { init : state
+        , function : Function state
+        , result : state -> Encode.Value
+        }
+
+
+aggregate : { init : state, function: Function state, result : state -> Encode.Value } -> Aggregate state
+aggregate { init, function, result } =
+    Aggregate
+        { init = init
+        , function = function
+        , result = result
+        }
+
+
+{-|-}
+start : (state -> Function state) -> Function state
+start func =
+    Function <| \direction state args ->
+        when func state is
+            Function innerFunc ->
+                innerFunc direction state args
+
+
+{-|-}
+arg : Decode.Decoder a -> (a -> Function state) -> Function state
+arg decoder func =
+    Function <| \direction state args ->
+        when Array.popFirst args is
+            Just { first = first, rest = rest } ->
+                when Json.Decode.decodeValue (Decode.unwrap decoder) first is
+                    Ok val ->
+                        when func val is
+                            Function innerFunc ->
+                                innerFunc direction state rest
+
+                    Err _err ->
+                        Err "decoding error"
+
+            Nothing ->
+                Err "not enough arguments passed"
+
+
+{-|-}
+return : (Direction -> state) -> Function state
+return func =
+    Function <| \direction _state args ->
+        when args is
+            [] ->
+                Ok (func direction)
+
+            many ->
+                Err "too many arguments passed"
+
+
+{-|-}
+register : String -> Sqlite.Database -> Aggregate state -> Task x {}
+register name db (Aggregate { init, function, result }) =
+    let
+        (Function unwrappedFunc) =
+            function
+    in
+    Gren.Kernel.Sqlite.aggregate name init unwrappedFunc result db