@htlkg/data 0.0.1

package/dist/index.js

@@ -0,0 +1,711 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+
+// ../../node_modules/.pnpm/aws-amplify@6.15.8/node_modules/aws-amplify/dist/esm/api/index.mjs
+var api_exports = {};
+__reExport(api_exports, api_star);
+import * as api_star from "@aws-amplify/api";
+
+// src/client/index.ts
+function generateClient() {
+  return (0, api_exports.generateClient)();
+}
+function generateServerClient(options) {
+  throw new Error(
+    "[generateServerClient] Not yet implemented in modular architecture. Please use generateServerClient from @htlkg/shared/lib/graphql for now. This will be properly implemented when the Amplify Astro adapter is migrated."
+  );
+}
+
+// src/queries/brands.ts
+async function getBrand(client, id) {
+  try {
+    const { data, errors } = await client.models.Brand.get({ id });
+    if (errors) {
+      console.error("[getBrand] GraphQL errors:", errors);
+      return null;
+    }
+    return data;
+  } catch (error) {
+    console.error("[getBrand] Error fetching brand:", error);
+    throw error;
+  }
+}
+async function listBrands(client, options) {
+  try {
+    const { data, errors, nextToken } = await client.models.Brand.list(
+      options
+    );
+    if (errors) {
+      console.error("[listBrands] GraphQL errors:", errors);
+      return { items: [], nextToken: void 0 };
+    }
+    return {
+      items: data || [],
+      nextToken
+    };
+  } catch (error) {
+    console.error("[listBrands] Error fetching brands:", error);
+    throw error;
+  }
+}
+async function getBrandWithProducts(client, id) {
+  try {
+    const { data, errors } = await client.models.Brand.get(
+      { id },
+      {
+        selectionSet: [
+          "id",
+          "name",
+          "accountId",
+          "logo",
+          "timezone",
+          "status",
+          "settings",
+          "productInstances.*"
+        ]
+      }
+    );
+    if (errors) {
+      console.error("[getBrandWithProducts] GraphQL errors:", errors);
+      return null;
+    }
+    return data;
+  } catch (error) {
+    console.error("[getBrandWithProducts] Error fetching brand:", error);
+    throw error;
+  }
+}
+async function listBrandsByAccount(client, accountId, options) {
+  return listBrands(client, {
+    filter: { accountId: { eq: accountId } },
+    ...options
+  });
+}
+async function listActiveBrands(client, options) {
+  return listBrands(client, {
+    filter: { status: { eq: "active" } },
+    ...options
+  });
+}
+
+// src/queries/accounts.ts
+async function getAccount(client, id) {
+  try {
+    const { data, errors } = await client.models.Account.get({ id });
+    if (errors) {
+      console.error("[getAccount] GraphQL errors:", errors);
+      return null;
+    }
+    return data;
+  } catch (error) {
+    console.error("[getAccount] Error fetching account:", error);
+    throw error;
+  }
+}
+async function listAccounts(client, options) {
+  try {
+    const { data, errors, nextToken } = await client.models.Account.list(options);
+    if (errors) {
+      console.error("[listAccounts] GraphQL errors:", errors);
+      return { items: [], nextToken: void 0 };
+    }
+    return {
+      items: data || [],
+      nextToken
+    };
+  } catch (error) {
+    console.error("[listAccounts] Error fetching accounts:", error);
+    throw error;
+  }
+}
+async function getAccountWithBrands(client, id) {
+  try {
+    const { data, errors } = await client.models.Account.get(
+      { id },
+      {
+        selectionSet: [
+          "id",
+          "name",
+          "logo",
+          "subscription",
+          "settings",
+          "brands.*"
+        ]
+      }
+    );
+    if (errors) {
+      console.error("[getAccountWithBrands] GraphQL errors:", errors);
+      return null;
+    }
+    return data;
+  } catch (error) {
+    console.error("[getAccountWithBrands] Error fetching account:", error);
+    throw error;
+  }
+}
+
+// src/queries/users.ts
+async function getUser(client, id) {
+  try {
+    const { data, errors } = await client.models.User.get({ id });
+    if (errors) {
+      console.error("[getUser] GraphQL errors:", errors);
+      return null;
+    }
+    return data;
+  } catch (error) {
+    console.error("[getUser] Error fetching user:", error);
+    throw error;
+  }
+}
+async function getUserByCognitoId(client, cognitoId) {
+  try {
+    const { data, errors } = await client.models.User.list({
+      filter: { cognitoId: { eq: cognitoId } },
+      limit: 1
+    });
+    if (errors) {
+      console.error("[getUserByCognitoId] GraphQL errors:", errors);
+      return null;
+    }
+    return data?.[0];
+  } catch (error) {
+    console.error("[getUserByCognitoId] Error fetching user:", error);
+    throw error;
+  }
+}
+async function getUserByEmail(client, email) {
+  try {
+    const { data, errors } = await client.models.User.list({
+      filter: { email: { eq: email } },
+      limit: 1
+    });
+    if (errors) {
+      console.error("[getUserByEmail] GraphQL errors:", errors);
+      return null;
+    }
+    return data?.[0];
+  } catch (error) {
+    console.error("[getUserByEmail] Error fetching user:", error);
+    throw error;
+  }
+}
+async function listUsers(client, options) {
+  try {
+    const { data, errors, nextToken } = await client.models.User.list(
+      options
+    );
+    if (errors) {
+      console.error("[listUsers] GraphQL errors:", errors);
+      return { items: [], nextToken: void 0 };
+    }
+    return {
+      items: data || [],
+      nextToken
+    };
+  } catch (error) {
+    console.error("[listUsers] Error fetching users:", error);
+    throw error;
+  }
+}
+async function listUsersByAccount(client, accountId, options) {
+  return listUsers(client, {
+    filter: { accountId: { eq: accountId } },
+    ...options
+  });
+}
+async function listActiveUsers(client, options) {
+  return listUsers(client, {
+    filter: { status: { eq: "active" } },
+    ...options
+  });
+}
+
+// src/queries/products.ts
+async function getProduct(client, id) {
+  try {
+    const { data, errors } = await client.models.Product.get({ id });
+    if (errors) {
+      console.error("[getProduct] GraphQL errors:", errors);
+      return null;
+    }
+    return data;
+  } catch (error) {
+    console.error("[getProduct] Error fetching product:", error);
+    throw error;
+  }
+}
+async function listProducts(client, options) {
+  try {
+    const { data, errors, nextToken } = await client.models.Product.list(options);
+    if (errors) {
+      console.error("[listProducts] GraphQL errors:", errors);
+      return { items: [], nextToken: void 0 };
+    }
+    return {
+      items: data || [],
+      nextToken
+    };
+  } catch (error) {
+    console.error("[listProducts] Error fetching products:", error);
+    throw error;
+  }
+}
+async function listActiveProducts(client, options) {
+  return listProducts(client, {
+    filter: { isActive: { eq: true } },
+    ...options
+  });
+}
+async function getProductInstance(client, id) {
+  try {
+    const { data, errors } = await client.models.ProductInstance.get({
+      id
+    });
+    if (errors) {
+      console.error("[getProductInstance] GraphQL errors:", errors);
+      return null;
+    }
+    return data;
+  } catch (error) {
+    console.error("[getProductInstance] Error fetching product instance:", error);
+    throw error;
+  }
+}
+async function listProductInstancesByBrand(client, brandId, options) {
+  try {
+    const { data, errors, nextToken } = await client.models.ProductInstance.list({
+      filter: { brandId: { eq: brandId } },
+      ...options
+    });
+    if (errors) {
+      console.error("[listProductInstancesByBrand] GraphQL errors:", errors);
+      return { items: [], nextToken: void 0 };
+    }
+    return {
+      items: data || [],
+      nextToken
+    };
+  } catch (error) {
+    console.error(
+      "[listProductInstancesByBrand] Error fetching product instances:",
+      error
+    );
+    throw error;
+  }
+}
+async function listProductInstancesByAccount(client, accountId, options) {
+  try {
+    const { data, errors, nextToken } = await client.models.ProductInstance.list({
+      filter: { accountId: { eq: accountId } },
+      ...options
+    });
+    if (errors) {
+      console.error("[listProductInstancesByAccount] GraphQL errors:", errors);
+      return { items: [], nextToken: void 0 };
+    }
+    return {
+      items: data || [],
+      nextToken
+    };
+  } catch (error) {
+    console.error(
+      "[listProductInstancesByAccount] Error fetching product instances:",
+      error
+    );
+    throw error;
+  }
+}
+async function listEnabledProductInstancesByBrand(client, brandId, options) {
+  try {
+    const { data, errors, nextToken } = await client.models.ProductInstance.list({
+      filter: {
+        brandId: { eq: brandId },
+        enabled: { eq: true }
+      },
+      ...options
+    });
+    if (errors) {
+      console.error(
+        "[listEnabledProductInstancesByBrand] GraphQL errors:",
+        errors
+      );
+      return { items: [], nextToken: void 0 };
+    }
+    return {
+      items: data || [],
+      nextToken
+    };
+  } catch (error) {
+    console.error(
+      "[listEnabledProductInstancesByBrand] Error fetching product instances:",
+      error
+    );
+    throw error;
+  }
+}
+
+// src/mutations/brands.ts
+async function createBrand(client, input) {
+  try {
+    const { data, errors } = await client.models.Brand.create(input);
+    if (errors) {
+      console.error("[createBrand] GraphQL errors:", errors);
+      return null;
+    }
+    return data;
+  } catch (error) {
+    console.error("[createBrand] Error creating brand:", error);
+    throw error;
+  }
+}
+async function updateBrand(client, input) {
+  try {
+    const { data, errors } = await client.models.Brand.update(input);
+    if (errors) {
+      console.error("[updateBrand] GraphQL errors:", errors);
+      return null;
+    }
+    return data;
+  } catch (error) {
+    console.error("[updateBrand] Error updating brand:", error);
+    throw error;
+  }
+}
+async function deleteBrand(client, id) {
+  try {
+    const { errors } = await client.models.Brand.delete({ id });
+    if (errors) {
+      console.error("[deleteBrand] GraphQL errors:", errors);
+      return false;
+    }
+    return true;
+  } catch (error) {
+    console.error("[deleteBrand] Error deleting brand:", error);
+    throw error;
+  }
+}
+
+// src/mutations/accounts.ts
+async function createAccount(client, input) {
+  try {
+    const { data, errors } = await client.models.Account.create(input);
+    if (errors) {
+      console.error("[createAccount] GraphQL errors:", errors);
+      return null;
+    }
+    return data;
+  } catch (error) {
+    console.error("[createAccount] Error creating account:", error);
+    throw error;
+  }
+}
+async function updateAccount(client, input) {
+  try {
+    const { data, errors } = await client.models.Account.update(input);
+    if (errors) {
+      console.error("[updateAccount] GraphQL errors:", errors);
+      return null;
+    }
+    return data;
+  } catch (error) {
+    console.error("[updateAccount] Error updating account:", error);
+    throw error;
+  }
+}
+async function deleteAccount(client, id) {
+  try {
+    const { errors } = await client.models.Account.delete({ id });
+    if (errors) {
+      console.error("[deleteAccount] GraphQL errors:", errors);
+      return false;
+    }
+    return true;
+  } catch (error) {
+    console.error("[deleteAccount] Error deleting account:", error);
+    throw error;
+  }
+}
+
+// src/mutations/users.ts
+async function createUser(client, input) {
+  try {
+    const { data, errors } = await client.models.User.create(input);
+    if (errors) {
+      console.error("[createUser] GraphQL errors:", errors);
+      return null;
+    }
+    return data;
+  } catch (error) {
+    console.error("[createUser] Error creating user:", error);
+    throw error;
+  }
+}
+async function updateUser(client, input) {
+  try {
+    const { data, errors } = await client.models.User.update(input);
+    if (errors) {
+      console.error("[updateUser] GraphQL errors:", errors);
+      return null;
+    }
+    return data;
+  } catch (error) {
+    console.error("[updateUser] Error updating user:", error);
+    throw error;
+  }
+}
+async function deleteUser(client, id) {
+  try {
+    const { errors } = await client.models.User.delete({ id });
+    if (errors) {
+      console.error("[deleteUser] GraphQL errors:", errors);
+      return false;
+    }
+    return true;
+  } catch (error) {
+    console.error("[deleteUser] Error deleting user:", error);
+    throw error;
+  }
+}
+
+// src/hooks/useBrands.ts
+import { ref, computed, onMounted } from "vue";
+function useBrands(options = {}) {
+  const {
+    filter: baseFilter,
+    limit,
+    autoFetch = true,
+    accountId,
+    activeOnly
+  } = options;
+  const brands = ref([]);
+  const loading = ref(false);
+  const error = ref(null);
+  let filter = baseFilter || {};
+  if (accountId) {
+    filter = { ...filter, accountId: { eq: accountId } };
+  }
+  if (activeOnly) {
+    filter = { ...filter, status: { eq: "active" } };
+  }
+  const activeBrands = computed(
+    () => brands.value.filter((b) => b.status === "active")
+  );
+  async function fetch() {
+    loading.value = true;
+    error.value = null;
+    try {
+      const client = generateClient();
+      const { data, errors } = await client.models.Brand.list({
+        filter: Object.keys(filter).length > 0 ? filter : void 0,
+        limit
+      });
+      if (errors) {
+        throw new Error(errors[0]?.message || "Failed to fetch brands");
+      }
+      brands.value = data || [];
+    } catch (e) {
+      error.value = e;
+      console.error("[useBrands] Error fetching brands:", e);
+    } finally {
+      loading.value = false;
+    }
+  }
+  if (autoFetch) {
+    onMounted(() => {
+      fetch();
+    });
+  }
+  return {
+    brands,
+    activeBrands,
+    loading,
+    error,
+    refetch: fetch
+  };
+}
+
+// src/hooks/useAccounts.ts
+import { ref as ref2, onMounted as onMounted2 } from "vue";
+function useAccounts(options = {}) {
+  const { filter, limit, autoFetch = true } = options;
+  const accounts = ref2([]);
+  const loading = ref2(false);
+  const error = ref2(null);
+  async function fetch() {
+    loading.value = true;
+    error.value = null;
+    try {
+      const client = generateClient();
+      const { data, errors } = await client.models.Account.list({
+        filter,
+        limit
+      });
+      if (errors) {
+        throw new Error(errors[0]?.message || "Failed to fetch accounts");
+      }
+      accounts.value = data || [];
+    } catch (e) {
+      error.value = e;
+      console.error("[useAccounts] Error fetching accounts:", e);
+    } finally {
+      loading.value = false;
+    }
+  }
+  if (autoFetch) {
+    onMounted2(() => {
+      fetch();
+    });
+  }
+  return {
+    accounts,
+    loading,
+    error,
+    refetch: fetch
+  };
+}
+
+// src/hooks/useUsers.ts
+import { ref as ref3, onMounted as onMounted3 } from "vue";
+function useUsers(options = {}) {
+  const { filter: baseFilter, limit, autoFetch = true, brandId, accountId } = options;
+  const users = ref3([]);
+  const loading = ref3(false);
+  const error = ref3(null);
+  let filter = baseFilter || {};
+  if (brandId) {
+    filter = { ...filter, brandIds: { contains: brandId } };
+  }
+  if (accountId) {
+    filter = { ...filter, accountIds: { contains: accountId } };
+  }
+  async function fetch() {
+    loading.value = true;
+    error.value = null;
+    try {
+      const client = generateClient();
+      const { data, errors } = await client.models.User.list({
+        filter: Object.keys(filter).length > 0 ? filter : void 0,
+        limit
+      });
+      if (errors) {
+        throw new Error(errors[0]?.message || "Failed to fetch users");
+      }
+      users.value = data || [];
+    } catch (e) {
+      error.value = e;
+      console.error("[useUsers] Error fetching users:", e);
+    } finally {
+      loading.value = false;
+    }
+  }
+  if (autoFetch) {
+    onMounted3(() => {
+      fetch();
+    });
+  }
+  return {
+    users,
+    loading,
+    error,
+    refetch: fetch
+  };
+}
+
+// src/hooks/useProducts.ts
+import { ref as ref4, computed as computed2, onMounted as onMounted4 } from "vue";
+function useProducts(options = {}) {
+  const { filter: baseFilter, limit, autoFetch = true, activeOnly } = options;
+  const products = ref4([]);
+  const loading = ref4(false);
+  const error = ref4(null);
+  let filter = baseFilter || {};
+  if (activeOnly) {
+    filter = { ...filter, isActive: { eq: true } };
+  }
+  const activeProducts = computed2(
+    () => products.value.filter((p) => p.isActive === true)
+  );
+  async function fetch() {
+    loading.value = true;
+    error.value = null;
+    try {
+      const client = generateClient();
+      const { data, errors } = await client.models.Product.list({
+        filter: Object.keys(filter).length > 0 ? filter : void 0,
+        limit
+      });
+      if (errors) {
+        throw new Error(errors[0]?.message || "Failed to fetch products");
+      }
+      products.value = data || [];
+    } catch (e) {
+      error.value = e;
+      console.error("[useProducts] Error fetching products:", e);
+    } finally {
+      loading.value = false;
+    }
+  }
+  if (autoFetch) {
+    onMounted4(() => {
+      fetch();
+    });
+  }
+  return {
+    products,
+    activeProducts,
+    loading,
+    error,
+    refetch: fetch
+  };
+}
+export {
+  createAccount,
+  createBrand,
+  createUser,
+  deleteAccount,
+  deleteBrand,
+  deleteUser,
+  generateClient,
+  generateServerClient,
+  getAccount,
+  getAccountWithBrands,
+  getBrand,
+  getBrandWithProducts,
+  getProduct,
+  getProductInstance,
+  getUser,
+  getUserByCognitoId,
+  getUserByEmail,
+  listAccounts,
+  listActiveBrands,
+  listActiveProducts,
+  listActiveUsers,
+  listBrands,
+  listBrandsByAccount,
+  listEnabledProductInstancesByBrand,
+  listProductInstancesByAccount,
+  listProductInstancesByBrand,
+  listProducts,
+  listUsers,
+  listUsersByAccount,
+  updateAccount,
+  updateBrand,
+  updateUser,
+  useAccounts,
+  useBrands,
+  useProducts,
+  useUsers
+};
+//# sourceMappingURL=index.js.map