@venulog/phasing-engine-schemas 0.1.0

package/README.md

@@ -0,0 +1,67 @@
+# @phasing-engine/schemas
+
+Shared schemas and types for Phasing Engine API. Provides Zod validation schemas, TypeScript types, and OpenAPI documentation support.
+
+## Installation
+
+This package is designed to be used as a local workspace package:
+
+```bash
+npm install @phasing-engine/schemas
+```
+
+## Usage
+
+```typescript
+import {
+  phaseBookingSchema,
+  PhaseBooking,
+  BookingStatus,
+  SlotStatus
+} from '@phasing-engine/schemas';
+
+// Use schemas for validation
+const booking = phaseBookingSchema.parse(data);
+
+// Use types for type safety
+const createBooking = (booking: PhaseBooking) => {
+  // ...
+};
+
+// Use enums for status values
+if (booking.status === BookingStatus.CONFIRMED) {
+  // ...
+}
+```
+
+## Available Exports
+
+### Schemas
+
+- `auth` - Authentication related schemas
+- `common` - Base response schemas and factory functions
+- `pagination` - Pagination and sorting schemas
+- `phaseBooking` - Phase booking operation schemas
+- `phaseSlot` - Phase slot management schemas
+
+### Enums
+
+- `BookingStatus` - Booking status values
+- `SlotStatus` - Slot status values
+
+### Types
+
+All schemas export corresponding TypeScript types using Zod's `z.infer<>`.
+
+## Development
+
+```bash
+# Build the package
+npm run build
+
+# Watch mode for development
+npm run dev
+
+# Clean build artifacts
+npm run clean
+```

package/dist/auth.d.ts

