@htlkg/data 0.0.14 → 0.0.16

package/dist/mutations/index.d.ts

@@ -1,4 +1,5 @@
-import { Brand, Account, User } from '@htlkg/core/types';
+import { Brand, Account, User, SystemSettings } from '@htlkg/core/types';
+export { C as CreateProductInstanceInput, U as UpdateProductInstanceInput, c as createProductInstance, d as deleteProductInstance, t as toggleProductInstanceEnabled, u as updateProductInstance } from '../productInstances-CzT3NZKU.js';
 
 /**
  * Brand Mutation Functions
@@ -64,7 +65,40 @@ declare function createBrand<TClient = any>(client: TClient, input: CreateBrandI
  */
 declare function updateBrand<TClient = any>(client: TClient, input: UpdateBrandInput): Promise<Brand | null>;
 /**
- * Delete a brand
+ * Soft delete a brand (sets status to "deleted" instead of removing)
+ *
+ * @example
+ * ```typescript
+ * import { softDeleteBrand } from '@htlkg/data/mutations';
+ * import { generateClient } from '@htlkg/data/client';
+ *
+ * const client = generateClient<Schema>();
+ * await softDeleteBrand(client, 'brand-123', 'admin@example.com');
+ * ```
+ */
+declare function softDeleteBrand<TClient = any>(client: TClient, id: string, deletedBy: string): Promise<boolean>;
+/**
+ * Restore a soft-deleted brand (sets status back to "active")
+ * Checks retention period before allowing restoration
+ *
+ * @example
+ * ```typescript
+ * import { restoreBrand } from '@htlkg/data/mutations';
+ * import { generateClient } from '@htlkg/data/client';
+ *
+ * const client = generateClient<Schema>();
+ * await restoreBrand(client, 'brand-123');
+ * // Or with custom retention days:
+ * await restoreBrand(client, 'brand-123', 60);
+ * ```
+ */
+declare function restoreBrand<TClient = any>(client: TClient, id: string, retentionDays?: number): Promise<{
+    success: boolean;
+    error?: string;
+}>;
+/**
+ * Hard delete a brand (permanently removes from database)
+ * Use with caution - prefer softDeleteBrand for recoverable deletion
  *
  * @example
  * ```typescript
@@ -135,7 +169,40 @@ declare function createAccount<TClient = any>(client: TClient, input: CreateAcco
  */
 declare function updateAccount<TClient = any>(client: TClient, input: UpdateAccountInput): Promise<Account | null>;
 /**
- * Delete an account
+ * Soft delete an account (sets status to "deleted" instead of removing)
+ *
+ * @example
+ * ```typescript
+ * import { softDeleteAccount } from '@htlkg/data/mutations';
+ * import { generateClient } from '@htlkg/data/client';
+ *
+ * const client = generateClient<Schema>();
+ * await softDeleteAccount(client, 'account-123', 'admin@example.com');
+ * ```
+ */
+declare function softDeleteAccount<TClient = any>(client: TClient, id: string, deletedBy: string): Promise<boolean>;
+/**
+ * Restore a soft-deleted account (sets status back to "active")
+ * Checks retention period before allowing restoration
+ *
+ * @example
+ * ```typescript
+ * import { restoreAccount } from '@htlkg/data/mutations';
+ * import { generateClient } from '@htlkg/data/client';
+ *
+ * const client = generateClient<Schema>();
+ * await restoreAccount(client, 'account-123');
+ * // Or with custom retention days:
+ * await restoreAccount(client, 'account-123', 60);
+ * ```
+ */
+declare function restoreAccount<TClient = any>(client: TClient, id: string, retentionDays?: number): Promise<{
+    success: boolean;
+    error?: string;
+}>;
+/**
+ * Hard delete an account (permanently removes from database)
+ * Use with caution - prefer softDeleteAccount for recoverable deletion
  *
  * @example
  * ```typescript
@@ -215,7 +282,40 @@ declare function createUser<TClient = any>(client: TClient, input: CreateUserInp
  */
 declare function updateUser<TClient = any>(client: TClient, input: UpdateUserInput): Promise<User | null>;
 /**
- * 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');
+ * ```
+ */
+declare function softDeleteUser<TClient = any>(client: TClient, id: string, deletedBy: string): Promise<boolean>;
+/**
+ * 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);
+ * ```
+ */
+declare function restoreUser<TClient = any>(client: TClient, id: string, retentionDays?: number): Promise<{
+    success: boolean;
+    error?: string;
+}>;
+/**
+ * Hard delete a user (permanently removes from database)
+ * Use with caution - prefer softDeleteUser for recoverable deletion
  *
  * @example
  * ```typescript
@@ -228,4 +328,48 @@ declare function updateUser<TClient = any>(client: TClient, input: UpdateUserInp
  */
 declare function deleteUser<TClient = any>(client: TClient, id: string): Promise<boolean>;
 
