@htlkg/data 0.0.14 → 0.0.16

package/src/mutations/productInstances/productInstances.ts

@@ -0,0 +1,280 @@
+/**
+ * ProductInstance Mutation Functions
+ *
+ * Provides mutation functions for creating, updating, and deleting product instances.
+ * Product instances represent enabled products for a specific brand with their configuration.
+ */
+
+import type { ProductInstance } from "@htlkg/core/types";
+import { getClientUser } from "@htlkg/core/auth";
+import { getCurrentTimestamp } from "@htlkg/core/utils";
+import { AppError } from "@htlkg/core/errors";
+
+/**
+ * Get current user identifier for audit trails
+ * Uses getClientUser() and returns email or username, falling back to "system"
+ */
+async function getUserIdentifier(fallback = "system"): Promise<string> {
+	try {
+		const user = await getClientUser();
+		if (user) {
+			return user.email || user.username || fallback;
+		}
+		return fallback;
+	} catch {
+		return fallback;
+	}
+}
+
+/**
+ * Input type for creating a product instance
+ */
+export interface CreateProductInstanceInput {
+	productId: string;
+	brandId: string;
+	accountId: string;
+	productName: string;
+	enabled: boolean;
+	config?: Record<string, any>;
+	version?: string;
+	lastUpdated?: string;
+	updatedBy?: string;
+}
+
+/**
+ * Input type for updating a product instance
+ */
+export interface UpdateProductInstanceInput {
+	id: string;
+	enabled?: boolean;
+	config?: Record<string, any>;
+	version?: string;
+	lastUpdated?: string;
+	updatedBy?: string;
+}
+
+/**
+ * Create a new product instance
+ *
+ * @example
+ * ```typescript
+ * import { createProductInstance } from '@htlkg/data/mutations';
+ * import { generateClient } from '@htlkg/data/client';
+ *
+ * const client = generateClient<Schema>();
+ * const instance = await createProductInstance(client, {
+ *   productId: 'product-123',
+ *   brandId: 'brand-456',
+ *   accountId: 'account-789',
+ *   enabled: true,
+ *   config: { apiKey: 'xxx', maxRequests: 100 }
+ * });
+ * ```
+ */
+export async function createProductInstance<TClient = any>(
+	client: TClient,
+	input: CreateProductInstanceInput,
+): Promise<ProductInstance | null> {
+	try {
+		// Build input - manually construct to avoid Vue Proxy issues
+		const createInput: any = {
+			productId: input.productId,
+			productName: input.productName,
+			brandId: input.brandId,
+			accountId: input.accountId,
+			enabled: input.enabled,
+			version: input.version,
+			lastUpdated: input.lastUpdated || getCurrentTimestamp(),
+			updatedBy: input.updatedBy || await getUserIdentifier(),
+		};
+
+		// AWSJSON type requires JSON STRING
+		if (input.config) {
+			// Double stringify: first to strip Vue Proxy, second to create JSON string
+			createInput.config = JSON.stringify(JSON.parse(JSON.stringify(input.config)));
+		}
+
+		console.log("[createProductInstance] Config as string:", createInput.config);
+		console.log("[createProductInstance] Config type:", typeof createInput.config);
+
+		const { data, errors } = await (client as any).models.ProductInstance.create(createInput);
+
+		if (errors) {
+			console.error("[createProductInstance] GraphQL errors:", errors);
+			throw new AppError(
+				"Failed to create product instance",
+				"PRODUCT_INSTANCE_CREATE_ERROR",
+				500,
+				{ errors }
+			);
+		}
+
+		return data as ProductInstance;
+	} catch (error) {
+		console.error("[createProductInstance] Error creating product instance:", error);
+		if (error instanceof AppError) {
+			throw error;
+		}
+		throw new AppError(
+			"Failed to create product instance",
+			"PRODUCT_INSTANCE_CREATE_ERROR",
+			500,
+			{ originalError: error }
+		);
+	}
+}
+
+/**
+ * Update an existing product instance
+ *
+ * @example
+ * ```typescript
+ * import { updateProductInstance } from '@htlkg/data/mutations';
+ * import { generateClient } from '@htlkg/data/client';
+ *
+ * const client = generateClient<Schema>();
+ * const instance = await updateProductInstance(client, {
+ *   id: 'instance-123',
+ *   enabled: false,
+ *   config: { apiKey: 'new-key', maxRequests: 200 }
+ * });
+ * ```
+ */
+export async function updateProductInstance<TClient = any>(
+	client: TClient,
+	input: UpdateProductInstanceInput,
+): Promise<ProductInstance | null> {
+	try {
+		// Add timestamp and user metadata if not provided
+		// Convert config from Vue Proxy to plain object
+		const updateInput: any = {
+			...input,
+			lastUpdated: input.lastUpdated || getCurrentTimestamp(),
+			updatedBy: input.updatedBy || await getUserIdentifier(),
+		};
+
+		// AWSJSON type requires JSON STRING
+		if (input.config) {
+			updateInput.config = JSON.stringify(JSON.parse(JSON.stringify(input.config)));
+		}
+
+		const { data, errors } = await (client as any).models.ProductInstance.update(updateInput);
+
+		if (errors) {
+			console.error("[updateProductInstance] GraphQL errors:", errors);
+			throw new AppError(
+				"Failed to update product instance",
+				"PRODUCT_INSTANCE_UPDATE_ERROR",
+				500,
+				{ errors }
+			);
+		}
+
+		return data as ProductInstance;
+	} catch (error) {
+		console.error("[updateProductInstance] Error updating product instance:", error);
+		if (error instanceof AppError) {
+			throw error;
+		}
+		throw new AppError(
+			"Failed to update product instance",
+			"PRODUCT_INSTANCE_UPDATE_ERROR",
+			500,
+			{ originalError: error }
+		);
+	}
+}
+
+/**
+ * Delete a product instance
+ *
+ * @example
+ * ```typescript
+ * import { deleteProductInstance } from '@htlkg/data/mutations';
+ * import { generateClient } from '@htlkg/data/client';
+ *
+ * const client = generateClient<Schema>();
+ * await deleteProductInstance(client, 'instance-123');
+ * ```
+ */
+export async function deleteProductInstance<TClient = any>(
+	client: TClient,
+	id: string,
+): Promise<boolean> {
+	try {
+		const { errors } = await (client as any).models.ProductInstance.delete({ id });
+
+		if (errors) {
+			console.error("[deleteProductInstance] GraphQL errors:", errors);
+			throw new AppError(
+				"Failed to delete product instance",
+				"PRODUCT_INSTANCE_DELETE_ERROR",
+				500,
+				{ errors }
+			);
+		}
+
+		return true;
+	} catch (error) {
+		console.error("[deleteProductInstance] Error deleting product instance:", error);
+		if (error instanceof AppError) {
+			throw error;
+		}
+		throw new AppError(
+			"Failed to delete product instance",
+			"PRODUCT_INSTANCE_DELETE_ERROR",
+			500,
+			{ originalError: error }
+		);
+	}
+}
+
+/**
+ * Toggle the enabled status of a product instance
+ *
+ * @example
+ * ```typescript
+ * import { toggleProductInstanceEnabled } from '@htlkg/data/mutations';
+ * import { generateClient } from '@htlkg/data/client';
+ *
+ * const client = generateClient<Schema>();
+ * const instance = await toggleProductInstanceEnabled(client, 'instance-123', true);
+ * ```
+ */
+export async function toggleProductInstanceEnabled<TClient = any>(
+	client: TClient,
+	id: string,
+	enabled: boolean,
+): Promise<ProductInstance | null> {
+	try {
+		const { data, errors } = await (client as any).models.ProductInstance.update({
+			id,
+			enabled,
+			lastUpdated: getCurrentTimestamp(),
+			updatedBy: await getUserIdentifier(),
+		});
+
+		if (errors) {
+			console.error("[toggleProductInstanceEnabled] GraphQL errors:", errors);
+			throw new AppError(
+				"Failed to toggle product instance",
+				"PRODUCT_INSTANCE_TOGGLE_ERROR",
+				500,
+				{ errors }
+			);
+		}
+
+		return data as ProductInstance;
+	} catch (error) {
+		console.error("[toggleProductInstanceEnabled] Error toggling product instance:", error);
+		if (error instanceof AppError) {
+			throw error;
+		}
+		throw new AppError(
+			"Failed to toggle product instance",
+			"PRODUCT_INSTANCE_TOGGLE_ERROR",
+			500,
+			{ originalError: error }
+		);
+	}
+}