@@ -0,0 +1,114 @@
+import { z } from './zod.js';
+export declare const signInParamsSchema: z.ZodObject<{}, z.core.$strip>;
+export declare const refreshTokenParamsSchema: z.ZodObject<{}, z.core.$strip>;
+export declare const signInBodySchema: z.ZodObject<{
+    email: z.ZodEmail;
+    password: z.ZodString;
+}, z.core.$strip>;
+export declare const refreshTokenBodySchema: z.ZodObject<{
+    refresh_token: z.ZodString;
+}, z.core.$strip>;
+export declare const authUserSchema: z.ZodObject<{
+    id: z.ZodUUID;
+    email: z.ZodEmail;
+    email_confirmed_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+    user_metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export declare const authSessionSchema: z.ZodObject<{
+    access_token: z.ZodString;
+    token_type: z.ZodString;
+    expires_in: z.ZodNumber;
+    expires_at: z.ZodOptional<z.ZodNumber>;
+    refresh_token: z.ZodOptional<z.ZodString>;
+    user: z.ZodObject<{
+        id: z.ZodUUID;
+        email: z.ZodEmail;
+        email_confirmed_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        created_at: z.ZodString;
+        updated_at: z.ZodString;
+        user_metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const signOutDataSchema: z.ZodObject<{
+    message: z.ZodString;
+    signed_out_at: z.ZodString;
+}, z.core.$strip>;
+export declare const currentUserDataSchema: z.ZodObject<{
+    id: z.ZodUUID;
+    email: z.ZodEmail;
+    email_confirmed_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+    user_metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export declare const signInResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    message: z.ZodString;
+    data: z.ZodObject<{
+        access_token: z.ZodString;
+        token_type: z.ZodString;
+        expires_in: z.ZodNumber;
+        expires_at: z.ZodOptional<z.ZodNumber>;
+        refresh_token: z.ZodOptional<z.ZodString>;
+        user: z.ZodObject<{
+            id: z.ZodUUID;
+            email: z.ZodEmail;
+            email_confirmed_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            created_at: z.ZodString;
+            updated_at: z.ZodString;
+            user_metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const refreshTokenResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    message: z.ZodString;
+    data: z.ZodObject<{
+        access_token: z.ZodString;
+        token_type: z.ZodString;
+        expires_in: z.ZodNumber;
+        expires_at: z.ZodOptional<z.ZodNumber>;
+        refresh_token: z.ZodOptional<z.ZodString>;
+        user: z.ZodObject<{
+            id: z.ZodUUID;
+            email: z.ZodEmail;
+            email_confirmed_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            created_at: z.ZodString;
+            updated_at: z.ZodString;
+            user_metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const signOutResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    message: z.ZodString;
+    data: z.ZodObject<{
+        message: z.ZodString;
+        signed_out_at: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const getCurrentUserResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    data: z.ZodObject<{
+        id: z.ZodUUID;
+        email: z.ZodEmail;
+        email_confirmed_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        created_at: z.ZodString;
+        updated_at: z.ZodString;
+        user_metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type SignInParams = z.infer<typeof signInParamsSchema>;
+export type RefreshTokenParams = z.infer<typeof refreshTokenParamsSchema>;
+export type SignInBody = z.infer<typeof signInBodySchema>;
+export type RefreshTokenBody = z.infer<typeof refreshTokenBodySchema>;
+export type AuthUser = z.infer<typeof authUserSchema>;
+export type AuthSession = z.infer<typeof authSessionSchema>;
+export type SignOutData = z.infer<typeof signOutDataSchema>;
+export type CurrentUserData = z.infer<typeof currentUserDataSchema>;
+export type SignInResponse = z.infer<typeof signInResponseSchema>;
+export type RefreshTokenResponse = z.infer<typeof refreshTokenResponseSchema>;
+export type SignOutResponse = z.infer<typeof signOutResponseSchema>;
+export type GetCurrentUserResponse = z.infer<typeof getCurrentUserResponseSchema>;

package/dist/auth.js

@@ -0,0 +1,109 @@
+import { z } from './zod.js';
+import { createMessageDataResponseSchema, createSuccessResponseSchema } from './common.js';
+// ------------------------------
+// Parameter schemas
+// ------------------------------
+export const signInParamsSchema = z.object({}).openapi('SignInParams');
+export const refreshTokenParamsSchema = z.object({}).openapi('RefreshTokenParams');
+// ------------------------------
+// Request body schemas
+// ------------------------------
+export const signInBodySchema = z
+    .object({
+    email: z.email().openapi({
+        description: 'User email address',
+        example: 'superadmin@venulog.com'
+    }),
+    password: z.string().min(6).openapi({
+        description: 'User password (minimum 6 characters)',
+        example: 'password'
+    })
+})
+    .openapi('SignInBody');
+export const refreshTokenBodySchema = z
+    .object({
+    refresh_token: z.string().min(1).openapi({
+        description: 'Valid refresh token',
+        example: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...'
+    })
+})
+    .openapi('RefreshTokenBody');
+// ------------------------------
+// Response data schemas
+// ------------------------------
+export const authUserSchema = z
+    .object({
+    id: z.uuid().openapi({
+        description: 'User unique identifier',
+        example: '123e4567-e89b-12d3-a456-426614174000'
+    }),
+    email: z.email().openapi({
+        description: 'User email address',
+        example: 'superadmin@venulog.com'
+    }),
+    email_confirmed_at: z.string().nullable().optional().openapi({
+        description: 'Timestamp when email was confirmed',
+        example: '2025-12-04T10:30:00.000Z'
+    }),
+    created_at: z.string().openapi({
+        description: 'Timestamp when user was created',
+        example: '2025-12-04T10:30:00.000Z'
+    }),
+    updated_at: z.string().openapi({
+        description: 'Timestamp when user was last updated',
+        example: '2025-12-04T10:30:00.000Z'
+    }),
+    user_metadata: z
+        .record(z.string(), z.unknown())
+        .optional()
+        .openapi({
+        description: 'Additional user metadata',
+        example: { first_name: 'John', last_name: 'Doe' }
+    })
+})
+    .openapi('AuthUser');
+export const authSessionSchema = z
+    .object({
+    access_token: z.string().openapi({
+        description: 'JWT access token for authenticated requests',
+        example: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...'
+    }),
+    token_type: z.string().openapi({
+        description: 'Type of the token',
+        example: 'Bearer'
+    }),
+    expires_in: z.number().openapi({
+        description: 'Token expiration time in seconds',
+        example: 3600
+    }),
+    expires_at: z.number().optional().openapi({
+        description: 'Token expiration timestamp',
+        example: 1701684600
+    }),
+    refresh_token: z.string().optional().openapi({
+        description: 'Refresh token for obtaining new access tokens',
+        example: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...'
+    }),
+    user: authUserSchema
+})
+    .openapi('AuthSession');
+export const signOutDataSchema = z
+    .object({
+    message: z.string().openapi({
+        description: 'Sign out confirmation message',
+        example: 'Successfully signed out'
+    }),
+    signed_out_at: z.string().openapi({
+        description: 'Timestamp when user was signed out',
+        example: '2025-12-04T10:30:00.000Z'
+    })
+})
+    .openapi('SignOutData');
+export const currentUserDataSchema = authUserSchema.openapi('CurrentUserData');
+// ------------------------------
+// Response schemas
+// ------------------------------
+export const signInResponseSchema = createMessageDataResponseSchema(authSessionSchema, 'SignInResponse', 'Successfully signed in', 'Authentication session with access token and user information');
+export const refreshTokenResponseSchema = createMessageDataResponseSchema(authSessionSchema, 'RefreshTokenResponse', 'Access token refreshed successfully', 'New authentication session with refreshed tokens');
+export const signOutResponseSchema = createMessageDataResponseSchema(signOutDataSchema, 'SignOutResponse', 'Successfully signed out', 'Sign out confirmation details');
+export const getCurrentUserResponseSchema = createSuccessResponseSchema(currentUserDataSchema, 'GetCurrentUserResponse', 'Current authenticated user information');

package/dist/common.d.ts

@@ -0,0 +1,18 @@
+import { z } from './zod.js';
+export declare const baseResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+}, z.core.$strip>;
+export declare function createSuccessResponseSchema<T extends z.ZodTypeAny>(dataSchema: T, schemaName: string, dataDescription?: string): z.ZodObject<{
+    success: z.ZodBoolean;
+    data: T;
+}, z.core.$strip>;
+export declare function createMessageResponseSchema(schemaName: string, messageExample?: string): z.ZodObject<{
+    success: z.ZodBoolean;
+    message: z.ZodString;
+}, z.core.$strip>;
+export declare function createMessageDataResponseSchema<T extends z.ZodTypeAny>(dataSchema: T, schemaName: string, messageExample?: string, dataDescription?: string): z.ZodObject<{
+    success: z.ZodBoolean;
+    message: z.ZodString;
+    data: T;
+}, z.core.$strip>;
+export type BaseResponse = z.infer<typeof baseResponseSchema>;

package/dist/common.js

@@ -0,0 +1,45 @@
+import { z } from './zod.js';
+// Base response schema for all API responses
+export const baseResponseSchema = z
+    .object({
+    success: z.boolean().openapi({
+        description: 'Indicates if the operation was successful',
+        example: true
+    })
+})
+    .openapi('BaseResponse');
+// Success response with data
+export function createSuccessResponseSchema(dataSchema, schemaName, dataDescription) {
+    return baseResponseSchema
+        .extend({
+        data: dataSchema.openapi({
+            description: dataDescription || 'Response data'
+        })
+    })
+        .openapi(schemaName);
+}
+// Success response with message
+export function createMessageResponseSchema(schemaName, messageExample = 'Operation completed successfully') {
+    return baseResponseSchema
+        .extend({
+        message: z.string().openapi({
+            description: 'Human-readable success message',
+            example: messageExample
+        })
+    })
+        .openapi(schemaName);
+}
+// Success response with both message and data
+export function createMessageDataResponseSchema(dataSchema, schemaName, messageExample = 'Operation completed successfully', dataDescription) {
+    return baseResponseSchema
+        .extend({
+        message: z.string().openapi({
+            description: 'Human-readable success message',
+            example: messageExample
+        }),
+        data: dataSchema.openapi({
+            description: dataDescription || 'Response data'
+        })
+    })
+        .openapi(schemaName);
+}

package/dist/company.d.ts

@@ -0,0 +1,45 @@
+import { z } from './zod.js';
+export declare const fullCompanySchema: z.ZodObject<{
+    id: z.ZodNumber;
+    company_name: z.ZodString;
+    vat_number: z.ZodNullable<z.ZodString>;
+    siret_code: z.ZodNullable<z.ZodString>;
+    tva_intracom: z.ZodNullable<z.ZodString>;
+    type: z.ZodString;
+    company_role: z.ZodNullable<z.ZodString>;
+    company_street: z.ZodNullable<z.ZodString>;
+    company_city: z.ZodNullable<z.ZodString>;
+    company_postal_code: z.ZodNullable<z.ZodString>;
+    company_country: z.ZodNullable<z.ZodString>;
+    company_address: z.ZodNullable<z.ZodString>;
+    contact_first_name: z.ZodNullable<z.ZodString>;
+    contact_last_name: z.ZodNullable<z.ZodString>;
+    contact_email: z.ZodNullable<z.ZodString>;
+    contact_phone: z.ZodNullable<z.ZodString>;
+    is_active: z.ZodBoolean;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+    created_by: z.ZodNullable<z.ZodString>;
+    updated_by: z.ZodNullable<z.ZodString>;
+    company_id: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const companyRoleSchema: z.ZodObject<{
+    role: z.ZodString;
+}, z.core.$strip>;
+export declare const companyRolesDataSchema: z.ZodObject<{
+    roles: z.ZodArray<z.ZodObject<{
+        role: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const getCompanyRolesResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    data: z.ZodObject<{
+        roles: z.ZodArray<z.ZodObject<{
+            role: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type FullCompany = z.infer<typeof fullCompanySchema>;
+export type CompanyRole = z.infer<typeof companyRoleSchema>;
+export type CompanyRolesData = z.infer<typeof companyRolesDataSchema>;
+export type GetCompanyRolesResponse = z.infer<typeof getCompanyRolesResponseSchema>;

package/dist/company.js

@@ -0,0 +1,120 @@
+import { z } from './zod.js';
+import { createSuccessResponseSchema } from './common.js';
+// ------------------------------
+// Company schemas
+// ------------------------------
+export const fullCompanySchema = z
+    .object({
+    id: z.number().openapi({
+        description: 'Company unique identifier',
+        example: 1
+    }),
+    company_name: z.string().openapi({
+        description: 'Company name',
+        example: 'Acme Corporation'
+    }),
+    vat_number: z.string().nullable().openapi({
+        description: 'VAT number',
+        example: 'FR12345678901'
+    }),
+    siret_code: z.string().nullable().openapi({
+        description: 'SIRET code',
+        example: '12345678901234'
+    }),
+    tva_intracom: z.string().nullable().openapi({
+        description: 'Intra-community VAT number',
+        example: 'FR12345678901'
+    }),
+    type: z.string().openapi({
+        description: 'Company type',
+        example: 'corporate'
+    }),
+    company_role: z.string().nullable().openapi({
+        description: 'Company role in the system',
+        example: 'exhibitor'
+    }),
+    company_street: z.string().nullable().openapi({
+        description: 'Company street address',
+        example: '123 Business Street'
+    }),
+    company_city: z.string().nullable().openapi({
+        description: 'Company city',
+        example: 'Paris'
+    }),
+    company_postal_code: z.string().nullable().openapi({
+        description: 'Company postal code',
+        example: '75001'
+    }),
+    company_country: z.string().nullable().openapi({
+        description: 'Company country',
+        example: 'France'
+    }),
+    company_address: z.string().nullable().openapi({
+        description: 'Full company address',
+        example: '123 Business Street, 75001 Paris, France'
+    }),
+    contact_first_name: z.string().nullable().openapi({
+        description: 'Contact person first name',
+        example: 'John'
+    }),
+    contact_last_name: z.string().nullable().openapi({
+        description: 'Contact person last name',
+        example: 'Doe'
+    }),
+    contact_email: z.string().email().nullable().openapi({
+        description: 'Contact email address',
+        example: 'john.doe@acme.com'
+    }),
+    contact_phone: z.string().nullable().openapi({
+        description: 'Contact phone number',
+        example: '+33123456789'
+    }),
+    is_active: z.boolean().openapi({
+        description: 'Whether the company is active',
+        example: true
+    }),
+    created_at: z.string().openapi({
+        description: 'Timestamp when company was created',
+        example: '2025-12-04T10:30:00.000Z'
+    }),
+    updated_at: z.string().openapi({
+        description: 'Timestamp when company was last updated',
+        example: '2025-12-04T10:30:00.000Z'
+    }),
+    created_by: z.string().uuid().nullable().openapi({
+        description: 'User who created the company',
+        example: '123e4567-e89b-12d3-a456-426614174000'
+    }),
+    updated_by: z.string().uuid().nullable().openapi({
+        description: 'User who last updated the company',
+        example: '123e4567-e89b-12d3-a456-426614174000'
+    }),
+    company_id: z.number().nullable().openapi({
+        description: 'Parent company ID if this is a subsidiary',
+        example: null
+    })
+})
+    .openapi('FullCompany');
+// ------------------------------
+// Company roles response schemas
+// ------------------------------
+export const companyRoleSchema = z
+    .object({
+    role: z.string().openapi({
+        description: 'Distinct company role',
+        example: 'exhibitor'
+    })
+})
+    .openapi('CompanyRole');
+export const companyRolesDataSchema = z
+    .object({
+    roles: z.array(companyRoleSchema).openapi({
+        description: 'List of distinct company roles',
+        example: [{ role: 'exhibitor' }, { role: 'sponsor' }, { role: 'visitor' }]
+    })
+})
+    .openapi('CompanyRolesData');
+// ------------------------------
+// Response schemas
+// ------------------------------
+export const getCompanyRolesResponseSchema = createSuccessResponseSchema(companyRolesDataSchema, 'GetCompanyRolesResponse', 'List of distinct company roles with counts');

package/dist/enums/bookingStatus.d.ts

@@ -0,0 +1,6 @@
+export declare enum BookingStatus {
+    BOOKED = "booked",
+    CONFIRMED = "confirmed",
+    CANCELLED = "cancelled",
+    REFUSED = "refused"
+}

package/dist/enums/bookingStatus.js

@@ -0,0 +1,7 @@
+export var BookingStatus;
+(function (BookingStatus) {
+    BookingStatus["BOOKED"] = "booked";
+    BookingStatus["CONFIRMED"] = "confirmed";
+    BookingStatus["CANCELLED"] = "cancelled";
+    BookingStatus["REFUSED"] = "refused";
+})(BookingStatus || (BookingStatus = {}));

package/dist/enums/slotStatus.d.ts

@@ -0,0 +1,5 @@
+export declare enum SlotStatus {
+    AVAILABLE = "available",
+    TAKEN = "taken",
+    RESERVED = "reserved"
+}

package/dist/enums/slotStatus.js

@@ -0,0 +1,6 @@
+export var SlotStatus;
+(function (SlotStatus) {
+    SlotStatus["AVAILABLE"] = "available";
+    SlotStatus["TAKEN"] = "taken";
+    SlotStatus["RESERVED"] = "reserved";
+})(SlotStatus || (SlotStatus = {}));

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export * from './common.js';
+export * from './pagination.js';
+export * from './auth.js';
+export * from './phaseBooking.js';
+export * from './phaseSlot.js';
+export * from './company.js';
+export * from './enums/bookingStatus.js';
+export * from './enums/slotStatus.js';
+export { z } from './zod.js';

package/dist/index.js

@@ -0,0 +1,12 @@
+// Main exports
+export * from './common.js';
+export * from './pagination.js';
+export * from './auth.js';
+export * from './phaseBooking.js';
+export * from './phaseSlot.js';
+export * from './company.js';
+// Enum exports
+export * from './enums/bookingStatus.js';
+export * from './enums/slotStatus.js';
+// Zod re-export for convenience
+export { z } from './zod.js';

package/dist/pagination.d.ts

@@ -0,0 +1,13 @@
+import { z } from './zod.js';
+export declare const paginationSchema: z.ZodObject<{
+    page: z.ZodOptional<z.ZodDefault<z.ZodCoercedNumber<unknown>>>;
+    limit: z.ZodOptional<z.ZodDefault<z.ZodCoercedNumber<unknown>>>;
+    sort: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        column: z.ZodString;
+        direction: z.ZodEnum<{
+            asc: "asc";
+            desc: "desc";
+        }>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type PaginationDTO = z.infer<typeof paginationSchema>;

package/dist/pagination.js

@@ -0,0 +1,11 @@
+import { z } from './zod.js';
+export const paginationSchema = z
+    .object({
+    page: z.coerce.number().int().nonnegative().default(1),
+    limit: z.coerce.number().int().nonnegative().default(10),
+    sort: z.array(z.object({
+        column: z.string(),
+        direction: z.enum(['asc', 'desc'])
+    }))
+})
+    .partial();