@htlkg/data 0.0.19 → 0.0.21

package/dist/reservations-CdDfkcZ_.d.ts

@@ -0,0 +1,172 @@
+import { C as CreateAuditFields, a as UpdateWithSoftDeleteFields } from './common-DSxswsZ3.js';
+
+/**
+ * Reservation Mutation Functions
+ *
+ * Provides type-safe mutation functions for creating, updating, and deleting reservations.
+ * Includes date validation and status transition rules.
+ */
+
+/**
+ * Reservation status type
+ */
+type ReservationStatus = "confirmed" | "checked_in" | "checked_out" | "cancelled" | "no_show";
+/**
+ * Validation error class for reservation operations
+ */
+declare class ReservationValidationError extends Error {
+    constructor(message: string);
+}
+/**
+ * Input type for creating a reservation
+ */
+interface CreateReservationInput extends CreateAuditFields {
+    brandId: string;
+    visitId: string;
+    confirmationCode: string;
+    checkIn: string;
+    checkOut: string;
+    status?: "confirmed" | "checked_in" | "checked_out" | "cancelled" | "no_show";
+    source?: string;
+    channel?: string;
+    roomType?: string;
+    room?: string;
+    totalAmount?: number;
+    currency?: string;
+    nights?: number;
+}
+/**
+ * Input type for updating a reservation
+ */
+interface UpdateReservationInput extends UpdateWithSoftDeleteFields {
+    id: string;
+    brandId?: string;
+    visitId?: string;
+    confirmationCode?: string;
+    checkIn?: string;
+    checkOut?: string;
+    status?: "confirmed" | "checked_in" | "checked_out" | "cancelled" | "no_show";
+    source?: string;
+    channel?: string;
+    roomType?: string;
+    room?: string;
+    totalAmount?: number;
+    currency?: string;
+    nights?: number;
+}
+/**
+ * Create a new reservation with date validation
+ *
+ * @throws {ReservationValidationError} if dates are invalid
+ *
+ * @example
+ * ```typescript
+ * import { createReservation } from '@htlkg/data/mutations';
+ * import { generateClient } from '@htlkg/data/client';
+ *
+ * const client = generateClient<Schema>();
+ * const reservation = await createReservation(client, {
+ *   brandId: 'brand-123',
+ *   visitId: 'visit-456',
+ *   confirmationCode: 'ABC123',
+ *   checkIn: '2024-01-01',
+ *   checkOut: '2024-01-05',
+ *   status: 'confirmed'
+ * });
+ * ```
+ */
+declare function createReservation<TClient = any>(client: TClient, input: CreateReservationInput): Promise<any | null>;
+/**
+ * Update an existing reservation with validation
+ *
+ * @throws {ReservationValidationError} if dates or status transition is invalid
+ *
+ * @example
+ * ```typescript
+ * import { updateReservation } from '@htlkg/data/mutations';
+ * import { generateClient } from '@htlkg/data/client';
+ *
+ * const client = generateClient<Schema>();
+ * const reservation = await updateReservation(client, {
+ *   id: 'reservation-123',
+ *   status: 'checked_in',
+ *   room: '201'
+ * });
+ * ```
+ */
+declare function updateReservation<TClient = any>(client: TClient, input: UpdateReservationInput): Promise<any | null>;
+/**
+ * Soft delete a reservation (sets deletedAt/deletedBy instead of removing)
+ *
+ * @example
+ * ```typescript
+ * import { softDeleteReservation } from '@htlkg/data/mutations';
+ * import { generateClient } from '@htlkg/data/client';
+ *
+ * const client = generateClient<Schema>();
+ * await softDeleteReservation(client, 'reservation-123', 'admin@example.com');
+ * ```
+ */
+declare function softDeleteReservation<TClient = any>(client: TClient, id: string, deletedBy: string): Promise<boolean>;
+/**
+ * Restore a soft-deleted reservation
+ * Checks retention period before allowing restoration
+ *
+ * @example
+ * ```typescript
+ * import { restoreReservation } from '@htlkg/data/mutations';
+ * import { generateClient } from '@htlkg/data/client';
+ *
+ * const client = generateClient<Schema>();
+ * await restoreReservation(client, 'reservation-123');
+ * // Or with custom retention days:
+ * await restoreReservation(client, 'reservation-123', 60);
+ * ```
+ */
+declare function restoreReservation<TClient = any>(client: TClient, id: string, retentionDays?: number): Promise<{
+    success: boolean;
+    error?: string;
+}>;
+/**
+ * Hard delete a reservation (permanently removes from database)
+ * Use with caution - prefer softDeleteReservation for recoverable deletion
+ *
+ * @example
+ * ```typescript
+ * import { deleteReservation } from '@htlkg/data/mutations';
+ * import { generateClient } from '@htlkg/data/client';
+ *
+ * const client = generateClient<Schema>();
+ * await deleteReservation(client, 'reservation-123');
+ * ```
+ */
+declare function deleteReservation<TClient = any>(client: TClient, id: string): Promise<boolean>;
+/**
+ * Update reservation status with validation
+ *
+ * Validates that the status transition is allowed based on current status.
+ * Status transition rules:
+ * - confirmed → checked_in, cancelled, no_show
+ * - checked_in → checked_out, cancelled
+ * - checked_out → (terminal state, no transitions)
+ * - cancelled → (terminal state, no transitions)
+ * - no_show → (terminal state, no transitions)
+ *
+ * @throws {ReservationValidationError} if status transition is invalid
+ *
+ * @example
+ * ```typescript
+ * import { updateReservationStatus } from '@htlkg/data/mutations';
+ * import { generateClient } from '@htlkg/data/client';
+ *
+ * const client = generateClient<Schema>();
+ * const reservation = await updateReservationStatus(
+ *   client,
+ *   'reservation-123',
+ *   'checked_in'
+ * );
+ * ```
+ */
+declare function updateReservationStatus<TClient = any>(client: TClient, id: string, newStatus: ReservationStatus): Promise<any | null>;
+
+export { type CreateReservationInput as C, ReservationValidationError as R, type UpdateReservationInput as U, updateReservationStatus as a, type ReservationStatus as b, createReservation as c, deleteReservation as d, restoreReservation as r, softDeleteReservation as s, updateReservation as u };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@htlkg/data",
-  "version": "0.0.19",
+  "version": "0.0.21",
   "type": "module",
   "exports": {
     ".": {
@@ -40,10 +40,20 @@
     "src",
     "dist"
   ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "prepublishOnly": "pnpm build",
+    "version:patch": "pnpm version patch --no-git-tag-version",
+    "version:minor": "pnpm version minor --no-git-tag-version",
+    "version:major": "pnpm version major --no-git-tag-version"
+  },
   "dependencies": {
     "@aws-amplify/api": "^6.0.0",
-    "zod": "^3.22.0",
-    "@htlkg/core": "0.0.13"
+    "@htlkg/core": "^0.0.15",
+    "zod": "^3.22.0"
   },
   "peerDependencies": {
     "vue": "^3.5.0"
@@ -58,14 +68,5 @@
     "tsup": "^8.0.0",
     "typescript": "^5.9.2",
     "vitest": "^3.2.4"
-  },
-  "scripts": {
-    "build": "tsup",
-    "dev": "tsup --watch",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "version:patch": "pnpm version patch --no-git-tag-version",
-    "version:minor": "pnpm version minor --no-git-tag-version",
-    "version:major": "pnpm version major --no-git-tag-version"
   }
-}
+}