-export { type CreateAccountInput, type CreateBrandInput, type CreateUserInput, type UpdateAccountInput, type UpdateBrandInput, type UpdateUserInput, createAccount, createBrand, createUser, deleteAccount, deleteBrand, deleteUser, updateAccount, updateBrand, updateUser };
+/**
+ * SystemSettings Mutation Functions
+ *
+ * Provides mutation functions for managing system settings.
+ */
+
+/**
+ * Input type for updating system settings
+ */
+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'
+ * });
+ * ```
+ */
+declare function updateSystemSettings<TClient = any>(client: TClient, input: UpdateSystemSettingsInput): Promise<SystemSettings | null>;
+/**
+ * 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');
+ * ```
+ */
+declare function initializeSystemSettings<TClient = any>(client: TClient, initializedBy: string): Promise<SystemSettings | null>;
+
+export { type CreateAccountInput, type CreateBrandInput, type CreateUserInput, type UpdateAccountInput, type UpdateBrandInput, type UpdateSystemSettingsInput, type UpdateUserInput, createAccount, createBrand, createUser, deleteAccount, deleteBrand, deleteUser, initializeSystemSettings, restoreAccount, restoreBrand, restoreUser, softDeleteAccount, softDeleteBrand, softDeleteUser, updateAccount, updateBrand, updateSystemSettings, updateUser };

package/dist/mutations/index.js

