Feat: post api boxes

app/lib/device-transform.ts

@@ -0,0 +1,102 @@
+import { type Device, type Sensor } from '~/schema';
+
+export type DeviceWithSensors = Device & {
+  sensors: Sensor[];
+};
+
+export type TransformedDevice = {
+  _id: string;
+  name: string;
+  description: string | null;
+  image: string | null;
+  link: string | null;
+  grouptag: string[];
+  exposure: string | null;
+  model: string | null;
+  latitude: number;
+  longitude: number;
+  useAuth: boolean | null;
+  public: boolean | null;
+  status: string | null;
+  createdAt: Date;
+  updatedAt: Date;
+  expiresAt: Date | null;
+  userId: string;
+  sensorWikiModel?: string | null;
+  currentLocation: {
+    type: "Point";
+    coordinates: number[];
+    timestamp: string;
+  };
+  lastMeasurementAt: string;
+  loc: Array<{
+    type: "Feature";
+    geometry: {
+      type: "Point";
+      coordinates: number[];
+      timestamp: string;
+    };
+  }>;
+  integrations: {
+    mqtt: {
+      enabled: boolean;
+    };
+  };
+  sensors: Array<{
+    _id: string;
+    title: string | null;
+    unit: string | null;
+    sensorType: string | null;
+    lastMeasurement: {
+      value: string;
+      createdAt: string;
+    } | null;
+  }>;
+};
+
+/**
+ * Transforms a device with sensors from database format to openSenseMap API format
+ * @param box - Device object with sensors from database
+ * @returns Transformed device in openSenseMap API format
+ * 
+ * Note: Converts lastMeasurement.value from number to string to match API specification
+ */
+export function transformDeviceToApiFormat(
+  box: DeviceWithSensors
+): TransformedDevice {
+  const { id, tags, sensors, ...rest } = box;
+  const timestamp = box.updatedAt.toISOString();
+  const coordinates = [box.longitude, box.latitude];
+
+  return {
+    _id: id,
+    grouptag: tags || [],
+    ...rest,
+    currentLocation: {
+      type: "Point",
+      coordinates,
+      timestamp
+    },
+    lastMeasurementAt: timestamp,
+    loc: [{
+      geometry: { type: "Point", coordinates, timestamp },
+      type: "Feature"
+    }],
+    integrations: { mqtt: { enabled: false } },
+    sensors: sensors?.map((sensor) => ({
+      _id: sensor.id,
+      title: sensor.title,
+      unit: sensor.unit,
+      sensorType: sensor.sensorType,
+      lastMeasurement: sensor.lastMeasurement 
+        ? {
+            createdAt: sensor.lastMeasurement.createdAt,
+            // Convert numeric values to string to match API specification
+            value: typeof sensor.lastMeasurement.value === 'number' 
+              ? String(sensor.lastMeasurement.value) 
+              : sensor.lastMeasurement.value,
+          }
+        : null,
+    })) || [],
+  };
+}

app/lib/devices-service.server.ts

@@ -1,9 +1,24 @@
-import { Device, User } from '~/schema'
+import { z } from 'zod'
 import {
 	deleteDevice as deleteDeviceById,
 } from '~/models/device.server'
 import { verifyLogin } from '~/models/user.server'
