fix: unsafe unwraps

quadratic-connection/src/server.rs

@@ -137,11 +137,6 @@ pub(crate) fn app(state: State) -> Result<Router> {
         // unprotected routes without state
         .route("/health", get(healthcheck))
         //
-        // don't show authorization header in logs
-        .layer(SetSensitiveHeadersLayer::new(
-            sensitive_headers.iter().cloned(),
-        ))
-        //
         // cache control - disable client side caching
         .layer(map_response(|mut response: Response| async move {
             let headers = response.headers_mut();
@@ -160,7 +155,12 @@ pub(crate) fn app(state: State) -> Result<Router> {
         .layer(
             TraceLayer::new_for_http()
                 .make_span_with(DefaultMakeSpan::default().include_headers(true)),
-        );
+        )
+        //
+        // don't show authorization header in logs
+        .layer(SetSensitiveHeadersLayer::new(
+            sensitive_headers.iter().cloned(),
+        ));
 
     Ok(app)
 }

quadratic-files/src/server.rs

@@ -186,7 +186,7 @@
                     tracing::info!(
                         r#"{{ "files_to_process_in_pubsub": "{:#?}", "last_processed_file_time": "{:#?}" }}"#,
                         stats.files_to_process_in_pubsub,
-                        stats.last_processed_file_time,
+                        stats.last_processed_file_time.unwrap_or_default(),
                     );
                 }
             }

quadratic-rust-shared/src/sql/mssql_connection.rs

@@ -101,7 +101,9 @@
         if let Some(username) = &self.username {
             config.authentication(AuthMethod::sql_server(
                 username,
-                self.password.as_ref().unwrap(),
+                self.password.as_deref().ok_or_else(|| {
+                    SharedError::Sql(SqlError::Connect("Password is required".into()))
+                })?,
             ));
         }
 
@@ -242,7 +244,9 @@
                 ColumnData::F64(_) => convert_mssql_type::<f64, _>(column_data, ArrowType::Float64),
                 ColumnData::Numeric(_) => {
                     convert_mssql_type::<Decimal, _>(column_data, |decimal| {
-                        ArrowType::BigDecimal(BigDecimal::from_str(&decimal.to_string()).unwrap())
+                        ArrowType::BigDecimal(
+                            BigDecimal::from_str(&decimal.to_string()).unwrap_or_default(),
+                        )
                     })
                 }
                 ColumnData::Guid(_) => convert_mssql_type::<Uuid, _>(column_data, ArrowType::Uuid),

quadratic-shared/typesAndSchemasConnections.ts

@@ -51,8 +51,24 @@ export const ConnectionTypeDetailsPostgresSchema = z.object({
   password: z.string().optional().transform(transformEmptyStringToUndefined),
 });
 export const ConnectionTypeDetailsMysqlSchema = ConnectionTypeDetailsPostgresSchema;
-export const ConnectionTypeDetailsMssqlSchema = ConnectionTypeDetailsPostgresSchema.extend({
+export const ConnectionTypeDetailsMssqlSchema = z.object({
+  host: z.string().min(1, { message: 'Required' }),
+  port: z
+    .string()
+    .min(1, { message: 'Required' })
+    .refine(
+      (port) => {
+        const portNumber = Number(port);
+        if (isNaN(portNumber)) return false;
+        return portNumber >= 0 && portNumber <= 65535;
+      },
+      {
+        message: 'Port must be a valid number between 0 and 65535',
+      }
+    ),
   database: z.string().optional(),
+  username: z.string().min(1, { message: 'Required' }),
+  password: z.string().min(1, { message: 'Required' }),
 });
 export const ConnectionTypeDetailsSnowflakeSchema = z.object({
   account_identifier: z.string().min(1, { message: 'Required' }),