@@ -1,3 +1,37 @@
+// src/queries/systemSettings.ts
+var DEFAULT_SOFT_DELETE_RETENTION_DAYS = 30;
+var SYSTEM_SETTINGS_KEY = "GLOBAL";
+function checkRestoreEligibility(deletedAt, retentionDays) {
+  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 = /* @__PURE__ */ new Date();
+  const msRemaining = expiresAt.getTime() - now.getTime();
+  const daysRemaining = Math.ceil(msRemaining / (1e3 * 60 * 60 * 24));
+  if (daysRemaining <= 0) {
+    return {
+      canRestore: false,
+      daysRemaining: 0,
+      daysExpired: Math.abs(daysRemaining),
+      expiresAt
+    };
+  }
+  return {
+    canRestore: true,
+    daysRemaining,
+    daysExpired: 0,
+    expiresAt
+  };
+}
+
 // src/mutations/brands.ts
 async function createBrand(client, input) {
   try {
@@ -25,6 +59,53 @@ async function updateBrand(client, input) {
     throw error;
   }
 }
+async function softDeleteBrand(client, id, deletedBy) {
+  try {
+    const { errors } = await client.models.Brand.update({
+      id,
+      status: "deleted",
+      deletedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      deletedBy
+    });
+    if (errors) {
+      console.error("[softDeleteBrand] GraphQL errors:", errors);
+      return false;
+    }
+    return true;
+  } catch (error) {
+    console.error("[softDeleteBrand] Error soft-deleting brand:", error);
+    throw error;
+  }
+}
+async function restoreBrand(client, id, retentionDays = DEFAULT_SOFT_DELETE_RETENTION_DAYS) {
+  try {
+    const { data: brand, errors: getErrors } = await client.models.Brand.get({ id });
+    if (getErrors || !brand) {
+      console.error("[restoreBrand] Error fetching brand:", getErrors);
+      return { success: false, error: "Brand not found" };
+    }
+    const eligibility = checkRestoreEligibility(brand.deletedAt, retentionDays);
+    if (!eligibility.canRestore) {
+      const errorMsg = `Cannot restore brand. Retention period of ${retentionDays} days has expired. Item was deleted ${eligibility.daysExpired} days ago.`;
+      console.error("[restoreBrand]", errorMsg);
+      return { success: false, error: errorMsg };
+    }
+    const { errors } = await client.models.Brand.update({
+      id,
+      status: "active",
+      deletedAt: null,
+      deletedBy: null
+    });
+    if (errors) {
+      console.error("[restoreBrand] GraphQL errors:", errors);
+      return { success: false, error: "Failed to restore brand" };
+    }
+    return { success: true };
+  } catch (error) {
+    console.error("[restoreBrand] Error restoring brand:", error);
+    throw error;
+  }
+}
 async function deleteBrand(client, id) {
   try {
     const { errors } = await client.models.Brand.delete({ id });
@@ -66,6 +147,53 @@ async function updateAccount(client, input) {
     throw error;
   }
 }
+async function softDeleteAccount(client, id, deletedBy) {
+  try {
+    const { errors } = await client.models.Account.update({
+      id,
+      status: "deleted",
+      deletedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      deletedBy
+    });
+    if (errors) {
+      console.error("[softDeleteAccount] GraphQL errors:", errors);
+      return false;
+    }
+    return true;
+  } catch (error) {
+    console.error("[softDeleteAccount] Error soft-deleting account:", error);
+    throw error;
+  }
+}
+async function restoreAccount(client, id, retentionDays = DEFAULT_SOFT_DELETE_RETENTION_DAYS) {
+  try {
+    const { data: account, errors: getErrors } = await client.models.Account.get({ id });
+    if (getErrors || !account) {
+      console.error("[restoreAccount] Error fetching account:", getErrors);
+      return { success: false, error: "Account not found" };
+    }
+    const eligibility = checkRestoreEligibility(account.deletedAt, retentionDays);
+    if (!eligibility.canRestore) {
+      const errorMsg = `Cannot restore account. Retention period of ${retentionDays} days has expired. Item was deleted ${eligibility.daysExpired} days ago.`;
+      console.error("[restoreAccount]", errorMsg);
+      return { success: false, error: errorMsg };
+    }
+    const { errors } = await client.models.Account.update({
+      id,
+      status: "active",
+      deletedAt: null,
+      deletedBy: null
+    });
+    if (errors) {
+      console.error("[restoreAccount] GraphQL errors:", errors);
+      return { success: false, error: "Failed to restore account" };
+    }
+    return { success: true };
+  } catch (error) {
+    console.error("[restoreAccount] Error restoring account:", error);
+    throw error;
+  }
+}
 async function deleteAccount(client, id) {
   try {
     const { errors } = await client.models.Account.delete({ id });
@@ -107,6 +235,53 @@ async function updateUser(client, input) {
     throw error;
   }
 }
+async function softDeleteUser(client, id, deletedBy) {
+  try {
+    const { errors } = await client.models.User.update({
+      id,
+      status: "deleted",
+      deletedAt: (/* @__PURE__ */ 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;
+  }
+}
+async function restoreUser(client, id, retentionDays = DEFAULT_SOFT_DELETE_RETENTION_DAYS) {
+  try {
+    const { data: user, errors: getErrors } = await client.models.User.get({ id });
+    if (getErrors || !user) {
+      console.error("[restoreUser] Error fetching user:", getErrors);
+      return { success: false, error: "User not found" };
+    }
+    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.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;
+  }
+}
 async function deleteUser(client, id) {
   try {
     const { errors } = await client.models.User.delete({ id });
@@ -120,15 +295,237 @@ async function deleteUser(client, id) {
     throw error;
   }
 }
+
+// src/mutations/productInstances/productInstances.ts
+import { getClientUser } from "@htlkg/core/auth";
+import { getCurrentTimestamp } from "@htlkg/core/utils";
+import { AppError } from "@htlkg/core/errors";
+async function getUserIdentifier(fallback = "system") {
+  try {
+    const user = await getClientUser();
+    if (user) {
+      return user.email || user.username || fallback;
+    }
+    return fallback;
+  } catch {
+    return fallback;
+  }
+}
+async function createProductInstance(client, input) {
+  try {
+    const createInput = {
+      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()
+    };
+    if (input.config) {
+      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.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;
+  } 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 }
+    );
+  }
+}
+async function updateProductInstance(client, input) {
+  try {
+    const updateInput = {
+      ...input,
+      lastUpdated: input.lastUpdated || getCurrentTimestamp(),
+      updatedBy: input.updatedBy || await getUserIdentifier()
+    };
+    if (input.config) {
+      updateInput.config = JSON.stringify(JSON.parse(JSON.stringify(input.config)));
+    }
+    const { data, errors } = await client.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;
+  } 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 }
+    );
+  }
+}
+async function deleteProductInstance(client, id) {
+  try {
+    const { errors } = await client.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 }
+    );
+  }
+}
+async function toggleProductInstanceEnabled(client, id, enabled) {
+  try {
+    const { data, errors } = await client.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;
+  } 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 }
+    );
+  }
+}
+
+// src/mutations/systemSettings.ts
+async function updateSystemSettings(client, input) {
+  try {
+    if (input.softDeleteRetentionDays < 1 || input.softDeleteRetentionDays > 365) {
+      console.error(
+        "[updateSystemSettings] Invalid retention days. Must be between 1 and 365."
+      );
+      return null;
+    }
+    const { data: existing } = await client.models.SystemSettings.get({
+      key: SYSTEM_SETTINGS_KEY
+    });
+    const settingsData = {
+      key: SYSTEM_SETTINGS_KEY,
+      softDeleteRetentionDays: input.softDeleteRetentionDays,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedBy: input.updatedBy
+    };
+    let result;
+    if (existing) {
+      result = await client.models.SystemSettings.update(settingsData);
+    } else {
+      result = await client.models.SystemSettings.create(settingsData);
+    }
+    if (result.errors) {
+      console.error("[updateSystemSettings] GraphQL errors:", result.errors);
+      return null;
+    }
+    return result.data;
+  } catch (error) {
+    console.error("[updateSystemSettings] Error updating system settings:", error);
+    throw error;
+  }
+}
+async function initializeSystemSettings(client, initializedBy) {
+  try {
+    const { data: existing } = await client.models.SystemSettings.get({
+      key: SYSTEM_SETTINGS_KEY
+    });
+    if (existing) {
+      return existing;
+    }
+    const { data, errors } = await client.models.SystemSettings.create({
+      key: SYSTEM_SETTINGS_KEY,
+      softDeleteRetentionDays: DEFAULT_SOFT_DELETE_RETENTION_DAYS,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedBy: initializedBy
+    });
+    if (errors) {
+      console.error("[initializeSystemSettings] GraphQL errors:", errors);
+      return null;
+    }
+    return data;
+  } catch (error) {
+    console.error(
+      "[initializeSystemSettings] Error initializing system settings:",
+      error
+    );
+    throw error;
+  }
+}
 export {
   createAccount,
   createBrand,
+  createProductInstance,
   createUser,
   deleteAccount,
   deleteBrand,
+  deleteProductInstance,
   deleteUser,
+  initializeSystemSettings,
+  restoreAccount,
+  restoreBrand,
+  restoreUser,
+  softDeleteAccount,
+  softDeleteBrand,
+  softDeleteUser,
+  toggleProductInstanceEnabled,
   updateAccount,
   updateBrand,
+  updateProductInstance,
+  updateSystemSettings,
   updateUser
 };
 //# sourceMappingURL=index.js.map