-import { z } from 'zod'
+import { type Device, type User } from '~/schema'
+
+export const CreateBoxSchema = z.object({
+	name: z.string().min(1, "Name is required").max(100, "Name too long"),
+	exposure: z.enum(["indoor", "outdoor", "mobile", "unknown"]).optional().default("unknown"),
+	location: z.array(z.number()).length(2, "Location must be [longitude, latitude]"),
+	grouptag: z.array(z.string()).optional().default([]),
+	model: z.enum(["homeV2Lora", "homeV2Ethernet", "homeV2Wifi", "senseBox:Edu", "luftdaten.info", "Custom"]).optional().default("Custom"),
+	sensors: z.array(z.object({
+		id: z.string(),
+		icon: z.string().optional(),
+		title: z.string().min(1, "Sensor title is required"),
+		unit: z.string().min(1, "Sensor unit is required"),
+		sensorType: z.string().min(1, "Sensor type is required"),
+	})).optional().default([]),
+});
 
 export const BoxesQuerySchema = z.object({
 	format: z.enum(["json", "geojson"]  ,{

app/models/device.server.ts

@@ -1,29 +1,38 @@
 import { point } from '@turf/helpers'
-import { eq, sql, desc, ilike, inArray, arrayContains, and } from 'drizzle-orm'
+import { eq, sql, desc, ilike, arrayContains, and } from 'drizzle-orm'
 import { type Point } from 'geojson'
 import { drizzleClient } from '~/db.server'
 import { device, location, sensor, type Device, type Sensor } from '~/schema'
 
+const BASE_DEVICE_COLUMNS = {
+	id: true,
+	name: true,
+	description: true,
+	image: true,
+	link: true,
+	tags: true,
+	exposure: true,
+	model: true,
+	latitude: true,
+	longitude: true,
+	status: true,
+	createdAt: true,
+	updatedAt: true,
+	expiresAt: true,
+	sensorWikiModel: true,
+} as const;
+
+const DEVICE_COLUMNS_WITH_SENSORS = {
+	...BASE_DEVICE_COLUMNS,
+	useAuth: true,
+	public: true,
+	userId: true,
+} as const;
+
 export function getDevice({ id }: Pick<Device, 'id'>) {
 	return drizzleClient.query.device.findFirst({
 		where: (device, { eq }) => eq(device.id, id),
-		columns: {
-			createdAt: true,
-			description: true,
-			exposure: true,
-			id: true,
-			image: true,
-			latitude: true,
-			longitude: true,
-			link: true,
-			model: true,
-			name: true,
-			sensorWikiModel: true,
-			status: true,
-			updatedAt: true,
-			tags: true,
-			expiresAt: true,
-		},
+		columns: BASE_DEVICE_COLUMNS,
 		with: {
 			user: {
 				columns: {
@@ -109,15 +118,9 @@ export function deleteDevice({ id }: Pick<Device, 'id'>) {
 export function getUserDevices(userId: Device['userId']) {
 	return drizzleClient.query.device.findMany({
 		where: (device, { eq }) => eq(device.userId, userId),
-		columns: {
-			id: true,
-			name: true,
-			latitude: true,
-			longitude: true,
-			exposure: true,
-			model: true,
-			createdAt: true,
-			updatedAt: true,
+		columns: DEVICE_COLUMNS_WITH_SENSORS,
+		with: {
+			sensors: true,
 		},
 	})
 }
@@ -356,9 +359,7 @@ interface BuildWhereClauseOptions {
   ) {
 	const { minimal, limit } = opts;
 	const { includeColumns, whereClause } = buildWhereClause(opts);
-
 	columns = minimal ? MINIMAL_COLUMNS : { ...DEFAULT_COLUMNS, ...columns };
-
 	relations = {
 	  ...relations,
 	  ...includeColumns
@@ -388,7 +389,11 @@ export async function createDevice(deviceData: any, userId: string) {
 					tags: deviceData.tags,
 					userId: userId,
 					name: deviceData.name,
+					description: deviceData.description,
+					image: deviceData.image,
+					link: deviceData.link,
 					exposure: deviceData.exposure,
+					public: deviceData.public ?? false,
 					expiresAt: deviceData.expiresAt
 						? new Date(deviceData.expiresAt)
 						: null,
@@ -400,18 +405,31 @@ export async function createDevice(deviceData: any, userId: string) {
 			if (!createdDevice) {
 				throw new Error('Failed to create device.')
 			}
-			// Add sensors in the same transaction
+
+			// Add sensors in the same transaction and collect them
+			const createdSensors = [];
 			if (deviceData.sensors && Array.isArray(deviceData.sensors)) {
 				for (const sensorData of deviceData.sensors) {
-					await tx.insert(sensor).values({
-						title: sensorData.title,
-						unit: sensorData.unit,
-						sensorType: sensorData.sensorType,
-						deviceId: createdDevice.id, // Reference the created device ID
-					})
+					const [newSensor] = await tx.insert(sensor)
+						.values({
+							title: sensorData.title,
+							unit: sensorData.unit,
+							sensorType: sensorData.sensorType,
+							deviceId: createdDevice.id, // Reference the created device ID
+						})
+						.returning();
+
+					if (newSensor) {
+						createdSensors.push(newSensor);
+					}
 				}
 			}
-			return createdDevice
+
+			// Return device with sensors
+			return {
+				...createdDevice,
+				sensors: createdSensors
+			};
 		})
 		return newDevice
 	} catch (error) {

app/models/sensor.server.ts

@@ -75,7 +75,6 @@ export async function getSensorsWithLastMeasurement(
   count?: number,
 ): Promise<SensorWithLatestMeasurement | SensorWithLatestMeasurement[]>;
 
-
 export async function getSensorsWithLastMeasurement(
   deviceId: Sensor["deviceId"],
   sensorId: Sensor["id"] | undefined = undefined,