package/src/mutations/systemSettings.ts

@@ -0,0 +1,130 @@
+/**
+ * SystemSettings Mutation Functions
+ *
+ * Provides mutation functions for managing system settings.
+ */
+
+import type { SystemSettings } from "@htlkg/core/types";
+import {
+	SYSTEM_SETTINGS_KEY,
+	DEFAULT_SOFT_DELETE_RETENTION_DAYS,
+} from "../queries/systemSettings";
+
+/**
+ * Input type for updating system settings
+ */
+export interface UpdateSystemSettingsInput {
+	softDeleteRetentionDays: number;
+	updatedBy: string;
+}
+
+/**
+ * Update or create system settings
+ * Only SUPER_ADMINS can update system settings
+ *
+ * @example
+ * ```typescript
+ * import { updateSystemSettings } from '@htlkg/data/mutations';
+ * import { generateClient } from '@htlkg/data/client';
+ *
+ * const client = generateClient<Schema>();
+ * const settings = await updateSystemSettings(client, {
+ *   softDeleteRetentionDays: 60,
+ *   updatedBy: 'admin@example.com'
+ * });
+ * ```
+ */
+export async function updateSystemSettings<TClient = any>(
+	client: TClient,
+	input: UpdateSystemSettingsInput,
+): Promise<SystemSettings | null> {
+	try {
+		// Validate retention days (minimum 1 day, maximum 365 days)
+		if (input.softDeleteRetentionDays < 1 || input.softDeleteRetentionDays > 365) {
+			console.error(
+				"[updateSystemSettings] Invalid retention days. Must be between 1 and 365.",
+			);
+			return null;
+		}
+
+		// First, try to get existing settings
+		const { data: existing } = await (client as any).models.SystemSettings.get({
+			key: SYSTEM_SETTINGS_KEY,
+		});
+
+		const settingsData = {
+			key: SYSTEM_SETTINGS_KEY,
+			softDeleteRetentionDays: input.softDeleteRetentionDays,
+			updatedAt: new Date().toISOString(),
+			updatedBy: input.updatedBy,
+		};
+
+		let result;
+		if (existing) {
+			// Update existing settings
+			result = await (client as any).models.SystemSettings.update(settingsData);
+		} else {
+			// Create new settings
+			result = await (client as any).models.SystemSettings.create(settingsData);
+		}
+
+		if (result.errors) {
+			console.error("[updateSystemSettings] GraphQL errors:", result.errors);
+			return null;
+		}
+
+		return result.data as SystemSettings;
+	} catch (error) {
+		console.error("[updateSystemSettings] Error updating system settings:", error);
+		throw error;
+	}
+}
+
+/**
+ * Initialize system settings with default values if they don't exist
+ *
+ * @example
+ * ```typescript
+ * import { initializeSystemSettings } from '@htlkg/data/mutations';
+ * import { generateClient } from '@htlkg/data/client';
+ *
+ * const client = generateClient<Schema>();
+ * const settings = await initializeSystemSettings(client, 'system@hotelinking.com');
+ * ```
+ */
+export async function initializeSystemSettings<TClient = any>(
+	client: TClient,
+	initializedBy: string,
+): Promise<SystemSettings | null> {
+	try {
+		// Check if settings already exist
+		const { data: existing } = await (client as any).models.SystemSettings.get({
+			key: SYSTEM_SETTINGS_KEY,
+		});
+
+		if (existing) {
+			return existing as SystemSettings;
+		}
+
+		// Create default settings
+		const { data, errors } = await (client as any).models.SystemSettings.create({
+			key: SYSTEM_SETTINGS_KEY,
+			softDeleteRetentionDays: DEFAULT_SOFT_DELETE_RETENTION_DAYS,
+			updatedAt: new Date().toISOString(),
+			updatedBy: initializedBy,
+		});
+
+		if (errors) {
+			console.error("[initializeSystemSettings] GraphQL errors:", errors);
+			return null;
+		}
+
+		return data as SystemSettings;
+	} catch (error) {
+		console.error(
+			"[initializeSystemSettings] Error initializing system settings:",
+			error,
+		);
+		throw error;
+	}
+}

