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

package/dist/parkingAreaAccess.js

@@ -0,0 +1,466 @@
+// packages/phasing-schemas/src/parkingAreaAccess.ts
+import { z } from './zod.js';
+import { createSuccessResponseSchema, createMessageDataResponseSchema } from './common.js';
+// ------------------------------
+// Access Point Geometry Schemas
+// ------------------------------
+/**
+ * A point in 2D space using percentage-based coordinates (0-100)
+ * relative to the site plan image dimensions
+ */
+export const accessPointSchema = z
+    .object({
+    x: z.number().min(0).max(100).openapi({
+        description: 'X coordinate as percentage of image width (0-100)',
+        example: 25.5
+    }),
+    y: z.number().min(0).max(100).openapi({
+        description: 'Y coordinate as percentage of image height (0-100)',
+        example: 30.2
+    })
+})
+    .openapi('AccessPoint');
+/**
+ * GeoJSON LineString for access point geometry
+ */
+export const geoJsonLineStringSchema = z
+    .object({
+    type: z.literal('LineString').openapi({
+        description: 'GeoJSON geometry type',
+        example: 'LineString'
+    }),
+    coordinates: z
+        .array(z.tuple([z.number(), z.number()]))
+        .min(2)
+        .openapi({
+        description: 'GeoJSON LineString coordinates (array of [x, y] points)',
+        example: [
+            [25.5, 30.2],
+            [35.5, 30.2]
+        ]
+    })
+})
+    .openapi('GeoJsonLineString');
+// ------------------------------
+// Parking Area Access Schemas
+// ------------------------------
+/**
+ * Core parking area access item schema matching database structure
+ */
+export const parkingAreaAccessItemSchema = z
+    .object({
+    id: z.number().int().positive().openapi({
+        description: 'Access point ID',
+        example: 1
+    }),
+    event_id: z.number().int().positive().openapi({
+        description: 'Event ID this access point belongs to',
+        example: 1
+    }),
+    name: z.string().openapi({
+        description: 'Name of the access point',
+        example: 'Main Entrance'
+    }),
+    geometry: geoJsonLineStringSchema.nullable().openapi({
+        description: 'GeoJSON LineString geometry for the access point'
+    }),
+    width_meters: z.number().positive().nullable().openapi({
+        description: 'Width of the access point in meters',
+        example: 6.5
+    }),
+    height_meters: z.number().positive().nullable().openapi({
+        description: 'Height of the access point in meters (for gates/barriers)',
+        example: 4.2
+    }),
+    is_active: z.boolean().openapi({
+        description: 'Whether the access point 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 access point',
+        example: '550e8400-e29b-41d4-a716-446655440000'
+    }),
+    updated_by: z.string().uuid().nullable().openapi({
+        description: 'UUID of user who last updated this access point',
+        example: '550e8400-e29b-41d4-a716-446655440000'
+    })
+})
+    .openapi('ParkingAreaAccessItem');
+/**
+ * Access point with linked parking areas
+ */
+export const parkingAreaAccessWithLinksSchema = parkingAreaAccessItemSchema
+    .extend({
+    linked_parking_areas: z
+        .array(z.object({
+        parking_area_id: z.number().int().positive(),
+        parking_area_name: z.string().nullable()
+    }))
+        .openapi({
+        description: 'List of parking areas linked to this access point'
+    })
+})
+    .openapi('ParkingAreaAccessWithLinks');
+// ------------------------------
+// Query Schemas
+// ------------------------------
+export const getAccessesByEventIdParamsSchema = 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('GetAccessesByEventIdParams');
+export const getAccessByIdParamsSchema = z
+    .object({
+    accessId: z
+        .string()
+        .min(1)
+        .transform(val => parseInt(val, 10))
+        .refine(val => !isNaN(val) && val > 0, {
+        message: 'Access point ID must be a positive number'
+    })
+        .openapi({
+        description: 'The ID of the access point',
+        example: '1'
+    })
+})
+    .openapi('GetAccessByIdParams');
+// ------------------------------
+// Create Access Point Schemas
+// ------------------------------
+export const createAccessBodySchema = 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 access point',
+        example: 'Main Entrance'
+    }),
+    geometry: geoJsonLineStringSchema.optional().openapi({
+        description: 'GeoJSON LineString geometry for the access point'
+    }),
+    width_meters: z.number().positive().optional().openapi({
+        description: 'Width of the access point in meters',
+        example: 6.5
+    }),
+    height_meters: z.number().positive().optional().openapi({
+        description: 'Height of the access point in meters',
+        example: 4.2
+    }),
+    linked_parking_area_ids: z
+        .array(z.number().int().positive())
+        .optional()
+        .openapi({
+        description: 'IDs of parking areas to link to this access point',
+        example: [1, 2, 3]
+    })
+})
+    .openapi('CreateAccessBody');
+export const createAccessDataSchema = z
+    .object({
+    access_id: z.number().openapi({
+        description: 'ID of the created access point',
+        example: 1
+    }),
+    event_id: z.number().openapi({
+        description: 'ID of the event',
+        example: 1
+    }),
+    name: z.string().openapi({
+        description: 'Name of the access point',
+        example: 'Main Entrance'
+    }),
+    geometry: geoJsonLineStringSchema.nullable().openapi({
+        description: 'GeoJSON LineString geometry'
+    }),
+    width_meters: z.number().nullable().openapi({
+        description: 'Width in meters',
+        example: 6.5
+    }),
+    height_meters: z.number().nullable().openapi({
+        description: 'Height in meters',
+        example: 4.2
+    }),
+    linked_parking_areas: z
+        .array(z.object({
+        parking_area_id: z.number(),
+        parking_area_name: z.string().nullable()
+    }))
+        .openapi({
+        description: 'Linked parking areas'
+    }),
+    is_active: z.boolean().openapi({
+        description: 'Whether the access point is active',
+        example: true
+    }),
+    created_at: z.string().openapi({
+        description: 'Timestamp when access point was created'
+    }),
+    created_by: z.string().nullable().openapi({
+        description: 'ID of the user who created the access point'
+    })
+})
+    .openapi('CreateAccessData');
+export const createAccessResponseSchema = createMessageDataResponseSchema(createAccessDataSchema, 'CreateAccessResponse', 'Access point created successfully', 'Details of the created access point');
+// ------------------------------
+// Update Access Point Schemas
+// ------------------------------
+export const updateAccessParamsSchema = z
+    .object({
+    accessId: z
+        .string()
+        .min(1)
+        .transform(val => parseInt(val, 10))
+        .refine(val => !isNaN(val) && val > 0, {
+        message: 'Access point ID must be a positive number'
+    })
+        .openapi({
+        description: 'The ID of the access point to update',
+        example: '1'
+    })
+})
+    .openapi('UpdateAccessParams');
+export const updateAccessBodySchema = z
+    .object({
+    name: z.string().min(1).max(255).optional().openapi({
+        description: 'New name for the access point'
+    }),
+    geometry: geoJsonLineStringSchema.nullable().optional().openapi({
+        description: 'New geometry'
+    }),
+    width_meters: z.number().positive().nullable().optional().openapi({
+        description: 'New width in meters'
+    }),
+    height_meters: z.number().positive().nullable().optional().openapi({
+        description: 'New height in meters'
+    }),
+    is_active: z.boolean().optional().openapi({
+        description: 'Whether the access point is active'
+    })
+})
+    .refine(data => Object.keys(data).length > 0, {
+    message: 'At least one field must be provided for update'
+})
+    .openapi('UpdateAccessBody');
+export const updateAccessDataSchema = createAccessDataSchema
+    .extend({
+    updated_at: z.string().openapi({
+        description: 'Timestamp when access point was updated'
+    }),
+    updated_by: z.string().nullable().openapi({
+        description: 'ID of the user who updated the access point'
+    })
+})
+    .omit({ access_id: true })
+    .extend({
+    access_id: z.number().openapi({
+        description: 'ID of the updated access point'
+    })
+})
+    .openapi('UpdateAccessData');
+export const updateAccessResponseSchema = createMessageDataResponseSchema(updateAccessDataSchema, 'UpdateAccessResponse', 'Access point updated successfully', 'Details of the updated access point');
+// ------------------------------
+// Delete Access Point Schemas
+// ------------------------------
+export const deleteAccessParamsSchema = z
+    .object({
+    accessId: z
+        .string()
+        .min(1)
+        .transform(val => parseInt(val, 10))
+        .refine(val => !isNaN(val) && val > 0, {
+        message: 'Access point ID must be a positive number'
+    })
+        .openapi({
+        description: 'The ID of the access point to delete',
+        example: '1'
+    })
+})
+    .openapi('DeleteAccessParams');
+export const deleteAccessDataSchema = z
+    .object({
+    access_id: z.number().openapi({
+        description: 'ID of the deleted access point',
+        example: 1
+    }),
+    deleted_at: z.string().openapi({
+        description: 'Timestamp when access point was deleted'
+    })
+})
+    .openapi('DeleteAccessData');
+export const deleteAccessResponseSchema = createMessageDataResponseSchema(deleteAccessDataSchema, 'DeleteAccessResponse', 'Access point deleted successfully', 'Details of the deleted access point');
+// ------------------------------
+// Link/Unlink Parking Areas Schemas
+// ------------------------------
+export const linkAccessAreasParamsSchema = z
+    .object({
+    accessId: z
+        .string()
+        .min(1)
+        .transform(val => parseInt(val, 10))
+        .refine(val => !isNaN(val) && val > 0, {
+        message: 'Access point ID must be a positive number'
+    })
+        .openapi({
+        description: 'The ID of the access point',
+        example: '1'
+    })
+})
+    .openapi('LinkAccessAreasParams');
+export const linkAccessAreasBodySchema = z
+    .object({
+    parking_area_ids: z
+        .array(z.number().int().positive())
+        .min(1, 'At least one parking area ID must be provided')
+        .openapi({
+        description: 'IDs of parking areas to link',
+        example: [1, 2, 3]
+    })
+})
+    .openapi('LinkAccessAreasBody');
+export const linkAccessAreasDataSchema = z
+    .object({
+    access_id: z.number().openapi({
+        description: 'ID of the access point',
+        example: 1
+    }),
+    linked_count: z.number().openapi({
+        description: 'Number of parking areas linked',
+        example: 3
+    }),
+    linked_parking_areas: z
+        .array(z.object({
+        parking_area_id: z.number(),
+        parking_area_name: z.string().nullable()
+    }))
+        .openapi({
+        description: 'List of linked parking areas'
+    })
+})
+    .openapi('LinkAccessAreasData');
+export const linkAccessAreasResponseSchema = createMessageDataResponseSchema(linkAccessAreasDataSchema, 'LinkAccessAreasResponse', 'Parking areas linked successfully', 'Details of the linked parking areas');
+export const unlinkAccessAreaParamsSchema = z
+    .object({
+    accessId: z
+        .string()
+        .min(1)
+        .transform(val => parseInt(val, 10))
+        .refine(val => !isNaN(val) && val > 0, {
+        message: 'Access point ID must be a positive number'
+    })
+        .openapi({
+        description: 'The ID of the access point',
+        example: '1'
+    }),
+    areaId: z
+        .string()
+        .min(1)
+        .transform(val => parseInt(val, 10))
+        .refine(val => !isNaN(val) && val > 0, {
+        message: 'Parking area ID must be a positive number'
+    })
+        .openapi({
+        description: 'The ID of the parking area to unlink',
+        example: '1'
+    })
+})
+    .openapi('UnlinkAccessAreaParams');
+export const unlinkAccessAreaDataSchema = z
+    .object({
+    access_id: z.number().openapi({
+        description: 'ID of the access point',
+        example: 1
+    }),
+    parking_area_id: z.number().openapi({
+        description: 'ID of the unlinked parking area',
+        example: 1
+    }),
+    unlinked_at: z.string().openapi({
+        description: 'Timestamp when the link was removed'
+    })
+})
+    .openapi('UnlinkAccessAreaData');
+export const unlinkAccessAreaResponseSchema = createMessageDataResponseSchema(unlinkAccessAreaDataSchema, 'UnlinkAccessAreaResponse', 'Parking area unlinked successfully', 'Details of the unlinked parking area');
+// ------------------------------
+// Get Access Points Response Schemas
+// ------------------------------
+export const getAccessesDataSchema = z
+    .object({
+    event_id: z.number().openapi({
+        description: 'ID of the event',
+        example: 1
+    }),
+    accesses: z.array(parkingAreaAccessWithLinksSchema).openapi({
+        description: 'List of access points for the event'
+    }),
+    total_count: z.number().openapi({
+        description: 'Total number of access points',
+        example: 4
+    })
+})
+    .openapi('GetAccessesData');
+export const getAccessesResponseSchema = createSuccessResponseSchema(getAccessesDataSchema, 'GetAccessesResponse', 'Access points for the event');
+export const getAccessDetailResponseSchema = createSuccessResponseSchema(parkingAreaAccessWithLinksSchema, 'GetAccessDetailResponse', 'Access point details with linked parking areas');
+// ------------------------------
+// Bulk Upsert Access Points Schemas
+// ------------------------------
+export const bulkUpsertAccessesBodySchema = z
+    .object({
+    event_id: z.number().int().positive().openapi({
+        description: 'ID of the event',
+        example: 1
+    }),
+    accesses: z
+        .array(z.object({
+        id: z.number().int().positive().optional().openapi({
+            description: 'Access point ID (for updates). Omit for new access points.'
+        }),
+        name: z.string().min(1).max(255).openapi({
+            description: 'Name of the access point'
+        }),
+        geometry: geoJsonLineStringSchema.optional(),
+        width_meters: z.number().positive().optional(),
+        height_meters: z.number().positive().optional(),
+        linked_parking_area_ids: z.array(z.number().int().positive()).optional()
+    }))
+        .min(1, 'At least one access point must be provided')
+        .openapi({
+        description: 'Array of access points to create or update'
+    })
+})
+    .openapi('BulkUpsertAccessesBody');
+export const bulkUpsertAccessesDataSchema = z
+    .object({
+    event_id: z.number().openapi({
+        description: 'ID of the event',
+        example: 1
+    }),
+    total_upserted: z.number().openapi({
+        description: 'Total number of access points successfully upserted',
+        example: 4
+    }),
+    upserted_accesses: z.array(parkingAreaAccessWithLinksSchema).openapi({
+        description: 'Array of successfully upserted access points'
+    })
+})
+    .openapi('BulkUpsertAccessesData');
+export const bulkUpsertAccessesResponseSchema = createMessageDataResponseSchema(bulkUpsertAccessesDataSchema, 'BulkUpsertAccessesResponse', 'Access points upserted successfully', 'Details of the upserted access points');