@adapt-toolkit/mufl 0.8.0

package/mufl_stdlib/lists.mm

@@ -0,0 +1,84 @@
+    // library lists { 
+    //     empty IS NIL. 
+    //     head IS 1. 
+    //     tail IS 2. 
+
+    //     cons IS fn (h, t) = ( head -> h, tail -> t ). 
+    //     make_list IS fn (array, start) {
+    //         IF (array start) == NIL THEN { _return empty. }
+    //         _return (cons (array start) (make_list array (start + 1) )).  
+    //     }
+
+    //     print_list IS fn (l, f, sep) { 
+    //         IF (l == empty) THEN { _return "". }
+            
+    //         ret IS NEW(). 
+    //         ret() -> (f (l head)).
+    //         IF (l tail != empty) THEN { ret() -> ret() + sep. } 
+    //         ret() -> ret() + (print_list (l tail) f sep).
+    //     }
+    // }
+
+// library lists
+// {
+//     empty = NIL.
+    
+//     cons = fn (h, t
+// }
+library lists
+{
+generic module generic_lists takes _Type
+{
+    metadef value_type: _Type.
+    metadef head_type: value_type. 
+    metadef tail_type: ($head -> value_type, $tail -> any)+.
+    metadef list_type: tail_type.
+
+    empty = NIL.
+    cons = fn (h: value_type, t: tail_type) = ($head -> h, $tail -> t).
+    head = fn (l: list_type) -> head_type+ {
+        if l == NIL {
+            return empty.
+        }
+        return l? $head.
+    }
+
+    tail = fn (l: list_type) -> list_type {
+        if l == NIL {
+            return empty.
+        }
+        return (l? $tail) as list_type.
+    }
+
+    hidden
+    {
+        make_list_ex = fn (array: value_type[], idx: int) -> list_type {
+            if idx == (_count array|) {
+                return empty.
+            }
+            return cons (array idx|) (make_list_ex array (idx + 1)) as list_type.
+        }
+    }
+
+    make_list = fn (array: value_type[]) -> list_type {
+        return make_list_ex array 0.
+    }
+
+    print_list = fn (l: list_type, functor: (value_type->str), sep: str) -> str {
+        if (l == empty) {
+            return "".
+        }
+
+        if (tail l != empty) {
+            return (functor (head l|)) + sep + (print_list (tail l) functor sep) as str.
+        } else {
+            return functor (head l|).
+        }
+    }
+}
+
+module int_list instantiates generic_lists with int.
+module str_list instantiates generic_lists with str.
+module bool_list instantiates generic_lists with bool.
+module any_list instantiates generic_lists with any.
+}

package/mufl_stdlib/permissions.mm

