@venulog/phasing-engine-schemas 0.7.6-alpha.0 → 0.8.0-alpha.0

package/dist/parkingAreaLayer.js

@@ -0,0 +1,385 @@
+// packages/phasing-schemas/src/parkingAreaLayer.ts
+import { z } from './zod.js';
+import { createSuccessResponseSchema, createMessageDataResponseSchema } from './common.js';
+// ------------------------------
+// Layer Transform Schema
+// ------------------------------
+/**
+ * Transform data for layer positioning and rotation
+ */
+export const layerTransformSchema = z
+    .object({
+    left: z.number().openapi({
+        description: 'Horizontal position offset in pixels',
+        example: 100
+    }),
+    top: z.number().openapi({
+        description: 'Vertical position offset in pixels',
+        example: 50
+    }),
+    scaleX: z.number().positive().openapi({
+        description: 'Horizontal scale factor',
+        example: 1.2
+    }),
+    scaleY: z.number().positive().openapi({
+        description: 'Vertical scale factor',
+        example: 1.2
+    }),
+    angle: z.number().min(-180).max(180).openapi({
+        description: 'Rotation angle in degrees',
+        example: 15
+    })
+})
+    .openapi('LayerTransform');
+// ------------------------------
+// Parking Area Layer Schemas
+// ------------------------------
+/**
+ * Core parking area layer item schema matching database structure
+ */
+export const parkingAreaLayerItemSchema = z
+    .object({
+    id: z.number().int().positive().openapi({
+        description: 'Layer ID',
+        example: 1
+    }),
+    event_id: z.number().int().positive().openapi({
+        description: 'Event ID this layer belongs to',
+        example: 1
+    }),
+    name: z.string().openapi({
+        description: 'Name of the layer',
+        example: 'Ground Floor Plan'
+    }),
+    layer_order: z.number().int().nonnegative().openapi({
+        description: 'Display order (lower numbers appear first)',
+        example: 0
+    }),
+    image_url: z.string().url().openapi({
+        description: 'URL to the layer image',
+        example: 'https://storage.example.com/layers/floor-1.png'
+    }),
+    visible: z.boolean().openapi({
+        description: 'Whether the layer is visible',
+        example: true
+    }),
+    opacity: z.number().min(0).max(1).openapi({
+        description: 'Layer opacity (0.0 to 1.0)',
+        example: 0.8
+    }),
+    altitude_meters: z.number().min(-100).max(100).openapi({
+        description: 'Altitude in meters for 3D rendering (-100 to +100)',
+        example: 0
+    }),
+    transform: layerTransformSchema.openapi({
+        description: 'Transform data for layer positioning and rotation'
+    }),
+    is_active: z.boolean().openapi({
+        description: 'Whether the layer is active',
+        example: true
+    }),
+    created_at: z.string().openapi({
+        description: 'Creation timestamp (ISO 8601)',
+        example: '2026-01-06T10:30:00Z'
+    }),
+    updated_at: z.string().openapi({
+        description: 'Last update timestamp (ISO 8601)',
+        example: '2026-01-06T10:30:00Z'
+    }),
+    created_by: z.string().uuid().nullable().openapi({
+        description: 'UUID of user who created this layer',
+        example: '550e8400-e29b-41d4-a716-446655440000'
+    }),
+    updated_by: z.string().uuid().nullable().openapi({
+        description: 'UUID of user who last updated this layer',
+        example: '550e8400-e29b-41d4-a716-446655440000'
+    })
+})
+    .openapi('ParkingAreaLayerItem');
+// ------------------------------
+// Query Schemas
+// ------------------------------
+export const getLayersByEventIdParamsSchema = z
+    .object({
+    eventId: z
+        .string()
+        .min(1)
+        .transform(val => parseInt(val, 10))
+        .refine(val => !isNaN(val) && val > 0, {
+        message: 'Event ID must be a positive number'
+    })
+        .openapi({
+        description: 'The ID of the event',
+        example: '1'
+    })
+})
+    .openapi('GetLayersByEventIdParams');
+export const getLayerByIdParamsSchema = z
+    .object({
+    layerId: z
+        .string()
+        .min(1)
+        .transform(val => parseInt(val, 10))
+        .refine(val => !isNaN(val) && val > 0, {
+        message: 'Layer ID must be a positive number'
+    })
+        .openapi({
+        description: 'The ID of the layer',
+        example: '1'
+    })
+})
+    .openapi('GetLayerByIdParams');
+// ------------------------------
+// Create Layer Schemas
+// ------------------------------
+export const createLayerBodySchema = z
+    .object({
+    event_id: z.number().int().positive().openapi({
+        description: 'ID of the event',
+        example: 1
+    }),
+    name: z.string().min(1).max(255).openapi({
+        description: 'Name of the layer',
+        example: 'Ground Floor Plan'
+    }),
+    layer_order: z.number().int().nonnegative().optional().openapi({
+        description: 'Display order (auto-assigned if not provided)',
+        example: 0
+    }),
+    image_url: z.string().url().openapi({
+        description: 'URL to the layer image',
+        example: 'https://storage.example.com/layers/floor-1.png'
+    }),
+    visible: z.boolean().default(true).openapi({
+        description: 'Whether the layer is visible',
+        example: true
+    }),
+    opacity: z.number().min(0).max(1).default(1).openapi({
+        description: 'Layer opacity (0.0 to 1.0)',
+        example: 1
+    }),
+    altitude_meters: z.number().min(-100).max(100).default(0).openapi({
+        description: 'Altitude in meters for 3D rendering',
+        example: 0
+    }),
+    transform: layerTransformSchema
+        .default({ left: 0, top: 0, scaleX: 1, scaleY: 1, angle: 0 })
+        .openapi({
+        description: 'Transform data for layer positioning'
+    })
+})
+    .openapi('CreateLayerBody');
+export const createLayerDataSchema = z
+    .object({
+    layer_id: z.number().openapi({
+        description: 'ID of the created layer',
+        example: 1
+    }),
+    event_id: z.number().openapi({
+        description: 'ID of the event',
+        example: 1
+    }),
+    name: z.string().openapi({
+        description: 'Name of the layer',
+        example: 'Ground Floor Plan'
+    }),
+    layer_order: z.number().openapi({
+        description: 'Display order',
+        example: 0
+    }),
+    image_url: z.string().openapi({
+        description: 'URL to the layer image'
+    }),
+    visible: z.boolean().openapi({
+        description: 'Whether the layer is visible',
+        example: true
+    }),
+    opacity: z.number().openapi({
+        description: 'Layer opacity',
+        example: 1
+    }),
+    altitude_meters: z.number().openapi({
+        description: 'Altitude in meters',
+        example: 0
+    }),
+    transform: layerTransformSchema.openapi({
+        description: 'Transform data'
+    }),
+    created_at: z.string().openapi({
+        description: 'Timestamp when layer was created'
+    }),
+    created_by: z.string().nullable().openapi({
+        description: 'ID of the user who created the layer'
+    })
+})
+    .openapi('CreateLayerData');
+export const createLayerResponseSchema = createMessageDataResponseSchema(createLayerDataSchema, 'CreateLayerResponse', 'Layer created successfully', 'Details of the created layer');
+// ------------------------------
+// Update Layer Schemas
+// ------------------------------
+export const updateLayerParamsSchema = z
+    .object({
+    layerId: z
+        .string()
+        .min(1)
+        .transform(val => parseInt(val, 10))
+        .refine(val => !isNaN(val) && val > 0, {
+        message: 'Layer ID must be a positive number'
+    })
+        .openapi({
+        description: 'The ID of the layer to update',
+        example: '1'
+    })
+})
+    .openapi('UpdateLayerParams');
+export const updateLayerBodySchema = z
+    .object({
+    name: z.string().min(1).max(255).optional().openapi({
+        description: 'New name for the layer'
+    }),
+    layer_order: z.number().int().nonnegative().optional().openapi({
+        description: 'New display order'
+    }),
+    visible: z.boolean().optional().openapi({
+        description: 'Whether the layer is visible'
+    }),
+    opacity: z.number().min(0).max(1).optional().openapi({
+        description: 'New opacity value'
+    }),
+    altitude_meters: z.number().min(-100).max(100).optional().openapi({
+        description: 'New altitude in meters'
+    }),
+    transform: layerTransformSchema.optional().openapi({
+        description: 'New transform data'
+    }),
+    is_active: z.boolean().optional().openapi({
+        description: 'Whether the layer is active'
+    })
+})
+    .refine(data => Object.keys(data).length > 0, {
+    message: 'At least one field must be provided for update'
+})
+    .openapi('UpdateLayerBody');
+export const updateLayerDataSchema = createLayerDataSchema
+    .extend({
+    updated_at: z.string().openapi({
+        description: 'Timestamp when layer was updated'
+    }),
+    updated_by: z.string().nullable().openapi({
+        description: 'ID of the user who updated the layer'
+    })
+})
+    .omit({ layer_id: true })
+    .extend({
+    layer_id: z.number().openapi({
+        description: 'ID of the updated layer'
+    })
+})
+    .openapi('UpdateLayerData');
+export const updateLayerResponseSchema = createMessageDataResponseSchema(updateLayerDataSchema, 'UpdateLayerResponse', 'Layer updated successfully', 'Details of the updated layer');
+// ------------------------------
+// Delete Layer Schemas
+// ------------------------------
+export const deleteLayerParamsSchema = z
+    .object({
+    layerId: z
+        .string()
+        .min(1)
+        .transform(val => parseInt(val, 10))
+        .refine(val => !isNaN(val) && val > 0, {
+        message: 'Layer ID must be a positive number'
+    })
+        .openapi({
+        description: 'The ID of the layer to delete',
+        example: '1'
+    })
+})
+    .openapi('DeleteLayerParams');
+export const deleteLayerDataSchema = z
+    .object({
+    layer_id: z.number().openapi({
+        description: 'ID of the deleted layer',
+        example: 1
+    }),
+    deleted_at: z.string().openapi({
+        description: 'Timestamp when layer was deleted'
+    })
+})
+    .openapi('DeleteLayerData');
+export const deleteLayerResponseSchema = createMessageDataResponseSchema(deleteLayerDataSchema, 'DeleteLayerResponse', 'Layer deleted successfully', 'Details of the deleted layer');
+// ------------------------------
+// Get Layers Response Schemas
+// ------------------------------
+export const getLayersDataSchema = z
+    .object({
+    event_id: z.number().openapi({
+        description: 'ID of the event',
+        example: 1
+    }),
+    layers: z.array(parkingAreaLayerItemSchema).openapi({
+        description: 'List of layers for the event, ordered by layer_order'
+    }),
+    total_count: z.number().openapi({
+        description: 'Total number of layers',
+        example: 3
+    })
+})
+    .openapi('GetLayersData');
+export const getLayersResponseSchema = createSuccessResponseSchema(getLayersDataSchema, 'GetLayersResponse', 'Layers for the event');
+export const getLayerDetailResponseSchema = createSuccessResponseSchema(parkingAreaLayerItemSchema, 'GetLayerDetailResponse', 'Layer details');
+// ------------------------------
+// Bulk Upsert Layers Schemas
+// ------------------------------
+export const bulkUpsertLayersBodySchema = z
+    .object({
+    event_id: z.number().int().positive().openapi({
+        description: 'ID of the event',
+        example: 1
+    }),
+    layers: z
+        .array(z.object({
+        id: z.number().int().positive().optional().openapi({
+            description: 'Layer ID (for updates). Omit for new layers.'
+        }),
+        name: z.string().min(1).max(255).openapi({
+            description: 'Name of the layer'
+        }),
+        layer_order: z.number().int().nonnegative().openapi({
+            description: 'Display order'
+        }),
+        image_url: z.string().url().openapi({
+            description: 'URL to the layer image'
+        }),
+        visible: z.boolean().default(true),
+        opacity: z.number().min(0).max(1).default(1),
+        altitude_meters: z.number().min(-100).max(100).default(0),
+        transform: layerTransformSchema.default({
+            left: 0,
+            top: 0,
+            scaleX: 1,
+            scaleY: 1,
+            angle: 0
+        })
+    }))
+        .min(1, 'At least one layer must be provided')
+        .openapi({
+        description: 'Array of layers to create or update'
+    })
+})
+    .openapi('BulkUpsertLayersBody');
+export const bulkUpsertLayersDataSchema = z
+    .object({
+    event_id: z.number().openapi({
+        description: 'ID of the event',
+        example: 1
+    }),
+    total_upserted: z.number().openapi({
+        description: 'Total number of layers successfully upserted',
+        example: 3
+    }),
+    upserted_layers: z.array(parkingAreaLayerItemSchema).openapi({
+        description: 'Array of successfully upserted layers'
+    })
+})
+    .openapi('BulkUpsertLayersData');
+export const bulkUpsertLayersResponseSchema = createMessageDataResponseSchema(bulkUpsertLayersDataSchema, 'BulkUpsertLayersResponse', 'Layers upserted successfully', 'Details of the upserted layers');