@htlkg/data 0.0.14 → 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 });
@@ -508,6 +751,216 @@ async function deleteUser(client, id) {
   }
 }
 
+// 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;
+  }
+}
+
 // src/hooks/createDataHook.ts
 import { ref, computed, onMounted } from "vue";
 function createDataHook(config) {
@@ -516,7 +969,7 @@ function createDataHook(config) {
     defaultLimit,
     selectionSet,
     transform,
-    buildFilter: buildFilter4,
+    buildFilter: buildFilter5,
     computedProperties,
     dataPropertyName = "data"
   } = config;
@@ -526,12 +979,12 @@ function createDataHook(config) {
     const loading = ref(false);
     const error = ref(null);
     const getFilter = () => {
-      if (buildFilter4) {
-        return buildFilter4(options);
+      if (buildFilter5) {
+        return buildFilter5(options);
       }
       return baseFilter && Object.keys(baseFilter).length > 0 ? baseFilter : void 0;
     };
-    async function fetch() {
+    async function fetch2() {
       loading.value = true;
       error.value = null;
       try {
@@ -564,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") {
@@ -682,6 +1135,74 @@ function useProducts(options = {}) {
   };
 }
 
+// src/hooks/useProductInstances.ts
+function buildFilter4(options) {
+  let filter = options.filter || {};
+  if (options.brandId) {
+    filter = { ...filter, brandId: { eq: options.brandId } };
+  }
+  if (options.accountId) {
+    filter = { ...filter, accountId: { eq: options.accountId } };
+  }
+  if (options.productId) {
+    filter = { ...filter, productId: { eq: options.productId } };
+  }
+  if (options.enabledOnly) {
+    filter = { ...filter, enabled: { eq: true } };
+  }
+  return Object.keys(filter).length > 0 ? filter : void 0;
+}
+var useProductInstancesInternal = createDataHook({
+  model: "ProductInstance",
+  dataPropertyName: "instances",
+  buildFilter: buildFilter4,
+  computedProperties: {
+    enabledInstances: (instances) => instances.filter((i) => i.enabled)
+  }
+});
+function useProductInstances(options = {}) {
+  const result = useProductInstancesInternal(options);
+  async function createInstance(input) {
+    const client = getSharedClient();
+    const instance = await createProductInstance(client, input);
+    if (!instance) {
+      throw new Error("Failed to create product instance");
+    }
+    return instance;
+  }
+  async function updateInstance(input) {
+    const client = getSharedClient();
+    const instance = await updateProductInstance(client, input);
+    if (!instance) {
+      throw new Error("Failed to update product instance");
+    }
+    return instance;
+  }
+  async function deleteInstance(id) {
+    const client = getSharedClient();
+    return deleteProductInstance(client, id);
+  }
+  async function toggleEnabled(id, enabled) {
+    const client = getSharedClient();
+    const instance = await toggleProductInstanceEnabled(client, id, enabled);
+    if (!instance) {
+      throw new Error("Failed to toggle product instance");
+    }
+    return instance;
+  }
+  return {
+    instances: result.instances,
+    enabledInstances: result.enabledInstances,
+    loading: result.loading,
+    error: result.error,
+    refetch: result.refetch,
+    createInstance,
+    updateInstance,
+    deleteInstance,
+    toggleEnabled
+  };
+}
+
 // ../../node_modules/.pnpm/nanostores@1.1.0/node_modules/nanostores/clean-stores/index.js
 var clean = /* @__PURE__ */ Symbol("clean");
 
@@ -785,15 +1306,20 @@ function createSingleStore(shared, name, defaultValue) {
   return shared(name, atom(defaultValue));
 }
 export {
+  DEFAULT_SOFT_DELETE_RETENTION_DAYS,
+  SYSTEM_SETTINGS_KEY,
+  checkRestoreEligibility,
   createAccount,
   createBrand,
   createDataHook,
+  createProductInstance,
   createResourceStores,
   createSingleStore,
   createStore,
   createUser,
   deleteAccount,
   deleteBrand,
+  deleteProductInstance,
   deleteUser,
   executePublicQuery,
   executeServerQuery,
@@ -803,12 +1329,17 @@ export {
   getAccountWithBrands,
   getBrand,
   getBrandWithProducts,
+  getErrorMessage,
   getProduct,
   getProductInstance,
   getSharedClient,
+  getSoftDeleteRetentionDays,
+  getSystemSettings,
   getUser,
   getUserByCognitoId,
   getUserByEmail,
+  hasErrors,
+  initializeSystemSettings,
   listAccounts,
   listActiveBrands,
   listActiveProducts,
@@ -821,13 +1352,25 @@ export {
   listProducts,
   listUsers,
   listUsersByAccount,
+  mutate,
+  query,
   resetSharedClient as resetClientInstance,
   resetSharedClient,
+  restoreAccount,
+  restoreBrand,
+  restoreUser,
+  softDeleteAccount,
+  softDeleteBrand,
+  softDeleteUser,
+  toggleProductInstanceEnabled,
   updateAccount,
   updateBrand,
+  updateProductInstance,
+  updateSystemSettings,
   updateUser,
   useAccounts,
   useBrands,
+  useProductInstances,
   useProducts,
   useUsers
 };