@@ -0,0 +1,219 @@
+library permissions
+{
+
+/*
+    Motivation:
+    In the context of authorization service, we sometimes need to give external actors (services, users) permission to access certain parts of the code
+    This library manages these access rules.
+
+    When user grants some permissions to the external actors, safereference is generated and given to the actor.
+    This safereference serves as an identificator of the external actor in this context.
+    It is obvious, that the same actor might have several safereferences with different permission bundles.
+    For example, we authorize the service S to read our person information - name, surname and date of birth.
+    Then, later, we want to give access to this server to create a backup data in our secret storage, so we have to give this service a permission to access secret storage.
+    It is obvious, that these two permission bundles should be managed separately, which is why to distinct safe refs should be generated
+
+
+    Each permission should potentially have payload. For example, in the previous example, we don't want to give access to the entire secret storage. This access should be scoped.
+    This library have no information about internal structure of the secret storage, which is why this additional permission checks should be executed on the next level.
+
+    This library simply checks the general permission ignoring the particular payload.
+
+
+    Please note that this implementation allows for sharing safe references. Meaning that permissions could be shared with other parties by sharing the safe reference.
+    Any additional logic could be implemented on top of this module.
+    For example, if you want to make the permissions non sharable, you can associate each safe reference with packet id of the counterparty.
+
+    library custom_permission_manager loads library permissions
+    {
+        module my_permissions instantiates permissions::creator with <$a, $b, $c>.
+
+        users_by_saferefs is (saferef ->> global_id) = (,).
+
+        // implement API functions for permissions manager storing addionally the packet id of the party you are granting permission to
+    }
+
+*/
+
+generic module creator takes P
+{
+    // in case P type is enumerated set of strings, for the ease of use of this module, we have to allow strings values as argument types in functions
+    // because our type system does not know  about the P type in the moment of a function call and treats the string arguments as str type
+    // permissions_id_t is equivalent to P
+    // permissions_id_extended_t is equivalent in case P is not enum, otherwise it is P || str
+
+
+    metablock
+    {
+        permissions_id_t = P.
+        permissions_id_extended_t = P.
+        if (P $is_enumerated_set)
+        {
+            permissions_id_extended_t -> meta::combinations::disjunction (P, meta::basics::string).
+        }
+    }
+
+
+
+    /*
+    module grant exposes API for granting permissions
+    it stores all the granted permissions to all the packets
+    */
+    module grant
+    {
+        // actual permission type - includes the type of the permission and payload data
+        metadef permission_t: (
+            $type -> P,
+            $payload -> any
+        ).
+
+        metadef permission_registration_t: permissions_id_extended_t || permission_t.
+
+        // bundle of permissions issues to some external party - indexed by the permission type
+        metadef permissions_bundle_t: P ->> permission_t.
+
+        hidden
+        {
+            metadef granted_permissions_t: (saferef ->> permissions_bundle_t).
+
+            granted_permissions is granted_permissions_t = (,).
+        }
+
+        fn get_permissions_bundle (sr: saferef) = (granted_permissions sr).
+
+        fn add_permissions (sr: saferef, permissions: permission_registration_t[])
+        {
+            abort "Unknown saferef passed to the permissions::grant::add_permissions" when granted_permissions sr == NIL.
+            sc permissions -- (-> permission)
+            {
+                if (_typeof permission == "IMMUTABLE_DICTIONARY" && (permission as any) $type != NIL)
+                {
+                    granted_permissions sr (((permission as permission_t) $type) safe permissions_id_t) -> permission as permission_t.
+                }
+                else
+                {
+                    granted_permissions sr (permission safe permissions_id_t) -> ($type -> permission safe permissions_id_t, $payload -> NIL).
+                }
+            }
+        }
+
+        fn revoke_permissions (sr: saferef, permissions: permissions_id_extended_t[])
+        {
+            sc permissions -- (-> permission)
+            {
+                delete granted_permissions sr (permission safe permissions_id_t).
+                // granted_permissions sr (permission safe permissions_id_t) -> NIL. // remove the permission from the bundle
+            }
+        }
+
+        fn register_permissions_bundle (permissions: permission_registration_t[]) -> saferef
+        {
+            sr = _new_safe_ref().
+            granted_permissions sr -> (,) as permissions_bundle_t.
+            add_permissions sr permissions.
+            return sr.
+        }
+
+    }
+
+    /*
+    module check exposes API for permissions verification
+    */
+    module check
+    {
+
+        metadef logical_t: ($type -> <$at_least_one, $all>, $permissions -> any). // we don't support recursive types, treat this any as check_permission_t
+        metadef check_permission_t: logical_t || permissions_id_extended_t.
+
+        fn at_least_one (permissions: check_permission_t || check_permission_t[]) -> logical_t
+        {
+            return ($type -> $at_least_one, $permissions -> permissions).
+        }
+
+        fn all (permissions: check_permission_t || check_permission_t[]) -> logical_t
+        {
+            return ($type -> $all, $permissions -> permissions).
+        }
+
+
+        hidden
+        {
+
+            fn check_single_permission (permissions_bundle: grant::permissions_bundle_t, permission: P) -> bool
+            {
+                return permissions_bundle permission != NIL.
+            }
+
+            fn check_ex (permissions_bundle: grant::permissions_bundle_t, required_permissions: check_permission_t || check_permission_t[]) -> bool
+            {
+                if (_count required_permissions == 0) // empty immutable dictionary is passed -> nothing to check
+                {
+                    return TRUE.
+                }
+
+                if (_typeof required_permissions == "STRING")
+                {
+                    single_permission = required_permissions safe permissions_id_t.
+
+                    // check single permission
+                    return check_single_permission permissions_bundle single_permission.
+
+                }
+
+                if ((required_permissions as any) 0 != NIL) // array is passed
+                {
+                    // simple array is always treated as all logical operator.. this is a simple syntax sugar to enable omitting the all function call
+                    return check_ex permissions_bundle (all required_permissions).
+                }
+
+                // at this point required_permissions have to be logical operator
+                logical_op = required_permissions safe logical_t.
+
+                if (logical_op $type == $all)
+                {
+                    sc logical_op $permissions -- (-> permission)
+                    {
+                        if (check_ex permissions_bundle (permission safe (check_permission_t || check_permission_t[])) != TRUE)
+                        {
+                            return FALSE.
+                        }
+                    }
+                    return TRUE.
+                }
+                else // at least one
+                {
+                    sc logical_op $permissions -- (-> permission)
+                    {
+                        if (check_ex permissions_bundle (permission safe (check_permission_t || check_permission_t[])) == TRUE)
+                        {
+                            return TRUE.
+                        }
+                    }
+                    return FALSE.
+                }
+           }
+
+        }
+
+
+        /*
+            Please note that due to the implementation, if permissions to check are passed as array it should be indexed from 0
+        */
+        fn check (sr: saferef, safe required_permissions: check_permission_t || check_permission_t[]) -> bool
+        {
+            granted_permissions_bundle = grant::get_permissions_bundle sr.
+            if (granted_permissions_bundle == NIL)
+            {
+                return FALSE.
+            }
+
+            return check_ex granted_permissions_bundle? required_permissions.
+        }
+
+
+    }
+
+}
+
+}
+

