@htlkg/data 0.0.15 → 0.0.16

package/dist/index.js

@@ -1,5 +1,6 @@
 // src/client/index.ts
 import { generateClient as generateDataClient } from "aws-amplify/data";
+import { Amplify } from "aws-amplify";
 
 // src/client/server.ts
 import {
@@ -9,6 +10,54 @@ import { getAmplifyServerContext } from "aws-amplify/adapter-core/internals";
 import { createRunWithAmplifyServerContext, createLogger } from "@htlkg/core/amplify-astro-adapter";
 var log = createLogger("server-client");
 
+// src/client/proxy.ts
+var DEFAULT_ENDPOINT = "/api/graphql";
+async function mutate(model, operation, data, options) {
+  return proxyRequest(model, operation, data, options);
+}
+async function query(model, operation, data, options) {
+  return proxyRequest(model, operation, data, options);
+}
+async function proxyRequest(model, operation, data, options) {
+  const endpoint = options?.endpoint ?? DEFAULT_ENDPOINT;
+  try {
+    const response = await fetch(endpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      credentials: "include",
+      // Important: include cookies
+      ...options?.fetchOptions,
+      body: JSON.stringify({ model, operation, data })
+    });
+    const result = await response.json();
+    if (response.status === 401) {
+      console.error("[GraphQL Proxy] Unauthorized - session may have expired");
+    }
+    return result;
+  } catch (error) {
+    console.error("[GraphQL Proxy] Request failed:", error);
+    return {
+      data: null,
+      errors: [
+        {
+          message: error instanceof Error ? error.message : "Network error"
+        }
+      ]
+    };
+  }
+}
+function hasErrors(response) {
+  return !!response.errors && response.errors.length > 0;
+}
+function getErrorMessage(response) {
+  if (!response.errors || response.errors.length === 0) {
+    return null;
+  }
+  return response.errors[0].message;
+}
+
 // src/client/index.ts
 var sharedClientInstance = null;
 function getSharedClient() {
@@ -23,7 +72,7 @@ function resetSharedClient() {
 function generateClient() {
   return generateDataClient();
 }
-function generateServerClient(options) {
+function generateServerClient(_options) {
   const client = generateDataClient();
   return client;
 }
@@ -385,6 +434,59 @@ async function executePublicQuery(astro, runWithAmplifyServerContext, operation)
   return result;
 }
 
+// src/queries/systemSettings.ts
+var DEFAULT_SOFT_DELETE_RETENTION_DAYS = 30;
+var SYSTEM_SETTINGS_KEY = "GLOBAL";
+async function getSystemSettings(client) {
+  try {
+    const { data, errors } = await client.models.SystemSettings.get({
+      key: SYSTEM_SETTINGS_KEY
+    });
+    if (errors) {
+      console.error("[getSystemSettings] GraphQL errors:", errors);
+      return null;
+    }
+    return data;
+  } catch (error) {
+    console.error("[getSystemSettings] Error fetching system settings:", error);
+    throw error;
+  }
+}
+async function getSoftDeleteRetentionDays(client) {
+  const settings = await getSystemSettings(client);
+  return settings?.softDeleteRetentionDays ?? DEFAULT_SOFT_DELETE_RETENTION_DAYS;
+}
+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 {
@@ -412,6 +514,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 });
@@ -453,6 +602,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 });
@@ -494,6 +690,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 });
@@ -656,6 +899,68 @@ async function toggleProductInstanceEnabled(client, id, enabled) {
   }
 }
 
+// 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;
+  }
+}
+
 // src/hooks/createDataHook.ts
 import { ref, computed, onMounted } from "vue";
 function createDataHook(config) {
@@ -679,7 +984,7 @@ function createDataHook(config) {
       }
       return baseFilter && Object.keys(baseFilter).length > 0 ? baseFilter : void 0;
     };
-    async function fetch() {
+    async function fetch2() {
       loading.value = true;
       error.value = null;
       try {
@@ -712,14 +1017,14 @@ function createDataHook(config) {
     }
     if (autoFetch) {
       onMounted(() => {
-        fetch();
+        fetch2();
       });
     }
     const result = {
       data,
       loading,
       error,
-      refetch: fetch,
+      refetch: fetch2,
       computed: computedRefs
     };
     if (dataPropertyName !== "data") {
@@ -1001,6 +1306,9 @@ function createSingleStore(shared, name, defaultValue) {
   return shared(name, atom(defaultValue));
 }
 export {
+  DEFAULT_SOFT_DELETE_RETENTION_DAYS,
+  SYSTEM_SETTINGS_KEY,
+  checkRestoreEligibility,
   createAccount,
   createBrand,
   createDataHook,
@@ -1021,12 +1329,17 @@ export {
   getAccountWithBrands,
   getBrand,
   getBrandWithProducts,
+  getErrorMessage,
   getProduct,
   getProductInstance,
   getSharedClient,
+  getSoftDeleteRetentionDays,
+  getSystemSettings,
   getUser,
   getUserByCognitoId,
   getUserByEmail,
+  hasErrors,
+  initializeSystemSettings,
   listAccounts,
   listActiveBrands,
   listActiveProducts,
@@ -1039,12 +1352,21 @@ export {
   listProducts,
   listUsers,
   listUsersByAccount,
+  mutate,
+  query,
   resetSharedClient as resetClientInstance,
   resetSharedClient,
+  restoreAccount,
+  restoreBrand,
+  restoreUser,
+  softDeleteAccount,
+  softDeleteBrand,
+  softDeleteUser,
   toggleProductInstanceEnabled,
   updateAccount,
   updateBrand,
   updateProductInstance,
+  updateSystemSettings,
   updateUser,
   useAccounts,
   useBrands,