enabled colored logs for server

Cargo.lock

@@ -1953,7 +1953,6 @@ dependencies = [
  "fern",
  "futures-util",
  "log",
- "num-traits",
  "papaya",
  "serde",
  "serde_json",

Cargo.toml

@@ -2,17 +2,10 @@
 members = ["api", "api-core", "api-proc-macro", "server", "examples/simple_producer", "examples/simple_command"]
 resolver = "2"
 
-[workspace.package]
-version = "0.1.0"
-authors = ["Sergey <me@sergeysav.com>"]
-
 [workspace.dependencies]
 actix-web = "4.12.1"
 actix-ws = "0.3.0"
 anyhow = "1.0.100"
-api = { path = "./api" }
-api-core = { path = "./api-core" }
-api-proc-macro = { path = "./api-proc-macro" }
 chrono = { version = "0.4.42" }
 derive_more = { version = "2.1.1" }
 env_logger = "0.11.8"
@@ -29,8 +22,8 @@ sqlx = "0.8.6"
 syn = "2.0.112"
 thiserror = "2.0.17"
 tokio = { version = "1.48.0" }
-tokio-stream = "0.1.17"
 tokio-test = "0.4.4"
+tokio-stream = "0.1.17"
 tokio-tungstenite = { version = "0.28.0" }
 tokio-util = "0.7.17"
 trybuild = "1.0.114"

api-core/Cargo.toml

@@ -2,8 +2,8 @@
 [package]
 name = "api-core"
 edition = "2021"
-version.workspace = true
-authors.workspace = true
+version = "0.1.0"
+authors = ["Sergey <me@sergeysav.com>"]
 
 [dependencies]
 chrono = { workspace = true, features = ["serde"] }

api-core/src/command.rs

@@ -45,16 +45,3 @@ pub trait IntoCommandDefinition: Sized {
 
     fn parse(command: Command) -> Result<Self, IntoCommandDefinitionError>;
 }
-
-impl IntoCommandDefinition for () {
-    fn create(name: String) -> CommandDefinition {
-        CommandDefinition {
-            name,
-            parameters: vec![],
-        }
-    }
-
-    fn parse(_: Command) -> Result<Self, IntoCommandDefinitionError> {
-        Ok(())
-    }
-}

api-core/src/data_type.rs

@@ -7,32 +7,6 @@ pub enum DataType {
     Float32,
     Float64,
     Boolean,
-    Int8,
-    Int16,
-    Int32,
-    Int64,
-    Unsigned8,
-    Unsigned16,
-    Unsigned32,
-    Unsigned64,
-}
-
-impl DataType {
-    pub fn get_data_length(self) -> u64 {
-        match self {
-            DataType::Float32 => 4,
-            DataType::Float64 => 8,
-            DataType::Boolean => 1,
-            DataType::Int8 => 1,
-            DataType::Int16 => 2,
-            DataType::Int32 => 4,
-            DataType::Int64 => 8,
-            DataType::Unsigned8 => 1,
-            DataType::Unsigned16 => 2,
-            DataType::Unsigned32 => 4,
-            DataType::Unsigned64 => 8,
-        }
-    }
 }
 
 pub trait ToDataType: Into<DataValue> {
@@ -50,11 +24,3 @@ macro_rules! impl_to_data_type {
 impl_to_data_type!(f32, DataType::Float32);
 impl_to_data_type!(f64, DataType::Float64);
 impl_to_data_type!(bool, DataType::Boolean);
-impl_to_data_type!(i8, DataType::Int8);
-impl_to_data_type!(i16, DataType::Int16);
-impl_to_data_type!(i32, DataType::Int32);
-impl_to_data_type!(i64, DataType::Int64);
-impl_to_data_type!(u8, DataType::Unsigned8);
-impl_to_data_type!(u16, DataType::Unsigned16);
-impl_to_data_type!(u32, DataType::Unsigned32);
-impl_to_data_type!(u64, DataType::Unsigned64);

api-core/src/data_value.rs

@@ -7,14 +7,6 @@ pub enum DataValue {
     Float32(f32),
     Float64(f64),
     Boolean(bool),
-    Int8(i8),
-    Int16(i16),
-    Int32(i32),
-    Int64(i64),
-    Unsigned8(u8),
-    Unsigned16(u16),
-    Unsigned32(u32),
-    Unsigned64(u64),
 }
 
 impl DataValue {
@@ -23,14 +15,6 @@ impl DataValue {
             DataValue::Float32(_) => DataType::Float32,
             DataValue::Float64(_) => DataType::Float64,
             DataValue::Boolean(_) => DataType::Boolean,
-            DataValue::Int8(_) => DataType::Int8,
-            DataValue::Int16(_) => DataType::Int16,
-            DataValue::Int32(_) => DataType::Int32,
-            DataValue::Int64(_) => DataType::Int64,
-            DataValue::Unsigned8(_) => DataType::Unsigned8,
-            DataValue::Unsigned16(_) => DataType::Unsigned16,
-            DataValue::Unsigned32(_) => DataType::Unsigned32,
-            DataValue::Unsigned64(_) => DataType::Unsigned64,
         }
     }
 }

api-proc-macro/Cargo.toml

@@ -2,18 +2,18 @@
 [package]
 name = "api-proc-macro"
 edition = "2021"
-version.workspace = true
-authors.workspace = true
+version = "0.1.0"
+authors = ["Sergey <me@sergeysav.com>"]
 
 [lib]
 proc-macro = true
 
 [dependencies]
-api-core = { workspace = true }
+api-core = { path = "../api-core" }
 proc-macro-error = { workspace = true }
 quote = { workspace = true }
 syn = { workspace = true }
 
 [dev-dependencies]
-api = { workspace = true }
+api = { path = "../api" }
 trybuild = { workspace = true }

api/Cargo.toml

@@ -2,12 +2,12 @@
 [package]
 name = "api"
 edition = "2021"
-version.workspace = true
-authors.workspace = true
+version = "0.1.0"
+authors = ["Sergey <me@sergeysav.com>"]
 
 [dependencies]
-api-core = { workspace = true }
-api-proc-macro = { workspace = true }
+api-core = { path = "../api-core" }
+api-proc-macro = { path = "../api-proc-macro" }
 chrono = { workspace = true, features = ["serde"] }
 derive_more = { workspace = true, features = ["from", "try_into"] }
 futures-util = { workspace = true }

api/src/client/command.rs

@@ -1,6 +1,6 @@
 use crate::client::Client;
 use crate::messages::command::CommandResponse;
-use api_core::command::{Command, CommandDefinition, CommandHeader, IntoCommandDefinition};
+use api_core::command::{CommandHeader, IntoCommandDefinition};
 use std::fmt::Display;
 use std::sync::Arc;
 use tokio::select;
@@ -15,13 +15,13 @@ impl CommandRegistry {
         Self { client }
     }
 
-    pub fn register_raw_handler<F, E: Display>(
+    pub fn register_handler<C: IntoCommandDefinition, F, E: Display>(
         &self,
-        command_definition: CommandDefinition,
+        command_name: impl Into<String>,
         mut callback: F,
     ) -> CommandHandle
     where
-        F: FnMut(Command) -> Result<String, E> + Send + 'static,
+        F: FnMut(CommandHeader, C) -> Result<String, E> + Send + 'static,
     {
         let cancellation_token = CancellationToken::new();
         let result = CommandHandle {
@@ -29,6 +29,8 @@ impl CommandRegistry {
         };
         let client = self.client.clone();
 
+        let command_definition = C::create(command_name.into());
+
         tokio::spawn(async move {
             while !cancellation_token.is_cancelled() {
                 // This would only fail if the sender closed while trying to insert data
@@ -45,10 +47,17 @@ impl CommandRegistry {
                     select!(
                         rx_value = rx.recv() => {
                             if let Some((cmd, responder)) = rx_value {
-                                let response = match callback(cmd) {
-                                    Ok(response) => CommandResponse {
-                                        success: true,
-                                        response,
+                                let header = cmd.header.clone();
+                                let response = match C::parse(cmd) {
+                                    Ok(cmd) => match callback(header, cmd) {
+                                        Ok(response) => CommandResponse {
+                                            success: true,
+                                            response,
+                                        },
+                                        Err(err) => CommandResponse {
+                                            success: false,
+                                            response: err.to_string(),
+                                        },
                                     },
                                     Err(err) => CommandResponse {
                                         success: false,
@@ -69,23 +78,6 @@ impl CommandRegistry {
 
         result
     }
-
-    pub fn register_handler<C: IntoCommandDefinition, F, E>(
-        &self,
-        command_name: impl Into<String>,
-        mut callback: F,
-    ) -> CommandHandle
-    where
-        F: FnMut(CommandHeader, C) -> Result<String, E> + Send + 'static,
-        E: Display,
-    {
-        self.register_raw_handler(C::create(command_name.into()), move |command: Command| {
-            let header = command.header.clone();
-            C::parse(command)
-                .map_err(|e| e.to_string())
-                .and_then(|cmd| callback(header, cmd).map_err(|err| err.to_string()))
-        })
-    }
 }
 
 pub struct CommandHandle {

api/src/client/mod.rs

@@ -193,6 +193,7 @@ impl Client {
                     break;
                 }
             }
+            println!("Exited Loop");
         });
 
         Ok(outer_rx)

api/src/client/telemetry.rs

@@ -319,7 +319,7 @@ mod tests {
         let (mut rx, _c, client) = create_test_client();
 
         let tlm = TelemetryRegistry::new(Arc::new(client));
-        let tlm_handle = tlm.register::<bool>("typed");
+        let tlm_handle = tlm.register::<f32>("typed");
 
         let tlm_uuid = Uuid::new_v4();
 
@@ -337,7 +337,7 @@ mod tests {
                 panic!("Expected Telemetry Definition Request")
             };
             assert_eq!(name, "typed".to_string());
-            assert_eq!(data_type, DataType::Boolean);
+            assert_eq!(data_type, DataType::Float32);
             responder
                 .send(ResponseMessage {
                     uuid: Uuid::new_v4(),
@@ -357,12 +357,15 @@ mod tests {
 
         // This should NOT block if there is space in the queue
         tlm_handle
-            .publish_now(true)
+            .publish_now(1.0f32.into())
             .now_or_never()
             .unwrap()
             .unwrap();
         // This should block as there should not be space in the queue
-        assert!(tlm_handle.publish_now(false).now_or_never().is_none());
+        assert!(tlm_handle
+            .publish_now(2.0f32.into())
+            .now_or_never()
+            .is_none());
 
         let tlm_msg = timeout(Duration::from_secs(1), rx.recv())
             .await
@@ -372,7 +375,7 @@ mod tests {
         match tlm_msg.msg.payload {
             RequestMessagePayload::TelemetryEntry(TelemetryEntry { uuid, value, .. }) => {
                 assert_eq!(uuid, tlm_uuid);
-                assert_eq!(value, DataValue::Boolean(true));
+                assert_eq!(value, DataValue::Float32(1.0f32));
             }
             _ => panic!("Expected Telemetry Entry"),
         }

examples/simple_command/Cargo.toml

@@ -5,7 +5,7 @@ edition = "2021"
 
 [dependencies]
 anyhow = { workspace = true }
-api = { workspace = true }
+api = { path = "../../api" }
 env_logger = { workspace = true }
 log = { workspace = true }
 tokio = { workspace = true, features = ["rt-multi-thread", "signal"] }

examples/simple_producer/Cargo.toml

@@ -5,7 +5,7 @@ edition = "2021"
 
 [dependencies]
 anyhow = { workspace = true }
-api = { workspace = true }
+api = { path = "../../api" }
 chrono = { workspace = true }
 env_logger = { workspace = true }
 futures-util = { workspace = true }

frontend/src/components/CommandInput.vue

@@ -3,10 +3,8 @@ import { computed, onMounted } from 'vue';
 import {
     type AnyTypeId,
     type DynamicDataType,
-    getLimits,
     isBooleanType,
     isNumericType,
-    type NumericLimits,
 } from '@/composables/dynamic.ts';
 
 const props = defineProps<{
@@ -19,100 +17,23 @@ const is_numeric = computed(() => {
     return isNumericType(props.type);
 });
 
-const numeric_limit = computed(() => {
-    if (isNumericType(props.type)) {
-        return getLimits(props.type);
-    }
-    return {
-        min: 0,
-        max: 0,
-        integer: false,
-        is_big: false,
-    } as NumericLimits;
-});
-
 const is_boolean = computed(() => {
     return isBooleanType(props.type);
 });
 
 // Initialize the parameter to some value:
 onMounted(() => {
-    if (model.value === undefined) {
-        if (is_numeric.value) {
-            if (numeric_limit.value.integer) {
-                if (numeric_limit.value.is_big) {
-                    model.value = 0n;
-                } else {
-                    model.value = 0;
-                }
-            } else {
-                model.value = 0.0;
-            }
-        } else if (is_boolean.value) {
-            model.value = false;
-        }
+    if (is_numeric.value) {
+        model.value = 0.0;
+    } else if (is_boolean.value) {
+        model.value = false;
     }
 });
-
-const value = computed({
-    get: () => {
-        if (is_numeric.value) {
-            if (numeric_limit.value.is_big) {
-                return ((model.value || 0n) as bigint).toString();
-            } else {
-                return model.value as number;
-            }
-        } else if (is_boolean.value) {
-            // Force it into a boolean
-            return !!model.value;
-        }
-        return undefined;
-    },
-    set: (value) => {
-        if (is_numeric.value) {
-            if (numeric_limit.value.is_big) {
-                let result = BigInt(value as string);
-                if (result > (numeric_limit.value.max as bigint)) {
-                    result = numeric_limit.value.max as bigint;
-                } else if (result < (numeric_limit.value.min as bigint)) {
-                    result = numeric_limit.value.min as bigint;
-                }
-                model.value = result;
-            } else {
-                let result_value = value as number;
-                if (numeric_limit.value.integer) {
-                    result_value = Math.round(value as number);
-                }
-                if (result_value > (numeric_limit.value.max as number)) {
-                    result_value = numeric_limit.value.max as number;
-                } else if (result_value < (numeric_limit.value.min as number)) {
-                    result_value = numeric_limit.value.min as number;
-                }
-                model.value = result_value;
-            }
-        } else if (is_boolean.value) {
-            model.value = value as boolean;
-        }
-    },
-});
 </script>
 
 <template>
-    <input
-        v-if="is_numeric && !numeric_limit.is_big"
-        type="number"
-        v-model="value"
-        :max="numeric_limit.max as number"
-        :min="numeric_limit.min as number"
-        :step="numeric_limit.integer ? 1 : undefined"
-    />
-    <input
-        v-else-if="is_numeric && numeric_limit.is_big"
-        type="text"
-        v-model="value"
-        pattern="-?\d+"
-    />
-    <input v-else-if="is_boolean" type="checkbox" v-model="value" />
+    <input v-if="is_numeric" type="number" v-model="model" />
+    <input v-else-if="is_boolean" type="checkbox" v-model="model" />
     <span v-else>UNKNOWN INPUT</span>
 </template>
 

frontend/src/components/CommandParameterListConfigurator.vue

@@ -2,7 +2,6 @@
 import {
     type CommandParameterData,
     type DynamicDataType,
-    getLimits,
     isBooleanType,
     isNumericType,
 } from '@/composables/dynamic.ts';
@@ -19,9 +18,7 @@ const model = defineModel<{ [key: string]: CommandParameterData }>({
     required: true,
 });
 
-const { data: command_info, error: command_error } = useCommand(
-    props.command_name,
-);
+const { data: command_info } = useCommand(props.command_name);
 
 watch([command_info], ([cmd_info]) => {
     if (cmd_info == null) {
@@ -43,8 +40,7 @@ watch([command_info], ([cmd_info]) => {
             switch (model_param_value.type) {
                 case 'constant':
                     if (
-                        (typeof model_param_value.value == 'number' ||
-                            typeof model_param_value.value == 'bigint') &&
+                        typeof model_param_value.value == 'number' &&
                         !isNumericType(param.data_type)
                     ) {
                         model_param_value = undefined;
@@ -60,14 +56,10 @@ watch([command_info], ([cmd_info]) => {
                     break;
             }
         }
-        if (model_param_value === undefined) {
+        if (!model_param_value) {
             let default_value: DynamicDataType = 0;
             if (isNumericType(param.data_type)) {
-                if (getLimits(param.data_type).is_big) {
-                    default_value = 0n;
-                } else {
-                    default_value = 0;
-                }
+                default_value = 0;
             } else if (isBooleanType(param.data_type)) {
                 default_value = false;
             }
@@ -76,21 +68,6 @@ watch([command_info], ([cmd_info]) => {
                 value: default_value,
             };
         }
-        // Perform some cleanup to remove data that shouldn't be there
-        switch (model_param_value.type) {
-            case 'constant':
-                model_param_value = {
-                    type: model_param_value.type,
-                    value: model_param_value.value,
-                };
-                break;
-            case 'input':
-                model_param_value = {
-                    type: model_param_value.type,
-                    id: model_param_value.id,
-                };
-                break;
-        }
         model_value[param.name] = model_param_value;
     }
     model.value = model_value;
@@ -114,9 +91,6 @@ watch([command_info], ([cmd_info]) => {
             ></CommandParameterDataConfigurator>
         </template>
     </template>
-    <template v-else-if="command_error">
-        <span>Error: {{ command_error }}</span>
-    </template>
     <template v-else>
         <span> Loading... </span>
     </template>

frontend/src/components/CommandSender.vue

@@ -4,7 +4,6 @@ import { ref } from 'vue';
 import CommandParameter from '@/components/CommandParameter.vue';
 import FlexDivider from '@/components/FlexDivider.vue';
 import type { DynamicDataType } from '@/composables/dynamic.ts';
-import { parseJsonString, toJsonString } from '@/composables/json.ts';
 
 const props = defineProps<{
     command: CommandDefinition | null;
@@ -28,13 +27,12 @@ async function sendCommand() {
         headers: {
             'Content-Type': 'application/json',
         },
-        body: toJsonString(params),
+        body: JSON.stringify(params),
     });
-    const text_response = await response.text();
     if (response.ok) {
-        result.value = parseJsonString(text_response);
+        result.value = await response.json();
     } else {
-        result.value = text_response;
+        result.value = await response.text();
     }
     busy.value = false;
 }

frontend/src/components/DynamicComponent.vue

@@ -7,7 +7,6 @@ import {
 } from '@/composables/dynamic.ts';
 import { computed, defineAsyncComponent, inject, type Ref, ref } from 'vue';
 import CommandParameterListConfigurator from '@/components/CommandParameterListConfigurator.vue';
-import { toJsonString } from '@/composables/json.ts';
 
 const TelemetryValue = defineAsyncComponent(
     () => import('@/components/TelemetryValue.vue'),
@@ -167,7 +166,7 @@ async function sendCommand(command: {
         headers: {
             'Content-Type': 'application/json',
         },
-        body: toJsonString(params),
+        body: JSON.stringify(params),
     });
     busy.value = false;
 }

frontend/src/components/NumericText.vue

@@ -3,7 +3,7 @@ import { computed, watch } from 'vue';
 import CopyableDynamicSpan from '@/components/CopyableDynamicSpan.vue';
 
 const props = defineProps<{
-    value: number | bigint;
+    value: number;
     max_width: number;
     copyable?: boolean;
     include_span?: boolean;
@@ -23,9 +23,6 @@ const display_value = computed(() => {
     if (props.value == 0) {
         return '0';
     }
-    if (typeof props.value === 'bigint') {
-        return props.value.toString();
-    }
     let precision = props.value.toPrecision(props.max_width - 3);
     // Chop off the last character as long as it is a 0
     while (

frontend/src/components/TelemetryLine.vue

@@ -28,7 +28,6 @@ import {
     isBooleanType,
     isNumericType,
 } from '@/composables/dynamic.ts';
-import { parseJsonString } from '@/composables/json.ts';
 
 const props = defineProps<{
     data: string;
@@ -139,14 +138,7 @@ watch(
                 const res = await fetch(
                     `/api/tlm/history/${uuid}?from=${min_x.toISOString()}&to=${max_x.toISOString()}&resolution=${data_min_sep.value}`,
                 );
-                const text_response = await res.text();
-                if (!res.ok) {
-                    console.error(text_response);
-                    return;
-                }
-                const response = parseJsonString(
-                    text_response,
-                ) as TelemetryDataItem[];
+                const response = (await res.json()) as TelemetryDataItem[];
                 for (const data_item of response) {
                     const val_t = Date.parse(data_item.timestamp);
                     const raw_item_val = data_item.value[

frontend/src/components/TelemetryValue.vue

@@ -6,8 +6,6 @@ import {
     type WebsocketHandle,
 } from '@/composables/websocket.ts';
 import NumericText from '@/components/NumericText.vue';
-import BooleanText from '@/components/BooleanText.vue';
-import { isBooleanType, isNumericType } from '@/composables/dynamic.ts';
 
 const max_update_rate = 50; // ms
 const default_update_rate = 200; // ms
@@ -35,23 +33,30 @@ const value = websocket.value.listen_to_telemetry(
 const is_data_present = computed(() => {
     return value.value != null;
 });
+
+const numeric_data = computed(() => {
+    const val = value.value;
+    if (val) {
+        const type = telemetry_data.value!.data_type;
+        const item_val = val.value[type];
+        if (typeof item_val == 'number') {
+            return item_val;
+        }
+    }
+    return null;
+});
 </script>
 
 <template>
     <span v-if="!is_data_present" v-bind="$attrs"> No Data </span>
     <template v-else>
         <NumericText
-            v-if="isNumericType(telemetry_data!.data_type)"
+            v-if="numeric_data"
             v-bind="$attrs"
-            :value="value!.value[telemetry_data!.data_type]"
+            :value="numeric_data"
             :max_width="10"
             include_span
         ></NumericText>
-        <BooleanText
-            v-else-if="isBooleanType(telemetry_data!.data_type)"
-            v-bind="$attrs"
-            :value="value!.value[telemetry_data!.data_type]"
-        ></BooleanText>
         <span v-else v-bind="$attrs">
             Cannot Display Data of Type {{ telemetry_data!.data_type }}
         </span>

frontend/src/composables/command.ts

@@ -1,7 +1,6 @@
 import { ref, toValue, watchEffect } from 'vue';
 import { type MaybeRefOrGetter } from 'vue';
 import type { AnyTypeId } from '@/composables/dynamic.ts';
-import { parseJsonString } from '@/composables/json.ts';
 
 export interface CommandParameterDefinition {
     name: string;
@@ -21,14 +20,8 @@ export function useAllCommands() {
     watchEffect(async () => {
         try {
             const res = await fetch(`/api/cmd`);
-            const text_response = await res.text();
-            if (res.ok) {
-                data.value = parseJsonString(text_response);
-                error.value = null;
-            } else {
-                data.value = null;
-                error.value = text_response;
-            }
+            data.value = await res.json();
+            error.value = null;
         } catch (e) {
             data.value = null;
             error.value = e;
@@ -48,14 +41,8 @@ export function useCommand(name: MaybeRefOrGetter<string>) {
 
         try {
             const res = await fetch(`/api/cmd/${name_value}`);
-            const text_response = await res.text();
-            if (res.ok) {
-                data.value = parseJsonString(text_response);
-                error.value = null;
-            } else {
-                data.value = null;
-                error.value = text_response;
-            }
+            data.value = await res.json();
+            error.value = null;
         } catch (e) {
             data.value = null;
             error.value = e;

frontend/src/composables/dynamic.ts

@@ -1,74 +1,5 @@
-export const NumericTypes = [
-    'Float32',
-    'Float64',
-    'Int8',
-    'Int16',
-    'Int32',
-    'Int64',
-    'Unsigned8',
-    'Unsigned16',
-    'Unsigned32',
-    'Unsigned64',
-] as const;
+export const NumericTypes = ['Float32', 'Float64'] as const;
 export type NumericTypeId = (typeof NumericTypes)[number];
-
-export type NumericLimits = {
-    min: number | bigint;
-    max: number | bigint;
-    integer: boolean;
-    is_big: boolean;
-};
-
-export function getLimits(numeric_type: NumericTypeId): NumericLimits {
-    switch (numeric_type) {
-        case 'Float32':
-            return {
-                integer: false,
-                is_big: false,
-                min: -3.40282347e38,
-                max: 3.40282347e38,
-            };
-        case 'Float64':
-            return {
-                integer: false,
-                is_big: false,
-                min: -1.7976931348623157e308,
-                max: 1.7976931348623157e308,
-            };
-        case 'Int8':
-            return { integer: true, is_big: false, min: -128, max: 127 };
-        case 'Int16':
-            return { integer: true, is_big: false, min: -32768, max: 32767 };
-        case 'Int32':
-            return {
-                integer: true,
-                is_big: false,
-                min: -2147483648,
-                max: 2147483647,
-            };
-        case 'Int64':
-            return {
-                integer: true,
-                is_big: true,
-                min: -9223372036854775808n,
-                max: 9223372036854775807n,
-            };
-        case 'Unsigned8':
-            return { integer: true, is_big: false, min: 0, max: 255 };
-        case 'Unsigned16':
-            return { integer: true, is_big: false, min: 0, max: 65535 };
-        case 'Unsigned32':
-            return { integer: true, is_big: false, min: 0, max: 4294967295 };
-        case 'Unsigned64':
-            return {
-                integer: true,
-                is_big: true,
-                min: 0,
-                max: 18446744073709551615n,
-            };
-    }
-}
-
 export const BooleanTypes = ['Boolean'] as const;
 export type BooleanTypeId = (typeof BooleanTypes)[number];
 export const AnyTypes = [...NumericTypes, ...BooleanTypes] as const;
@@ -81,7 +12,7 @@ export function isBooleanType(type: AnyTypeId): type is BooleanTypeId {
     return BooleanTypes.some((it) => it == type);
 }
 
-export type DynamicDataType = bigint | number | boolean;
+export type DynamicDataType = number | boolean;
 
 export type CommandParameterData =
     | {

frontend/src/composables/json.ts

@@ -1,26 +0,0 @@
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function toJsonString(data: any, pretty: boolean = false): string {
-    return JSON.stringify(
-        data,
-        (_key, value) => {
-            if (typeof value == 'bigint') {
-                // @ts-expect-error TS2339
-                return JSON.rawJSON(value.toString());
-            }
-            return value;
-        },
-        pretty ? 4 : undefined,
-    );
-}
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function parseJsonString(data: string): any {
-    // @ts-expect-error TS2345, TS7006
-    return JSON.parse(data, (key, value, context) => {
-        if (key === 'Int64' || key == 'Unsigned64') {
-            // Or use the constructor of your custom high-precision number library
-            return BigInt(context.source);
-        }
-        return value;
-    });
-}

frontend/src/composables/telemetry.ts

@@ -1,7 +1,6 @@
 import { ref, toValue, watchEffect } from 'vue';
 import { type MaybeRefOrGetter } from 'vue';
 import type { AnyTypeId } from '@/composables/dynamic.ts';
-import { parseJsonString } from '@/composables/json.ts';
 
 export interface TelemetryDefinition {
     uuid: string;
@@ -17,14 +16,8 @@ export function useAllTelemetry() {
     watchEffect(async () => {
         try {
             const res = await fetch(`/api/tlm/info`);
-            const text_response = await res.text();
-            if (res.ok) {
-                data.value = parseJsonString(text_response);
-                error.value = null;
-            } else {
-                data.value = null;
-                error.value = text_response;
-            }
+            data.value = await res.json();
+            error.value = null;
         } catch (e) {
             data.value = null;
             error.value = e;
@@ -44,14 +37,8 @@ export function useTelemetry(name: MaybeRefOrGetter<string>) {
 
         try {
             const res = await fetch(`/api/tlm/info/${name_value}`);
-            const text_response = await res.text();
-            if (res.ok) {
-                data.value = parseJsonString(text_response);
-                error.value = null;
-            } else {
-                data.value = null;
-                error.value = text_response;
-            }
+            data.value = await res.json();
+            error.value = null;
         } catch (e) {
             data.value = null;
             error.value = e;

frontend/src/composables/websocket.ts

@@ -12,7 +12,6 @@ import {
 } from 'vue';
 import type { TelemetryDefinition } from '@/composables/telemetry';
 import { onDocumentVisibilityChange } from '@/composables/document.ts';
-import { parseJsonString, toJsonString } from '@/composables/json.ts';
 
 export interface TelemetryDataItem {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -72,7 +71,7 @@ export class WebsocketHandle {
             }
         });
         this.websocket.addEventListener('message', (event) => {
-            const message = parseJsonString(event.data);
+            const message = JSON.parse(event.data);
             if (message['TlmValue']) {
                 const tlm_value = message['TlmValue'] as TlmValue;
                 const listeners = this.on_telem_value.get(tlm_value.uuid);
@@ -127,7 +126,7 @@ export class WebsocketHandle {
             ([uuid_value, connected, enabled, min_sep, live_value]) => {
                 if (connected && enabled && uuid_value && live_value) {
                     this.websocket?.send(
-                        toJsonString({
+                        JSON.stringify({
                             RegisterTlmListener: {
                                 uuid: uuid_value,
                                 minimum_separation_ms: min_sep,
@@ -143,7 +142,7 @@ export class WebsocketHandle {
                     this.on_telem_value.get(uuid_value)?.push(callback_fn);
                     onWatcherCleanup(() => {
                         this.websocket?.send(
-                            toJsonString({
+                            JSON.stringify({
                                 UnregisterTlmListener: {
                                     uuid: uuid_value,
                                 },

frontend/src/panels/panel.ts

@@ -1,6 +1,5 @@
 import type { RouteLocationRaw } from 'vue-router';
 import { ref, type Ref, watchEffect } from 'vue';
-import { parseJsonString } from '@/composables/json.ts';
 
 export enum PanelHeirarchyType {
     LEAF = 'leaf',
@@ -62,11 +61,7 @@ export function usePanelHeirarchy(): Ref<PanelHeirarchyChildren> {
     watchEffect(async () => {
         try {
             const res = await fetch(`/api/panel`);
-            if (!res.ok) {
-                console.error('Failed to fetch panels');
-                return;
-            }
-            const data = parseJsonString(await res.text());
+            const data = await res.json();
 
             const server_panels: PanelHeirarchyFolder = {
                 name: 'Server Panels',

frontend/src/views/PanelEditorView.vue

@@ -1,8 +1,7 @@
 <script setup lang="ts">
 import DynamicComponent from '@/components/DynamicComponent.vue';
 import type { OptionalDynamicComponentData } from '@/composables/dynamic.ts';
-import { ref, useTemplateRef, watchEffect } from 'vue';
-import { parseJsonString, toJsonString } from '@/composables/json.ts';
+import { ref, watchEffect } from 'vue';
 
 const data = ref<OptionalDynamicComponentData>({ type: 'none' });
 
@@ -20,11 +19,7 @@ const unselect = () => {
 
 async function reload_panel_list() {
     const res = await fetch(`/api/panel`);
-    if (!res.ok) {
-        console.error('Failed to reload panel list');
-        return;
-    }
-    panel_list.value = parseJsonString(await res.text());
+    panel_list.value = await res.json();
 }
 watchEffect(reload_panel_list);
 
@@ -33,9 +28,10 @@ async function load(id: string) {
     load_screen.value = false;
     loading.value = true;
     const panel_data = await fetch(`/api/panel/${id}`);
-    const panel_text_value = await panel_data.text();
-    const panel_json_value = parseJsonString(panel_text_value);
-    data.value = panel_json_value['data'] as OptionalDynamicComponentData;
+    const panel_json_value = await panel_data.json();
+    data.value = JSON.parse(
+        panel_json_value['data'],
+    ) as OptionalDynamicComponentData;
     panel_name.value = panel_json_value['name'];
     panel_id.value = id;
     loading.value = false;
@@ -54,33 +50,28 @@ async function save() {
     if (panel_id_value) {
         const res = await fetch(`/api/panel/${panel_id_value}`, {
             method: 'PUT',
-            body: toJsonString({
+            body: JSON.stringify({
                 name: panel_name.value,
-                data: data.value,
+                data: JSON.stringify(data.value),
             }),
             headers: {
                 'Content-Type': 'application/json',
             },
         });
-        await res.text();
-        // TODO: Handle failures
+        await res.json();
     } else {
         const res = await fetch('/api/panel', {
             method: 'POST',
-            body: toJsonString({
+            body: JSON.stringify({
                 name: panel_name.value,
-                data: data.value,
+                data: JSON.stringify(data.value),
             }),
             headers: {
                 'Content-Type': 'application/json',
             },
         });
-        const text_response = await res.text();
-        if (res.ok) {
-            const uuid = parseJsonString(text_response);
-            panel_id.value = uuid as string;
-        }
-        // TODO: Handle failures
+        const uuid = await res.json();
+        panel_id.value = uuid as string;
     }
     loading.value = false;
 }
@@ -89,35 +80,6 @@ async function showLoadScreen() {
     load_screen.value = true;
     await reload_panel_list();
 }
-
-function download() {
-    const file = new Blob([toJsonString(data.value, true)], {
-        type: 'application/json',
-    });
-    const a = document.createElement('a');
-    const url = URL.createObjectURL(file);
-    a.href = url;
-    a.download = panel_name.value.toLowerCase().replace(' ', '_') + '.json';
-    document.body.appendChild(a);
-    a.click();
-    setTimeout(function () {
-        document.body.removeChild(a);
-        window.URL.revokeObjectURL(url);
-    }, 0);
-}
-
-const upload_input = useTemplateRef<HTMLInputElement>('upload-input');
-
-function upload() {
-    upload_input.value!.click();
-}
-
-async function onUpload() {
-    const input = upload_input.value!;
-    const file = input.files![0];
-    const file_data = await file.text();
-    data.value = parseJsonString(file_data);
-}
 </script>
 
 <template>
@@ -150,15 +112,6 @@ async function onUpload() {
                     {{ panel_id ? 'Save' : 'New' }}
                 </button>
                 <button @click.prevent.stop="showLoadScreen">Load</button>
-                <button @click.prevent.stop="download">Download</button>
-                <input
-                    ref="upload-input"
-                    class="file"
-                    type="file"
-                    accept="application/json"
-                    @change="onUpload"
-                />
-                <button @click.prevent.stop="upload">Upload</button>
             </div>
             <div id="inspector" class="column"></div>
         </div>
@@ -173,8 +126,4 @@ async function onUpload() {
     height: 100vh;
     background: variables.$dark-background-color;
 }
-
-input.file {
-    display: none;
-}
 </style>

frontend/src/views/PanelView.vue

@@ -6,7 +6,6 @@ import type {
 } from '@/composables/dynamic.ts';
 import { computed, provide, ref, watchEffect } from 'vue';
 import { useRoute } from 'vue-router';
-import { parseJsonString } from '@/composables/json.ts';
 
 const route = useRoute();
 
@@ -22,10 +21,10 @@ provide('inputs', inputs);
 
 watchEffect(async () => {
     const panel_data = await fetch(`/api/panel/${id.value}`);
-    const panel_text_value = await panel_data.text();
-    panel.value = parseJsonString(panel_text_value)[
-        'data'
-    ] as OptionalDynamicComponentData;
+    const panel_json_value = await panel_data.json();
+    panel.value = JSON.parse(
+        panel_json_value['data'],
+    ) as OptionalDynamicComponentData;
 });
 </script>
 

server/Cargo.toml

@@ -2,20 +2,19 @@
 [package]
 name = "server"
 edition = "2021"
-version.workspace = true
-authors.workspace = true
+version = "0.1.0"
+authors = ["Sergey <me@sergeysav.com>"]
 
 [dependencies]
 actix-web = { workspace = true, features = [ ] }
 actix-ws = { workspace = true }
 anyhow = { workspace = true }
-api = { workspace = true }
+api = { path = "../api" }
 chrono = { workspace = true }
 derive_more = { workspace = true, features = ["from"] }
 fern = { workspace = true, features = ["colored"] }
 futures-util = { workspace = true }
 log = { workspace = true }
-num-traits = { workspace = true }
 papaya = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }

server/src/command/service.rs

@@ -11,7 +11,6 @@ use api::messages::command::{Command, CommandDefinition, CommandHeader, CommandR
 use api::messages::ResponseMessage;
 use chrono::Utc;
 use log::error;
-use num_traits::FromPrimitive;
 use papaya::HashMap;
 use std::collections::HashMap as StdHashMap;
 use tokio::sync::oneshot;
@@ -103,34 +102,10 @@ impl CommandManagementService {
             let Some(param_value) = parameters.get(&parameter.name) else {
                 return Err(MisingParameter(parameter.name.clone()));
             };
-            let Some(Some(param_value)) = (match parameter.data_type {
-                DataType::Float32 => param_value
-                    .as_f64()
-                    .map(|v| Some(DataValue::Float32(v as f32))),
-                DataType::Float64 => param_value.as_f64().map(DataValue::Float64).map(Some),
-                DataType::Boolean => param_value.as_bool().map(DataValue::Boolean).map(Some),
-                DataType::Int8 => param_value
-                    .as_i64()
-                    .map(|v| Some(DataValue::Int8(i8::from_i64(v)?))),
-                DataType::Int16 => param_value
-                    .as_i64()
-                    .map(|v| Some(DataValue::Int16(i16::from_i64(v)?))),
-                DataType::Int32 => param_value
-                    .as_i64()
-                    .map(|v| Some(DataValue::Int32(i32::from_i64(v)?))),
-                DataType::Int64 => param_value.as_i64().map(|v| Some(DataValue::Int64(v))),
-                DataType::Unsigned8 => param_value
-                    .as_u64()
-                    .map(|v| Some(DataValue::Unsigned8(u8::from_u64(v)?))),
-                DataType::Unsigned16 => param_value
-                    .as_u64()
-                    .map(|v| Some(DataValue::Unsigned16(u16::from_u64(v)?))),
-                DataType::Unsigned32 => param_value
-                    .as_u64()
-                    .map(|v| Some(DataValue::Unsigned32(u32::from_u64(v)?))),
-                DataType::Unsigned64 => {
-                    param_value.as_u64().map(|v| Some(DataValue::Unsigned64(v)))
-                }
+            let Some(param_value) = (match parameter.data_type {
+                DataType::Float32 => param_value.as_f64().map(|v| DataValue::Float32(v as f32)),
+                DataType::Float64 => param_value.as_f64().map(DataValue::Float64),
+                DataType::Boolean => param_value.as_bool().map(DataValue::Boolean),
             }) else {
                 return Err(WrongParameterType {
                     name: parameter.name.clone(),

server/src/http/api/cmd.rs

@@ -3,7 +3,7 @@ use crate::http::error::HttpServerResultError;
 use actix_web::{get, post, web, Responder};
 use std::sync::Arc;
 
-#[post("/cmd/{name:[\\.\\w\\d/_-]+}")]
+#[post("/cmd/{name:[\\w\\d/_-]+}")]
 pub(super) async fn send_command(
     command_service: web::Data<Arc<CommandManagementService>>,
     name: web::Path<String>,
@@ -23,16 +23,12 @@ pub(super) async fn get_all(
     Ok(web::Json(command_service.get_commands()?))
 }
 
-#[get("/cmd/{name:[\\.\\w\\d/_-]+}")]
+#[get("/cmd/{name:[\\w\\d/_-]+}")]
 pub(super) async fn get_one(
     command_service: web::Data<Arc<CommandManagementService>>,
     name: web::Path<String>,
 ) -> Result<impl Responder, HttpServerResultError> {
     Ok(web::Json(
-        command_service
-            .get_command_definition(&name.to_string())
-            .ok_or_else(|| HttpServerResultError::CmdNotFound {
-                cmd: name.to_string(),
-            })?,
+        command_service.get_command_definition(&name.to_string()),
     ))
 }

server/src/http/api/panels.rs

@@ -9,7 +9,7 @@ use uuid::Uuid;
 #[derive(Deserialize)]
 struct CreateParam {
     name: String,
-    data: serde_json::Value,
+    data: String,
 }
 
 #[derive(Deserialize)]

server/src/http/api/tlm.rs

@@ -9,7 +9,7 @@ use std::time::Duration;
 use tokio::time::timeout;
 use uuid::Uuid;
 
-#[get("/tlm/info/{name:[\\.\\w\\d/_-]+}")]
+#[get("/tlm/info/{name:[\\w\\d/_-]+}")]
 pub(super) async fn get_tlm_definition(
     data: web::Data<Arc<TelemetryManagementService>>,
     name: web::Path<String>,

server/src/http/error.rs

@@ -23,8 +23,6 @@ pub enum HttpServerResultError {
     PanelUuidNotFound { uuid: Uuid },
     #[error(transparent)]
     Command(#[from] crate::command::error::Error),
-    #[error("Command Not Found: {cmd}")]
-    CmdNotFound { cmd: String },
 }
 
 impl ResponseError for HttpServerResultError {
@@ -38,7 +36,6 @@ impl ResponseError for HttpServerResultError {
             HttpServerResultError::InternalError { .. } => StatusCode::INTERNAL_SERVER_ERROR,
             HttpServerResultError::PanelUuidNotFound { .. } => StatusCode::NOT_FOUND,
             HttpServerResultError::Command(inner) => inner.status_code(),
-            HttpServerResultError::CmdNotFound { .. } => StatusCode::NOT_FOUND,
         }
     }
     fn error_response(&self) -> HttpResponse {

server/src/http/mod.rs

@@ -9,7 +9,7 @@ use crate::http::backend::setup_backend;
 use crate::http::websocket::setup_websocket;
 use crate::panels::PanelService;
 use crate::telemetry::management_service::TelemetryManagementService;
-use actix_web::middleware::{Compress, Logger};
+use actix_web::middleware::Logger;
 use actix_web::{web, App, HttpServer};
 use log::info;
 use std::sync::Arc;
@@ -36,7 +36,6 @@ pub async fn setup(
             .service(web::scope("/backend").configure(setup_backend))
             .service(web::scope("/ws").configure(setup_websocket))
             .service(web::scope("/api").configure(setup_api))
-            .wrap(Compress::default())
             .wrap(Logger::default())
     })
     .bind("localhost:8080")?

server/src/panels/mod.rs

@@ -14,12 +14,10 @@ impl PanelService {
         Self { pool }
     }
 
-    pub async fn create(&self, name: &str, data: &serde_json::Value) -> anyhow::Result<Uuid> {
+    pub async fn create(&self, name: &str, data: &str) -> anyhow::Result<Uuid> {
         let id = Uuid::new_v4();
         let id_string = id.to_string();
 
-        let data = serde_json::to_string(data)?;
-
         let mut transaction = self.pool.begin().await?;
 
         let _ = sqlx::query!(

server/src/panels/panel.rs

@@ -12,12 +12,11 @@ pub struct Panel {
     #[sqlx(flatten)]
     #[serde(flatten)]
     pub header: PanelRequired,
-    #[sqlx(json)]
-    pub data: serde_json::Value,
+    pub data: String,
 }
 
 #[derive(Default, Clone, Serialize, Deserialize)]
 pub struct PanelUpdate {
     pub name: Option<String>,
-    pub data: Option<serde_json::Value>,
+    pub data: Option<String>,
 }

server/src/telemetry/history.rs

@@ -196,17 +196,9 @@ impl HistorySegmentFile {
         // Write all the values
         for value in &data.values {
             match value {
-                DataValue::Float32(value) => file.write_data(*value)?,
-                DataValue::Float64(value) => file.write_data(*value)?,
-                DataValue::Boolean(value) => file.write_data(*value)?,
-                DataValue::Int8(value) => file.write_data(*value)?,
-                DataValue::Int16(value) => file.write_data(*value)?,
-                DataValue::Int32(value) => file.write_data(*value)?,
-                DataValue::Int64(value) => file.write_data(*value)?,
-                DataValue::Unsigned8(value) => file.write_data(*value)?,
-                DataValue::Unsigned16(value) => file.write_data(*value)?,
-                DataValue::Unsigned32(value) => file.write_data(*value)?,
-                DataValue::Unsigned64(value) => file.write_data(*value)?,
+                DataValue::Float32(value) => file.write_data::<f32>(*value)?,
+                DataValue::Float64(value) => file.write_data::<f64>(*value)?,
+                DataValue::Boolean(value) => file.write_data::<bool>(*value)?,
             }
         }
 
@@ -340,20 +332,20 @@ impl HistorySegmentFile {
     }
 
     fn read_telemetry_item(&mut self, telemetry_data_type: DataType) -> anyhow::Result<DataValue> {
-        self.file_position += telemetry_data_type.get_data_length() as i64;
-        Ok(match telemetry_data_type {
-            DataType::Float32 => self.file.read_data::<f32>()?.into(),
-            DataType::Float64 => self.file.read_data::<f64>()?.into(),
-            DataType::Boolean => self.file.read_data::<bool>()?.into(),
-            DataType::Int8 => self.file.read_data::<i8>()?.into(),
-            DataType::Int16 => self.file.read_data::<i16>()?.into(),
-            DataType::Int32 => self.file.read_data::<i32>()?.into(),
-            DataType::Int64 => self.file.read_data::<i64>()?.into(),
-            DataType::Unsigned8 => self.file.read_data::<u8>()?.into(),
-            DataType::Unsigned16 => self.file.read_data::<u16>()?.into(),
-            DataType::Unsigned32 => self.file.read_data::<u32>()?.into(),
-            DataType::Unsigned64 => self.file.read_data::<u64>()?.into(),
-        })
+        match telemetry_data_type {
+            DataType::Float32 => {
+                self.file_position += 4;
+                Ok(DataValue::Float32(self.file.read_data::<f32>()?))
+            }
+            DataType::Float64 => {
+                self.file_position += 8;
+                Ok(DataValue::Float64(self.file.read_data::<f64>()?))
+            }
+            DataType::Boolean => {
+                self.file_position += 1;
+                Ok(DataValue::Boolean(self.file.read_data::<bool>()?))
+            }
+        }
     }
 
     fn get_telemetry_item(
@@ -361,7 +353,11 @@ impl HistorySegmentFile {
         index: u64,
         telemetry_data_type: DataType,
     ) -> anyhow::Result<DataValue> {
-        let item_length = telemetry_data_type.get_data_length();
+        let item_length = match telemetry_data_type {
+            DataType::Float32 => 4,
+            DataType::Float64 => 8,
+            DataType::Boolean => 1,
+        };
         let desired_position =
             Self::HEADER_LENGTH + self.length * Self::TIMESTAMP_LENGTH + index * item_length;
         let seek_amount = desired_position as i64 - self.file_position;

server/src/telemetry/management_service.rs

@@ -3,6 +3,8 @@ use crate::telemetry::data_item::TelemetryDataItem;
 use crate::telemetry::definition::TelemetryDefinition;
 use crate::telemetry::history::{TelemetryHistory, TelemetryHistoryService};
 use anyhow::bail;
+use api::data_type::DataType;
+use api::data_value::DataValue;
 use api::messages::telemetry_definition::{
     TelemetryDefinitionRequest, TelemetryDefinitionResponse,
 };
@@ -142,7 +144,11 @@ impl TelemetryManagementService {
             bail!("Telemetry Item Not Found");
         };
 
-        let expected_type = tlm_item.value.to_data_type();
+        let expected_type = match &tlm_item.value {
+            DataValue::Float32(_) => DataType::Float32,
+            DataValue::Float64(_) => DataType::Float64,
+            DataValue::Boolean(_) => DataType::Boolean,
+        };
         if expected_type != tlm_data.data.definition.data_type {
             bail!("Data Type Mismatch");
         };