package/mufl_stdlib/platform_type_id.mm

@@ -0,0 +1,20 @@
+pragma langserver path="."
+library platform_type_id loads library current_transaction_info uses transactions 
+{
+    trn readonly _get_platform_type_id _ { 
+        current_transaction_info::validate_origin (transaction::envelope::origin::user,).
+        return _get_platform_type_id (). 
+    }
+    trn readonly _get_nitro_platform_type_id _ { 
+        current_transaction_info::validate_origin (transaction::envelope::origin::user,).
+        return _get_nitro_platform_type_id(). 
+    }
+    trn readonly _get_wasm_platform_type_id _ { 
+        current_transaction_info::validate_origin (transaction::envelope::origin::user,).
+        return _get_wasm_platform_type_id(). 
+    }
+    trn readonly _get_native_platform_type_id _ { 
+        current_transaction_info::validate_origin (transaction::envelope::origin::user,).
+        return _get_native_platform_type_id(). 
+    }
+}

package/mufl_stdlib/random.mm

@@ -0,0 +1,50 @@
+library random
+{
+
+hidden
+{
+
+fn construct_bytes_rec (l: int) -> bin
+{
+    if (l == 0)
+    {
+        return 0x.
+    }
+    
+    slice = _hex_string_to_binary << _new_id "".
+    if (_binlen slice >= l)
+    {
+        return slice @! (0 .. l - 1).
+    }
+
+    return slice + (construct_bytes_rec (l - (_binlen slice))) as bin.
+}
+
+}
+
+
+fn generate_random_bytes (len: int) -> bin
+{
+    return construct_bytes_rec len.
+}
+
+
+fn generate_random_int (_) -> int 
+{
+    bytes = generate_random_bytes 4.
+
+    res = bytes 3.
+
+    res -> res + (bytes 2) * 10.
+    res -> res + (bytes 1) * 100.
+    res -> res + (bytes 0) * 1000.
+
+    return res.
+}
+
+fn generate_random_int_from_interval (min: int, max: int) -> int 
+{
+    return min + (generate_random_int() % (max - min)).
+}
+
+}

package/mufl_stdlib/rslt.mm

@@ -0,0 +1,32 @@
+library rslt
+{
+
+
+generic module creator takes types
+{
+  metablock {
+    ok_t = types $type_list 0.
+    err_t = types $type_list 1.
+  }
+
+  metadef rslt_t: (
+    $is_ok -> bool,
+    $err -> err_t+,
+    $ok -> ok_t+
+  ).
+
+  fn get_ok(v: rslt_t) -> ok_t {
+    abort "Called 'get_ok' on Err result." when v $ok == NIL.
+    return (v $ok)?.
+  }
+
+  fn get_err(v: rslt_t) -> err_t {
+    abort "Called 'get_err' on Ok result." when v $err == NIL.
+    return (v $err)?.
+  }
+
+  fn ok(data: ok_t) -> rslt_t = ($is_ok -> TRUE, $err -> NIL, $ok -> data).
+  fn err(data: err_t) -> rslt_t = ($is_ok -> FALSE, $err -> data, $ok -> NIL).
+}
+
+}

package/mufl_stdlib/transaction_message_decoder.mm