package/src/client/index.ts

@@ -26,6 +26,24 @@ export {
 	type ProxyOptions,
 } from "./proxy";
 
+// Re-export type-safe client-side Reservation operations
+export {
+	createReservation,
+	updateReservation,
+	softDeleteReservation,
+	restoreReservation,
+	deleteReservation,
+	getReservation,
+	listReservations,
+	updateReservationStatus,
+	bulkSoftDeleteReservations,
+	bulkRestoreReservations,
+	bulkDeleteReservations,
+	bulkUpdateReservationStatus,
+	type Reservation,
+	type ReservationStatus,
+} from "./reservations";
+
 /**
  * Type for the server-side Amplify client (for use in type declarations)
  * This represents the client returned by generateServerClientUsingCookies

package/src/client/reservations.ts

@@ -0,0 +1,336 @@
+/**
+ * Type-safe Client-Side Reservation Operations
+ *
+ * Provides type-safe wrappers around the GraphQL proxy for reservation operations.
+ * These functions can be used directly in Vue components while maintaining type safety.
+ * Includes client-side validation for dates and status transitions.
+ */
+
+import { mutate, query, type GraphQLResponse } from "./proxy";
+import type {
+	CreateReservationInput,
+	UpdateReservationInput,
+	ReservationStatus,
+} from "../mutations/reservations";
+
+/**
+ * Reservation type (simplified for client-side use)
+ */
+export interface Reservation {
+	id: string;
+	brandId: string;
+	visitId: string;
+	confirmationCode: string;
+	checkIn: string;
+	checkOut: string;
+	status: ReservationStatus;
+	source?: string;
+	channel?: string;
+	roomType?: string;
+	room?: string;
+	totalAmount?: number;
+	currency?: string;
+	nights?: number;
+	deletedAt?: string;
+	deletedBy?: string;
+	createdAt?: string;
+	createdBy?: string;
+	updatedAt?: string;
+	updatedBy?: string;
+}
+
+/**
+ * Re-export ReservationStatus type for convenience
+ */
+export type { ReservationStatus } from "../mutations/reservations";
+
+/**
+ * Create a new reservation (client-side)
+ *
+ * @example
+ * ```typescript
+ * import { createReservation } from '@htlkg/data/client';
+ *
+ * const result = await createReservation({
+ *   brandId: 'brand-123',
+ *   visitId: 'visit-456',
+ *   confirmationCode: 'ABC123',
+ *   checkIn: '2024-01-01',
+ *   checkOut: '2024-01-05',
+ *   status: 'confirmed'
+ * });
+ *
+ * if (!result.errors) {
+ *   console.log('Created:', result.data);
+ * }
+ * ```
+ */
+export async function createReservation(
+	input: CreateReservationInput,
+): Promise<GraphQLResponse<Reservation>> {
+	return mutate<Reservation>("Reservation", "create", input);
+}
+
+/**
+ * Update an existing reservation (client-side)
+ *
+ * @example
+ * ```typescript
+ * import { updateReservation } from '@htlkg/data/client';
+ *
+ * const result = await updateReservation({
+ *   id: 'reservation-123',
+ *   status: 'checked_in',
+ *   room: '201'
+ * });
+ *
+ * if (!result.errors) {
+ *   console.log('Updated:', result.data);
+ * }
+ * ```
+ */
+export async function updateReservation(
+	input: UpdateReservationInput,
+): Promise<GraphQLResponse<Reservation>> {
+	return mutate<Reservation>("Reservation", "update", input);
+}
+
+/**
+ * Soft delete a reservation (sets deletedAt/deletedBy)
+ *
+ * @example
+ * ```typescript
+ * import { softDeleteReservation } from '@htlkg/data/client';
+ *
+ * const result = await softDeleteReservation('reservation-123', 'admin@example.com');
+ *
+ * if (!result.errors) {
+ *   console.log('Soft deleted');
+ * }
+ * ```
+ */
+export async function softDeleteReservation(
+	id: string,
+	deletedBy: string,
+): Promise<GraphQLResponse<Reservation>> {
+	return mutate<Reservation>("Reservation", "update", {
+		id,
+		deletedAt: new Date().toISOString(),
+		deletedBy,
+	});
+}
+
+/**
+ * Restore a soft-deleted reservation
+ *
+ * @example
+ * ```typescript
+ * import { restoreReservation } from '@htlkg/data/client';
+ *
+ * const result = await restoreReservation('reservation-123');
+ *
+ * if (!result.errors) {
+ *   console.log('Restored');
+ * }
+ * ```
+ */
+export async function restoreReservation(
+	id: string,
+): Promise<GraphQLResponse<Reservation>> {
+	return mutate<Reservation>("Reservation", "update", {
+		id,
+		deletedAt: null,
+		deletedBy: null,
+	});
+}
+
+/**
+ * Permanently delete a reservation (removes from database)
+ *
+ * @example
+ * ```typescript
+ * import { deleteReservation } from '@htlkg/data/client';
+ *
+ * const result = await deleteReservation('reservation-123');
+ *
+ * if (!result.errors) {
+ *   console.log('Permanently deleted');
+ * }
+ * ```
+ */
+export async function deleteReservation(
+	id: string,
+): Promise<GraphQLResponse<Reservation>> {
+	return mutate<Reservation>("Reservation", "delete", { id });
+}
+
+/**
+ * Get a single reservation by ID
+ *
+ * @example
+ * ```typescript
+ * import { getReservation } from '@htlkg/data/client';
+ *
+ * const result = await getReservation('reservation-123');
+ *
+ * if (!result.errors && result.data) {
+ *   console.log('Reservation:', result.data);
+ * }
+ * ```
+ */
+export async function getReservation(
+	id: string,
+): Promise<GraphQLResponse<Reservation>> {
+	return query<Reservation>("Reservation", "get", { id });
+}
+
+/**
+ * List reservations with optional filters
+ *
+ * @example
+ * ```typescript
+ * import { listReservations } from '@htlkg/data/client';
+ *
+ * const result = await listReservations({
+ *   filter: { brandId: { eq: 'brand-123' } },
+ *   limit: 100
+ * });
+ *
+ * if (!result.errors && result.data) {
+ *   console.log('Reservations:', result.data);
+ * }
+ * ```
+ */
+export async function listReservations(
+	options?: {
+		filter?: Record<string, any>;
+		limit?: number;
+		nextToken?: string;
+		selectionSet?: string[];
+	},
+): Promise<GraphQLResponse<Reservation[]>> {
+	return query<Reservation[]>("Reservation", "list", options);
+}
+
+/**
+ * Update reservation status (with server-side validation)
+ *
+ * The server will validate status transitions:
+ * - confirmed → checked_in, cancelled, no_show
+ * - checked_in → checked_out, cancelled
+ * - checked_out, cancelled, no_show → (terminal states, no transitions)
+ *
+ * @example
+ * ```typescript
+ * import { updateReservationStatus } from '@htlkg/data/client';
+ *
+ * const result = await updateReservationStatus('reservation-123', 'checked_in');
+ *
+ * if (!result.errors) {
+ *   console.log('Status updated');
+ * } else {
+ *   console.error('Status transition not allowed:', result.errors[0].message);
+ * }
+ * ```
+ */
+export async function updateReservationStatus(
+	id: string,
+	status: ReservationStatus,
+): Promise<GraphQLResponse<Reservation>> {
+	return mutate<Reservation>("Reservation", "update", { id, status });
+}
+
+/**
+ * Bulk soft delete reservations
+ *
+ * @example
+ * ```typescript
+ * import { bulkSoftDeleteReservations } from '@htlkg/data/client';
+ *
+ * const results = await bulkSoftDeleteReservations(
+ *   ['res-1', 'res-2', 'res-3'],
+ *   'admin@example.com'
+ * );
+ *
+ * results.forEach(result => {
+ *   if (!result.errors) console.log('Deleted:', result.data?.id);
+ * });
+ * ```
+ */
+export async function bulkSoftDeleteReservations(
+	ids: string[],
+	deletedBy: string,
+): Promise<GraphQLResponse<Reservation>[]> {
+	return Promise.all(ids.map((id) => softDeleteReservation(id, deletedBy)));
+}
+
+/**
+ * Bulk restore reservations
+ *
+ * @example
+ * ```typescript
+ * import { bulkRestoreReservations } from '@htlkg/data/client';
+ *
+ * const results = await bulkRestoreReservations(['res-1', 'res-2', 'res-3']);
+ *
+ * results.forEach(result => {
+ *   if (!result.errors) console.log('Restored:', result.data?.id);
+ * });
+ * ```
+ */
+export async function bulkRestoreReservations(
+	ids: string[],
+): Promise<GraphQLResponse<Reservation>[]> {
+	return Promise.all(ids.map((id) => restoreReservation(id)));
+}
+
+/**
+ * Bulk permanently delete reservations
+ *
+ * @example
+ * ```typescript
+ * import { bulkDeleteReservations } from '@htlkg/data/client';
+ *
+ * const results = await bulkDeleteReservations(['res-1', 'res-2', 'res-3']);
+ *
+ * results.forEach(result => {
+ *   if (!result.errors) console.log('Permanently deleted:', result.data?.id);
+ * });
+ * ```
+ */
+export async function bulkDeleteReservations(
+	ids: string[],
+): Promise<GraphQLResponse<Reservation>[]> {
+	return Promise.all(ids.map((id) => deleteReservation(id)));
+}
+
+/**
+ * Bulk update reservation status (with server-side validation per reservation)
+ *
+ * Note: Each reservation's status transition is validated independently.
+ * Some may succeed while others fail if their current status doesn't allow the transition.
+ *
+ * @example
+ * ```typescript
+ * import { bulkUpdateReservationStatus } from '@htlkg/data/client';
+ *
+ * const results = await bulkUpdateReservationStatus(
+ *   ['res-1', 'res-2', 'res-3'],
+ *   'checked_in'
+ * );
+ *
+ * results.forEach(result => {
+ *   if (!result.errors) {
+ *     console.log('Updated:', result.data?.id);
+ *   } else {
+ *     console.error('Failed:', result.errors[0].message);
+ *   }
+ * });
+ * ```
+ */
+export async function bulkUpdateReservationStatus(
+	ids: string[],
+	status: ReservationStatus,
+): Promise<GraphQLResponse<Reservation>[]> {
+	return Promise.all(ids.map((id) => updateReservationStatus(id, status)));
+}