package/src/mutations/users.ts

@@ -5,6 +5,10 @@
  */
 
 import type { User } from "@htlkg/core/types";
+import {
+	checkRestoreEligibility,
+	DEFAULT_SOFT_DELETE_RETENTION_DAYS,
+} from "../queries/systemSettings";
 
 /**
  * Input type for creating a user
@@ -105,7 +109,104 @@ export async function updateUser<TClient = any>(
 }
 
 /**
- * Delete a user
+ * Soft delete a user (sets status to "deleted" instead of removing)
+ *
+ * @example
+ * ```typescript
+ * import { softDeleteUser } from '@htlkg/data/mutations';
+ * import { generateClient } from '@htlkg/data/client';
+ *
+ * const client = generateClient<Schema>();
+ * await softDeleteUser(client, 'user-123', 'admin@example.com');
+ * ```
+ */
+export async function softDeleteUser<TClient = any>(
+	client: TClient,
+	id: string,
+	deletedBy: string,
+): Promise<boolean> {
+	try {
+		const { errors } = await (client as any).models.User.update({
+			id,
+			status: "deleted",
+			deletedAt: new Date().toISOString(),
+			deletedBy,
+		});
+
+		if (errors) {
+			console.error("[softDeleteUser] GraphQL errors:", errors);
+			return false;
+		}
+
+		return true;
+	} catch (error) {
+		console.error("[softDeleteUser] Error soft-deleting user:", error);
+		throw error;
+	}
+}
+
+/**
+ * Restore a soft-deleted user (sets status back to "active")
+ * Checks retention period before allowing restoration
+ *
+ * @example
+ * ```typescript
+ * import { restoreUser } from '@htlkg/data/mutations';
+ * import { generateClient } from '@htlkg/data/client';
+ *
+ * const client = generateClient<Schema>();
+ * await restoreUser(client, 'user-123');
+ * // Or with custom retention days:
+ * await restoreUser(client, 'user-123', 60);
+ * ```
+ */
+export async function restoreUser<TClient = any>(
+	client: TClient,
+	id: string,
+	retentionDays: number = DEFAULT_SOFT_DELETE_RETENTION_DAYS,
+): Promise<{ success: boolean; error?: string }> {
+	try {
+		// First, get the user to check its deletedAt timestamp
+		const { data: user, errors: getErrors } = await (
+			client as any
+		).models.User.get({ id });
+
+		if (getErrors || !user) {
+			console.error("[restoreUser] Error fetching user:", getErrors);
+			return { success: false, error: "User not found" };
+		}
+
+		// Check if restoration is allowed based on retention period
+		const eligibility = checkRestoreEligibility(user.deletedAt, retentionDays);
+
+		if (!eligibility.canRestore) {
+			const errorMsg = `Cannot restore user. Retention period of ${retentionDays} days has expired. Item was deleted ${eligibility.daysExpired} days ago.`;
+			console.error("[restoreUser]", errorMsg);
+			return { success: false, error: errorMsg };
+		}
+
+		const { errors } = await (client as any).models.User.update({
+			id,
+			status: "active",
+			deletedAt: null,
+			deletedBy: null,
+		});
+
+		if (errors) {
+			console.error("[restoreUser] GraphQL errors:", errors);
+			return { success: false, error: "Failed to restore user" };
+		}
+
+		return { success: true };
+	} catch (error) {
+		console.error("[restoreUser] Error restoring user:", error);
+		throw error;
+	}
+}
+
+/**
+ * Hard delete a user (permanently removes from database)
+ * Use with caution - prefer softDeleteUser for recoverable deletion
  *
  * @example
  * ```typescript

package/src/queries/index.ts

@@ -43,3 +43,12 @@ export {
 
 // Server-side query helpers
 export { executeServerQuery, executePublicQuery } from "./server-helpers";
+
+// SystemSettings queries
+export {
+	getSystemSettings,
+	getSoftDeleteRetentionDays,
+	checkRestoreEligibility,
+	SYSTEM_SETTINGS_KEY,
+	DEFAULT_SOFT_DELETE_RETENTION_DAYS,
+} from "./systemSettings";

package/src/queries/systemSettings.ts

@@ -0,0 +1,115 @@
+/**
+ * SystemSettings Query Functions
+ *
+ * Provides query functions for fetching system settings from the GraphQL API.
+ */
+
+import type { SystemSettings } from "@htlkg/core/types";
+
+/** Default retention days if no settings exist */
+export const DEFAULT_SOFT_DELETE_RETENTION_DAYS = 30;
+
+/** The key used for global system settings */
+export const SYSTEM_SETTINGS_KEY = "GLOBAL";
+
+/**
+ * Get system settings
+ *
+ * @example
+ * ```typescript
+ * import { getSystemSettings } from '@htlkg/data/queries';
+ * import { generateClient } from '@htlkg/data/client';
+ *
+ * const client = generateClient<Schema>();
+ * const settings = await getSystemSettings(client);
+ * ```
+ */
+export async function getSystemSettings<TClient = any>(
+	client: TClient,
+): Promise<SystemSettings | null> {
+	try {
+		const { data, errors } = await (client as any).models.SystemSettings.get({
+			key: SYSTEM_SETTINGS_KEY,
+		});
+
+		if (errors) {
+			console.error("[getSystemSettings] GraphQL errors:", errors);
+			return null;
+		}
+
+		return data as SystemSettings;
+	} catch (error) {
+		console.error("[getSystemSettings] Error fetching system settings:", error);
+		throw error;
+	}
+}
+
+/**
+ * Get the soft delete retention days from system settings
+ * Returns the default (30 days) if settings don't exist
+ *
+ * @example
+ * ```typescript
+ * import { getSoftDeleteRetentionDays } from '@htlkg/data/queries';
+ * import { generateClient } from '@htlkg/data/client';
+ *
+ * const client = generateClient<Schema>();
+ * const days = await getSoftDeleteRetentionDays(client);
+ * ```
+ */
+export async function getSoftDeleteRetentionDays<TClient = any>(
+	client: TClient,
+): Promise<number> {
+	const settings = await getSystemSettings(client);
+	return settings?.softDeleteRetentionDays ?? DEFAULT_SOFT_DELETE_RETENTION_DAYS;
+}
+
+/**
+ * Check if a soft-deleted item can still be restored based on retention period
+ *
+ * @param deletedAt - The ISO date string when the item was deleted
+ * @param retentionDays - Number of days items can be restored
+ * @returns Object with canRestore flag and daysRemaining/daysExpired
+ */
+export function checkRestoreEligibility(
+	deletedAt: string | undefined | null,
+	retentionDays: number,
+): {
+	canRestore: boolean;
+	daysRemaining: number;
+	daysExpired: number;
+	expiresAt: Date | null;
+} {
+	if (!deletedAt) {
+		return {
+			canRestore: false,
+			daysRemaining: 0,
+			daysExpired: 0,
+			expiresAt: null,
+		};
+	}
+
+	const deletedDate = new Date(deletedAt);
+	const expiresAt = new Date(deletedDate);
+	expiresAt.setDate(expiresAt.getDate() + retentionDays);
+
+	const now = new Date();
+	const msRemaining = expiresAt.getTime() - now.getTime();
+	const daysRemaining = Math.ceil(msRemaining / (1000 * 60 * 60 * 24));
+
+	if (daysRemaining <= 0) {
+		return {
+			canRestore: false,
+			daysRemaining: 0,
+			daysExpired: Math.abs(daysRemaining),
+			expiresAt,
+		};
+	}
+
+	return {
+		canRestore: true,
+		daysRemaining,
+		daysExpired: 0,
+		expiresAt,
+	};
+}