@@ -0,0 +1,22 @@
+library transaction_message_decoder loads library current_transaction_info uses transactions
+{
+    trn readonly describe_message
+    message: transaction::type {
+        current_transaction_info::validate_origin (transaction::envelope::origin::user,).
+
+        raw_message is any = message.
+        message_decoded is any = NIL.
+        if raw_message $trn {
+            message_decoded -> raw_message $trn.
+        } elif raw_message $encrypted_message {
+            message_decoded -> ($name -> "::encrypted_message::", $targ -> NIL).
+        } else {
+            message_decoded -> raw_message.
+        }
+
+        if !(_is_test_mode()) {
+            message_decoded $targ -> "Arguments are hidden.".
+        }
+        return message_decoded.
+    }
+}

package/mufl_stdlib/transaction_queue.mm

@@ -0,0 +1,60 @@
+library transaction_queue loads library transaction {
+  /*
+      Assume, there is transaction 'trn2', result of which should be processed
+     after transaction 'trn2' is executed. For example, container sends some
+     data to the another container as a result of 'trn2', but this data is
+     depending on another transaction 'trn1'. In this case, we can add result of
+     the 'trn2' to the buffer and access this buffer in 'trn2'.
+
+
+      Pseudo code example:
+      trn trn2 ... {
+          buffered_transactions_cb = fn (_) { ...) =
+     [transaction::action::send ..., transactions::send ...] } // 1 buffer::add 'trn1'
+     buffered_transactions_cb. RETURN transaction::success [].
+      }
+
+      trn trn1 ... {
+          RETURN transaction::success []. // callback 1 is called here and
+     transactions returned from the callback are added to the result of this
+     transaction
+      }
+
+      For now transaction name is being used as transaction identifier, but
+     maybe it's better to use a hash of the transaction with arguments. But in
+     this case we don't always know arguments of the transaction. For example,
+     when we want to process result after we receive signature from authorizing
+     container, we cannot know signature before we recieved it...
+  */
+    metadef t_actions_creator_func: (any->transaction::action::type[]).
+    
+    hidden {
+        transactions_buffer IS (str->> t_actions_creator_func[]) = (,).
+
+    }
+
+    add = fn (trn_name: str, actions_creator: t_actions_creator_func) {
+        if transactions_buffer trn_name != NIL { 
+            transactions_buffer trn_name (_count(transactions_buffer trn_name |)|) ->actions_creator.
+        } else { 
+            transactions_buffer trn_name -> [actions_creator].
+        }
+    }
+
+    get = fn (trn_name : str) -> transaction::action::type[] {
+        res is transaction::action::type[] = [].
+        if transactions_buffer trn_name != NIL { 
+            creators = (transactions_buffer trn_name |).
+            sc creators -- ( -> creator) { 
+                actions = creator().
+                sc actions -- ( -> action) { 
+                    res (_count res|) -> action.
+                } 
+            }
+            
+            transactions_buffer -> transactions_buffer'(trn_name -> delete). 
+        } 
+        
+        return res.
+  }
+}

package/mufl_stdlib/vector.mm

@@ -0,0 +1,115 @@
+library vector {
+    generic module vector takes value_type {
+        metadef type: (
+            $push_back -> (value_type -> any),
+            $at -> (int -> value_type),
+            $set -> (int -> value_type -> any),
+            $pop_back -> (any -> any),
+            $size -> (any -> int),
+            $for_each -> ((value_type -> any) -> nil),
+            $map -> ((value_type -> value_type) -> any),
+            $select_by_indices -> ((int*>int) -> any),
+            $merge -> ((int*>value_type) -> any),
+            $get -> (any -> value_type[])
+        ).
+
+        construct = fn (init: int*>value_type) -> type
+        {
+            array is value_type[] = [].
+            sc init -- ( -> val) {
+                array (_count array|) -> val.
+            }
+
+            push_back = fn (old_vector: value_type[], value: value_type)
+            {
+                old_vector (_count old_vector|) -> value.
+                return construct old_vector.
+            }
+
+            get = fn (vec: value_type[], _) = vec.
+
+            pop_back = fn (old_vector: value_type[], _)
+            {
+                abort "Trying to pop from empty vector." when (_count old_vector|) == 0.
+                new_vector is value_type[] = [].
+                sc old_vector -- (i -> it) ?? i < ((_count old_vector|) - 1 ) {
+                    new_vector (_count new_vector|) -> it.
+                }
+                return construct new_vector.
+            }
+
+            at = fn (vec: value_type[], idx: int) -> value_type
+            {
+                abort "Internal error. Trying to get uninitialized element of vector." when idx >= (_count vec|).
+                return (vec idx)?.
+            }
+
+            set = fn (old_vector: value_type[], idx: int, value: value_type) -> any
+            {
+                abort "Internal error. Trying to set uninitialized element of vector." when idx > (_count old_vector|).
+                old_vector idx -> value.
+                return construct old_vector.
+            }
+
+            size = fn (vec: value_type[], _) = (_count vec|).
+
+            for_each = fn (vec: value_type[], f: (value_type -> any)) -> nil
+            {
+                sc vec -- ( -> it) {
+                    f it.
+                }
+                return NIL.
+            }
+
+            select_by_indices = fn (old_vector: value_type[], indices: int*>int) -> any
+            {
+                new_vector is value_type[] = [].
+                sc indices -- ( -> idx) {
+                    abort "Index out of bounds." when idx >= (_count old_vector|).
+                    new_vector (_count new_vector|) -> (old_vector idx)?.
+                }
+                return construct new_vector.
+            }
+
+            merge = fn (vec: value_type[], new_vals: int*>value_type) -> any
+            {
+                sc new_vals -- ( -> val) {
+                    vec (_count vec|) -> val.
+                }
+                return construct vec.
+            }
+
+            map = fn (vec: value_type[], f: (value_type -> value_type)) -> any
+            {
+                new_vector is value_type[] = [].
+                sc vec -- (idx -> it) {
+                    new_vector idx -> f it.
+                }
+                return construct new_vector.
+            }
+
+            return (
+                $push_back -> push_back array,
+                $pop_back -> pop_back array,
+                $get -> get array,
+                $at -> at array,
+                $set -> set array,
+                $size -> size array,
+                $for_each -> for_each array,
+                $map -> map array,
+                $merge -> merge array,
+                $select_by_indices -> select_by_indices array
+            ).
+        }
+
+        empty = fn (_) -> type
+        {
+            init is value_type[] = [].
+            return construct init.
+        }
+
+        identity = fn (v: any) = (v as type).
+    }
+
+    module int_vector instantiates vector with int.
+}

package/mufl_stdlib/verification.mm

@@ -0,0 +1,35 @@
+library verification loads library current_transaction_info uses transactions
+{
+
+    hidden
+    {
+        callbacks is global_id->>any = (,).
+
+        get_cb = fn (id: global_id)
+        {
+            res = callbacks id abort "Verification callback not found. ID: " + id when is NIL.
+            delete callbacks id.
+            return res?.
+        }
+
+    }
+
+
+    add_verification = fn (cb) -> global_id
+    {
+        id = _new_id "Verification id.".
+
+        abort "Internal error: Verification with generated id already exists." when callbacks id != NIL.
+
+        callbacks id -> cb.
+        return id.
+    }
+
+    trn accept
+    _:($id->id: global_id)
+    {
+        current_transaction_info::validate_origin (transaction::envelope::origin::user,).
+        return get_cb id NIL.
+    }
+
+}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@adapt-toolkit/mufl",
+  "version": "0.8.0",
+  "type": "module",
+  "license": "SEE LICENSE IN LICENSE",
+  "description": "The MUFL toolchain: prebuilt `mufl` (REPL) and `mufl-compile` (compiler) engine binaries plus the MUFL stdlib, meta, and transactions trees they need at run time. Linux x64 only; the binaries are proprietary (AEFL) — see LICENSE and NOTICE.",
+  "bin": {
+    "mufl": "./bin/mufl.js",
+    "mufl-compile": "./bin/mufl-compile.js"
+  },
+  "exports": {
+    "./paths": "./lib/paths.js",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "bin",
+    "lib",
+    "prebuilds",
+    "mufl_stdlib",
+    "meta",
+    "transactions",
+    "LICENSE",
+    "LICENSE.fsl",
+    "NOTICE",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "test": "node --test"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/adapt-toolkit/adapt.git",
+    "directory": "typescript/mufl"
+  },
+  "homepage": "https://github.com/adapt-toolkit/adapt/tree/main/typescript/mufl#readme",
+  "bugs": {
+    "url": "https://github.com/adapt-toolkit/adapt/issues"
+  },
+  "author": "Adapt Framework Solutions Ltd."
+}