amplifyquery 1.0.0

package/dist/service.js

@@ -0,0 +1,1236 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAmplifyService = createAmplifyService;
+const client_1 = require("./client");
+const query_1 = require("./query");
+const utils_1 = require("./utils");
+const react_query_1 = require("@tanstack/react-query");
+const auth_1 = require("aws-amplify/auth");
+const expo_crypto_1 = require("expo-crypto");
+const react_1 = require("react");
+/**
+ * Utility function to get owner value based on authentication mode
+ * Sets owner value only in userPool auth mode, returns empty string for other auth modes
+ *
+ * @param authMode Current authentication mode
+ * @returns Owner value and API call parameters based on auth mode
+ */
+function getOwnerByAuthMode(authMode) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let owner = "";
+        // Set owner value only in userPool auth mode
+        if (authMode === "userPool") {
+            try {
+                const { username, userId } = yield (0, auth_1.getCurrentUser)();
+                owner = userId + "::" + username;
+            }
+            catch (error) {
+                console.error("Error getting user authentication info:", error);
+                // Continue even if error occurs (API call will fail)
+            }
+        }
+        // Return with auth mode parameters
+        return {
+            owner,
+            authModeParams: { authMode },
+        };
+    });
+}
+/**
+ * Find all related query keys
+ * @param modelName Model name
+ * @param queryClient TanStack QueryClient instance
+ * @returns Array of related query keys (readonly unknown[] type)
+ */
+function findRelatedQueryKeys(modelName, queryClient) {
+    // Extract only query keys from Query objects array
+    return queryClient
+        .getQueryCache()
+        .findAll({
+        predicate: ({ queryKey }) => {
+            // Find all query keys starting with model name
+            // Example: ["Mission"], ["Mission", "filter", ...], ["Daily", dailyId, "Mission"]
+            return Array.isArray(queryKey) && queryKey[0] === modelName;
+        },
+    })
+        .map((query) => query.queryKey);
+}
+/**
+ * Helper function to handle optimistic updates and cache updates for a single item
+ * @param queryClient TanStack QueryClient instance
+ * @param modelName Model name
+ * @param relatedQueryKeys Array of related query keys to update
+ * @param itemId ID of item to update
+ * @param updateData Data to use for optimistic update (includes id)
+ * @returns Previous cache data (for rollback) - using QueryKey as key
+ */
+function performOptimisticUpdate(queryClient, modelName, relatedQueryKeys, itemId, updateData) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const previousDataMap = new Map();
+        // 1. Update individual item cache
+        const singleItemQueryKey = [modelName, itemId];
+        const previousItemSingle = queryClient.getQueryData(singleItemQueryKey);
+        previousDataMap.set(singleItemQueryKey, previousItemSingle);
+        // Merge with existing data if available, otherwise use updateData as optimistic data
+        const optimisticData = previousItemSingle
+            ? Object.assign(Object.assign({}, previousItemSingle), updateData)
+            : updateData; // updateData includes at least id here
+        queryClient.setQueryData(singleItemQueryKey, optimisticData);
+        // 2. Update list queries
+        relatedQueryKeys.forEach((queryKey) => {
+            // Process only list query keys since single item key is handled above
+            if (queryKey.length > 1 && queryKey[1] !== itemId) {
+                const previousItems = queryClient.getQueryData(queryKey);
+                previousDataMap.set(queryKey, previousItems); // Backup previous data
+                queryClient.setQueryData(queryKey, (oldData) => {
+                    // Safely handle if oldData is null, undefined or not an array
+                    const oldItems = Array.isArray(oldData) ? oldData : [];
+                    const hasItem = oldItems.some((item) => item && item.id === itemId);
+                    if (hasItem) {
+                        // Update if existing item found
+                        return oldItems.map((item) => item && item.id === itemId
+                            ? Object.assign(Object.assign({}, item), updateData) : item);
+                    }
+                    else if (optimisticData && queryKey.length < 3) {
+                        // Only consider adding created item for top-level list queries
+                        // Add if no existing item and optimistic update data available (for create/upsert)
+                        return [...oldItems, optimisticData];
+                    }
+                    return oldItems; // No changes
+                });
+            }
+        });
+        return previousDataMap;
+    });
+}
+/**
+ * Handle cache updates after API call success
+ * @param queryClient TanStack QueryClient instance
+ * @param modelName Model name
+ * @param relatedQueryKeys Array of related query keys to update
+ * @param itemId ID of updated item
+ * @param updatedItem Latest item data from API response
+ */
+function handleCacheUpdateOnSuccess(queryClient, modelName, relatedQueryKeys, itemId, updatedItem) {
+    // 1. Update individual item cache
+    queryClient.setQueryData([modelName, itemId], updatedItem);
+    // 2. Update list query cache (with relational filtering applied)
+    relatedQueryKeys.forEach((queryKey) => {
+        // Check if relational query - e.g. ["Mission", "Daily", "daily-id", ...]
+        const isRelationalQuery = queryKey.length > 3 &&
+            typeof queryKey[1] === "string" &&
+            typeof queryKey[2] === "string";
+        // Check if relational query - e.g. ["Mission", "Daily", "daily-id", ...]
+        if (isRelationalQuery) {
+            const relationName = queryKey[1]; // "Daily", "User" 등
+            const relationId = queryKey[2]; // 실제 관계 ID
+            const relationField = `${relationName.toLowerCase()}Id`; // "dailyId", "userId" 등
+            // Check if updated item belongs to this relation ID
+            const belongsToRelation = updatedItem[relationField] === relationId;
+            if (!belongsToRelation) {
+                // Skip cache update if item does not belong to this relation ID
+                return;
+            }
+        }
+        // Update query cache
+        queryClient.setQueryData(queryKey, (oldData) => {
+            const oldItems = Array.isArray(oldData) ? oldData : [];
+            const hasItem = oldItems.some((item) => item && item.id === itemId);
+            if (hasItem) {
+                // Update if existing item found
+                return oldItems.map((item) => item && item.id === itemId ? updatedItem : item);
+            }
+            else {
+                // Add if successfully created (already filtered in relational queries)
+                return [...oldItems, updatedItem];
+            }
+        });
+    });
+}
+/**
+ * Rollback cache on error
+ * @param queryClient TanStack QueryClient instance
+ * @param previousDataMap Map containing previous cache data
+ */
+function rollbackCache(queryClient, previousDataMap) {
+    previousDataMap.forEach((previousData, queryKey) => {
+        queryClient.setQueryData(queryKey, previousData);
+    });
+}
+/**
+ * Create model-specific Amplify service
+ * @param modelName Model name
+ * @param queryMap Model-specific query name mapping (optional)
+ * @param defaultAuthMode Default authentication mode (default: 'userPool')
+ * @returns AmplifyDataService instance for the model
+ */
+function createAmplifyService(modelName, queryMap, defaultAuthMode = "userPool") {
+    // Track current authentication mode state
+    let currentAuthMode = defaultAuthMode;
+    // Create service object
+    const service = {
+        // Add model name (needed for singleton services)
+        modelName,
+        // Set authentication mode method
+        setAuthMode: (authMode) => {
+            currentAuthMode = authMode;
+            console.log(`🔐 ${modelName} service auth mode changed: ${authMode}`);
+        },
+        // Get current authentication mode
+        getAuthMode: () => {
+            return currentAuthMode;
+        },
+        // Set authentication mode chaining method
+        withAuthMode: (authMode) => {
+            const clonedService = Object.assign({}, service);
+            clonedService.setAuthMode(authMode);
+            return clonedService;
+        },
+        // Create item
+        create: (data, options) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!data) {
+                    console.error(`🍬 ${modelName} creation error: data is null`);
+                    return null;
+                }
+                // Determine auth mode (use provided option if available)
+                const authMode = (options === null || options === void 0 ? void 0 : options.authMode) || currentAuthMode;
+                // Get owner and parameters based on auth mode
+                const { authModeParams } = yield getOwnerByAuthMode(authMode);
+                const dataWithoutOwner = utils_1.Utils.removeOwnerField(data, "create");
+                const cleanedData = {};
+                Object.entries(dataWithoutOwner).forEach(([key, value]) => {
+                    if (value !== undefined) {
+                        cleanedData[key] = value;
+                    }
+                });
+                const newItem = Object.assign(Object.assign({}, cleanedData), { id: (0, expo_crypto_1.randomUUID)() });
+                // Extract relation fields (e.g., dailyId, userId)
+                const relationFields = new Map();
+                for (const [key, value] of Object.entries(newItem)) {
+                    if (key.endsWith("Id") && typeof value === "string" && value) {
+                        // Relation field name and its value
+                        relationFields.set(key, value);
+                    }
+                }
+                // Find related query keys (all keys starting with model name)
+                const relatedQueryKeys = findRelatedQueryKeys(modelName, query_1.queryClient);
+                // Backup previous data for optimistic update
+                const previousDataMap = new Map();
+                // Update individual item cache
+                const singleItemQueryKey = [modelName, newItem.id];
+                const previousItemSingle = query_1.queryClient.getQueryData(singleItemQueryKey);
+                previousDataMap.set(singleItemQueryKey, previousItemSingle);
+                query_1.queryClient.setQueryData(singleItemQueryKey, newItem);
+                // Update list queries (with relation filtering)
+                relatedQueryKeys.forEach((queryKey) => {
+                    // Check if it's a relational query (e.g., ["Mission", "Daily", "daily-id", ...])
+                    const isRelationalQuery = queryKey.length > 3 &&
+                        typeof queryKey[1] === "string" &&
+                        typeof queryKey[2] === "string";
+                    if (isRelationalQuery) {
+                        // For relational queries, only add to cache if it belongs to the relation
+                        const relationName = queryKey[1]; // "Daily", "User" etc.
+                        const relationId = queryKey[2]; // Actual relation ID value
+                        const relationField = `${relationName.toLowerCase()}Id`; // "dailyId", "userId" etc.
+                        // Check if new item belongs to this relation ID
+                        const belongsToRelation = newItem[relationField] === relationId;
+                        if (belongsToRelation) {
+                            // Only update cache if it belongs to this relation
+                            const data = query_1.queryClient.getQueryData(queryKey);
+                            if (data) {
+                                previousDataMap.set(queryKey, data);
+                            }
+                            query_1.queryClient.setQueryData(queryKey, (oldData) => {
+                                const oldItems = Array.isArray(oldData) ? oldData : [];
+                                return [...oldItems, newItem];
+                            });
+                        }
+                    }
+                    else if (queryKey.length < 3) {
+                        // Regular list query
+                        const data = query_1.queryClient.getQueryData(queryKey);
+                        if (data) {
+                            previousDataMap.set(queryKey, data);
+                        }
+                        query_1.queryClient.setQueryData(queryKey, (oldData) => {
+                            const oldItems = Array.isArray(oldData) ? oldData : [];
+                            return [...oldItems, newItem];
+                        });
+                    }
+                });
+                try {
+                    // Attempt API call - apply auth mode
+                    console.log(`🍬 ${modelName} creation attempt [Auth: ${authMode}]:`, newItem.id);
+                    const { data: createdItem } = yield (0, client_1.getClient)().models[modelName].create(newItem, authModeParams);
+                    if (createdItem) {
+                        // Update cache on API success
+                        query_1.queryClient.setQueryData(singleItemQueryKey, createdItem);
+                        // Invalidate queries based on relation fields
+                        for (const [field, value] of relationFields) {
+                            // Extract relation name from field name (e.g., "dailyId" -> "Daily")
+                            const relationName = field
+                                .replace(/Id$/, "")
+                                .replace(/^./, (c) => c.toUpperCase());
+                            // Invalidate queries for this relation
+                            query_1.queryClient.invalidateQueries({
+                                queryKey: [modelName, relationName, value],
+                                refetchType: "active",
+                            });
+                        }
+                        // Invalidate all related queries
+                        query_1.queryClient.invalidateQueries({
+                            queryKey: [modelName],
+                            refetchType: "active",
+                        });
+                        console.log(`🍬 ${modelName} creation successful:`, newItem.id);
+                        return createdItem;
+                    }
+                    // Keep optimistic update data even if no API response
+                    console.warn(`🍬 ${modelName} creation API no response. Keeping optimistic update data.`);
+                    return newItem;
+                }
+                catch (apiError) {
+                    // Rollback and log error on API failure
+                    console.error(`🍬 ${modelName} creation error, performing rollback:`, apiError);
+                    rollbackCache(query_1.queryClient, previousDataMap);
+                    // Re-throw error for caller to handle
+                    throw apiError;
+                }
+            }
+            catch (error) {
+                console.error(`🍬 ${modelName} final creation error:`, error);
+                return null;
+            }
+        }),
+        // Batch create items
+        createList: (dataList, options) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!dataList || dataList.length === 0) {
+                    return [];
+                }
+                // Determine auth mode (use provided option if available)
+                const authMode = (options === null || options === void 0 ? void 0 : options.authMode) || currentAuthMode;
+                // Get owner and parameters based on auth mode
+                const { authModeParams } = yield getOwnerByAuthMode(authMode);
+                const preparedItems = dataList
+                    .map((data) => {
+                    if (!data)
+                        return null;
+                    const dataWithoutOwner = utils_1.Utils.removeOwnerField(data, "create");
+                    const cleanedData = {};
+                    Object.entries(dataWithoutOwner).forEach(([key, value]) => {
+                        if (value !== undefined) {
+                            cleanedData[key] = value;
+                        }
+                    });
+                    return Object.assign(Object.assign({}, cleanedData), { id: (0, expo_crypto_1.randomUUID)() });
+                })
+                    .filter(Boolean);
+                const relatedQueryKeys = findRelatedQueryKeys(modelName, query_1.queryClient);
+                const previousDataMap = new Map();
+                // Extract relation properties (e.g., dailyId)
+                const relationFields = new Map();
+                for (const item of preparedItems) {
+                    for (const [key, value] of Object.entries(item)) {
+                        if (key.endsWith("Id") && typeof value === "string" && value) {
+                            // Relation field name and its value
+                            relationFields.set(key, value);
+                        }
+                    }
+                }
+                console.log(`🍬 ${modelName} batch creation attempt: ${preparedItems.length} items`);
+                // Batch optimistic update - with relation filtering
+                relatedQueryKeys.forEach((queryKey) => {
+                    // Check if this query key is a relational query (e.g., ["Mission", "Daily", "daily-id", ...])
+                    const isRelationalQuery = queryKey.length > 3 &&
+                        typeof queryKey[1] === "string" &&
+                        typeof queryKey[2] === "string";
+                    const previousItems = query_1.queryClient.getQueryData(queryKey);
+                    previousDataMap.set(queryKey, previousItems); // Backup previous data
+                    if (isRelationalQuery) {
+                        // For relational queries, only add items that belong to the relation
+                        const relationName = queryKey[1]; // "Daily", "User" etc.
+                        const relationId = queryKey[2]; // Actual relation ID value
+                        const relationField = `${relationName.toLowerCase()}Id`; // "dailyId", "userId" etc.
+                        query_1.queryClient.setQueryData(queryKey, (oldData) => {
+                            const oldItems = Array.isArray(oldData) ? oldData : [];
+                            // Filter new items that belong to this relation ID
+                            const itemsToAdd = preparedItems.filter((newItem) => newItem[relationField] === relationId);
+                            // Merge existing items with filtered new items
+                            if (itemsToAdd.length > 0) {
+                                return [...oldItems, ...itemsToAdd];
+                            }
+                            return oldItems; // No change if no items match relation ID
+                        });
+                    }
+                    else if (queryKey.length < 3) {
+                        // Regular list query - add all items
+                        query_1.queryClient.setQueryData(queryKey, (oldData) => {
+                            const oldItems = Array.isArray(oldData) ? oldData : [];
+                            return [...oldItems, ...preparedItems];
+                        });
+                    }
+                });
+                // Update individual item caches
+                preparedItems.forEach((item) => {
+                    const singleItemQueryKey = [modelName, item.id];
+                    const previousItemSingle = query_1.queryClient.getQueryData(singleItemQueryKey);
+                    previousDataMap.set(singleItemQueryKey, previousItemSingle);
+                    query_1.queryClient.setQueryData(singleItemQueryKey, item);
+                });
+                try {
+                    // Parallel API calls - apply auth mode
+                    const createPromises = preparedItems.map((newItem) => __awaiter(this, void 0, void 0, function* () {
+                        try {
+                            const { data: createdItem } = yield (0, client_1.getClient)().models[modelName].create(newItem, authModeParams);
+                            // Update individual item cache on API success
+                            if (createdItem) {
+                                query_1.queryClient.setQueryData([modelName, createdItem.id], createdItem);
+                            }
+                            return createdItem || newItem;
+                        }
+                        catch (error) {
+                            console.error(`🍬 ${modelName} batch creation failed for ID ${newItem.id}:`, error);
+                            return newItem;
+                        }
+                    }));
+                    const results = yield Promise.all(createPromises);
+                    console.log(`🍬 ${modelName} batch creation completed: ${results.length} items`);
+                    // After creation, invalidate all related queries to ensure exact server data
+                    // This is important as it prevents side effects of optimistic updates by invalidating related queries
+                    for (const [field, value] of relationFields) {
+                        // Extract relation name from field name (e.g., "dailyId" -> "Daily")
+                        const relationName = field
+                            .replace(/Id$/, "")
+                            .replace(/^./, (c) => c.toUpperCase());
+                        // Invalidate query for this relation
+                        query_1.queryClient.invalidateQueries({
+                            queryKey: [modelName, relationName, value],
+                            refetchType: "active",
+                        });
+                        // Also invalidate general queries
+                        query_1.queryClient.invalidateQueries({
+                            queryKey: [modelName],
+                            refetchType: "active",
+                        });
+                    }
+                    return results;
+                }
+                catch (apiError) {
+                    console.error(`🍬 ${modelName} batch creation API error, performing rollback:`, apiError);
+                    rollbackCache(query_1.queryClient, previousDataMap);
+                    throw apiError;
+                }
+            }
+            catch (error) {
+                console.error(`🍬 ${modelName} final batch creation error:`, error);
+                return [];
+            }
+        }),
+        // Get item
+        get: (id_1, ...args_1) => __awaiter(this, [id_1, ...args_1], void 0, function* (id, options = { forceRefresh: false }) {
+            try {
+                const singleItemQueryKey = [modelName, id];
+                // Check cache first (if forceRefresh is false)
+                if (!options.forceRefresh) {
+                    const cachedItem = query_1.queryClient.getQueryData(singleItemQueryKey);
+                    if (cachedItem) {
+                        return cachedItem;
+                    }
+                }
+                // Determine auth mode (use provided option if available)
+                const authMode = (options === null || options === void 0 ? void 0 : options.authMode) || currentAuthMode;
+                // Get parameters based on auth mode
+                const { authModeParams } = yield getOwnerByAuthMode(authMode);
+                // API call - apply auth mode
+                const { data: item } = yield (0, client_1.getClient)().models[modelName].get({ id }, authModeParams);
+                // Update cache
+                if (item) {
+                    query_1.queryClient.setQueryData(singleItemQueryKey, item);
+                    // Update related list queries (lists that might contain this item)
+                    const relatedQueryKeys = findRelatedQueryKeys(modelName, query_1.queryClient);
+                    relatedQueryKeys.forEach((queryKey) => {
+                        // Exclude single item keys, only process list queries
+                        if (queryKey.length > 1 && queryKey[1] !== id) {
+                            // Query keys with id as second element are not single item get query key format, so treat as list
+                            query_1.queryClient.setQueryData(queryKey, (oldData) => {
+                                const oldItems = Array.isArray(oldData) ? oldData : [];
+                                const exists = oldItems.some((oldItem) => oldItem && oldItem.id === id);
+                                if (exists) {
+                                    return oldItems.map((oldItem) => oldItem && oldItem.id === id ? item : oldItem);
+                                }
+                                else {
+                                    // Need to check if item matches list query filter conditions (not checking here)
+                                    // If checking is difficult, invalidateQueries might be safer
+                                    // Currently implemented to add item to all related lists that might contain it on API get success
+                                    return [...oldItems, item];
+                                }
+                            });
+                        }
+                    });
+                }
+                return item || null;
+            }
+            catch (error) {
+                console.error(`🍬 ${modelName} get error:`, error);
+                return null;
+            }
+        }),
+        // Batch get items
+        list: (...args_1) => __awaiter(this, [...args_1], void 0, function* (options = { filter: undefined, forceRefresh: false }) {
+            var _a;
+            try {
+                // Determine query key
+                const queryKey = options.filter
+                    ? [modelName, "filter", JSON.stringify(options.filter)]
+                    : [modelName];
+                // Check cache first (if forceRefresh is false)
+                if (!options.forceRefresh) {
+                    const cachedItems = query_1.queryClient.getQueryData(queryKey);
+                    if (cachedItems && cachedItems.length > 0) {
+                        console.log(`🍬 ${modelName} list using cache`, queryKey);
+                        return cachedItems.filter((item) => item !== null);
+                    }
+                }
+                // Determine auth mode (use provided option if available)
+                const authMode = (options === null || options === void 0 ? void 0 : options.authMode) || currentAuthMode;
+                // Get owner and parameters based on auth mode
+                const { owner, authModeParams } = yield getOwnerByAuthMode(authMode);
+                // Get owner-based query name, use default format if not found
+                const ownerQueryName = (queryMap === null || queryMap === void 0 ? void 0 : queryMap[modelName]) || `list${modelName}sByOwner`;
+                // Try query call
+                try {
+                    console.log(`🍬 ${modelName} list API call`, queryKey, `by ${ownerQueryName}`, `[Auth: ${authMode}]`);
+                    // Execute owner query
+                    const { data: result } = yield (0, client_1.getClient)().models[modelName][ownerQueryName]({ owner, authMode }, authModeParams);
+                    // Extract result data + filter null values
+                    const items = ((result === null || result === void 0 ? void 0 : result.items) || (result === null || result === void 0 ? void 0 : result.data) || result || []).filter((item) => item !== null);
+                    // Apply filter (if client-side filtering needed)
+                    let filteredItems = items;
+                    if (options.filter) {
+                        filteredItems = items.filter((item) => {
+                            return Object.entries(options.filter).every(([key, value]) => {
+                                if (typeof value === "object" && value !== null) {
+                                    // Ensure type safety when accessing item with key
+                                    const itemValue = item[key];
+                                    if ("eq" in value)
+                                        return itemValue === value.eq;
+                                    if ("ne" in value)
+                                        return itemValue !== value.ne;
+                                    if ("gt" in value)
+                                        return itemValue > value.gt;
+                                    if ("lt" in value)
+                                        return itemValue < value.lt;
+                                    if ("contains" in value)
+                                        return String(itemValue).includes(value.contains);
+                                    if ("between" in value &&
+                                        Array.isArray(value.between))
+                                        return (itemValue >= value.between[0] &&
+                                            itemValue <= value.between[1]);
+                                }
+                                // Ensure type safety when accessing item with key
+                                return item[key] === value;
+                            });
+                        });
+                    }
+                    // Update cache
+                    query_1.queryClient.setQueryData(queryKey, filteredItems);
+                    // Update individual item cache
+                    filteredItems.forEach((item) => {
+                        query_1.queryClient.setQueryData([modelName, item.id], item);
+                    });
+                    return filteredItems;
+                }
+                catch (error) {
+                    if ((_a = error === null || error === void 0 ? void 0 : error.message) === null || _a === void 0 ? void 0 : _a.includes("not found")) {
+                        console.warn(`🍬 ${ownerQueryName} query not found. Trying default list query...`);
+                        // Try default list query if owner query not found
+                        const { data: result } = yield (0, client_1.getClient)().models[modelName].list({}, authModeParams);
+                        // Extract and process result data
+                        const items = ((result === null || result === void 0 ? void 0 : result.items) ||
+                            (result === null || result === void 0 ? void 0 : result.data) ||
+                            result ||
+                            []).filter((item) => item !== null);
+                        // Filter, cache update etc. remaining logic same
+                        let filteredItems = items;
+                        if (options.filter) {
+                            // Filtering logic (same as before)
+                            filteredItems = items.filter((item) => {
+                                return Object.entries(options.filter).every(([key, value]) => {
+                                    if (typeof value === "object" && value !== null) {
+                                        // Ensure type safety when accessing item with key
+                                        const itemValue = item[key];
+                                        if ("eq" in value)
+                                            return itemValue === value.eq;
+                                        if ("ne" in value)
+                                            return itemValue !== value.ne;
+                                        if ("gt" in value)
+                                            return itemValue > value.gt;
+                                        if ("lt" in value)
+                                            return itemValue < value.lt;
+                                        if ("contains" in value)
+                                            return String(itemValue).includes(value.contains);
+                                        if ("between" in value &&
+                                            Array.isArray(value.between))
+                                            return (itemValue >= value.between[0] &&
+                                                itemValue <= value.between[1]);
+                                    }
+                                    // Ensure type safety when accessing item with key
+                                    return item[key] === value;
+                                });
+                            });
+                        }
+                        query_1.queryClient.setQueryData(queryKey, filteredItems);
+                        filteredItems.forEach((item) => {
+                            query_1.queryClient.setQueryData([modelName, item.id], item);
+                        });
+                        return filteredItems;
+                    }
+                    throw error; // Pass other errors to upper catch
+                }
+            }
+            catch (error) {
+                console.log("🍬 error", error);
+                console.error(`🍬 ${modelName} list error:`, error);
+                // Invalidate list query cache on error
+                const queryKey = [
+                    modelName,
+                    "filter",
+                    JSON.stringify(options.filter),
+                ];
+                query_1.queryClient.invalidateQueries({ queryKey });
+                return [];
+            }
+        }),
+        // Update item (modified to use helper functions)
+        update: (data, options) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!(data === null || data === void 0 ? void 0 : data.id)) {
+                    console.error(`🍬 ${modelName} update error: No valid data or id provided.`);
+                    return null;
+                }
+                // Determine auth mode (use provided option if available)
+                const authMode = (options === null || options === void 0 ? void 0 : options.authMode) || currentAuthMode;
+                // Get parameters based on auth mode
+                const { authModeParams } = yield getOwnerByAuthMode(authMode);
+                const dataWithoutOwner = utils_1.Utils.removeOwnerField(data, "update");
+                const cleanedData = {};
+                // Always include id, and only include other fields that are actually passed (not undefined)
+                Object.entries(dataWithoutOwner).forEach(([key, value]) => {
+                    if (key === "id" || value !== undefined) {
+                        cleanedData[key] = value;
+                    }
+                });
+                const { id: itemId } = cleanedData; // Get id from cleanedData
+                // Find related query keys
+                const relatedQueryKeys = findRelatedQueryKeys(modelName, query_1.queryClient);
+                // Perform optimistic update
+                const previousDataMap = yield performOptimisticUpdate(query_1.queryClient, modelName, relatedQueryKeys, itemId, cleanedData);
+                try {
+                    // Attempt API call - apply auth mode
+                    console.log(`🍬 ${modelName} update attempt [Auth: ${authMode}]:`, itemId);
+                    const { data: updatedItem } = yield (0, client_1.getClient)().models[modelName].update(cleanedData, authModeParams);
+                    if (updatedItem) {
+                        // Update cache on API success
+                        handleCacheUpdateOnSuccess(query_1.queryClient, modelName, relatedQueryKeys, itemId, updatedItem);
+                        // Invalidate all related queries to automatically fetch new data
+                        query_1.queryClient.invalidateQueries({
+                            queryKey: [modelName],
+                            refetchType: "active",
+                        });
+                        console.log(`🍬 ${modelName} update success:`, itemId);
+                        return updatedItem;
+                    }
+                    else {
+                        console.warn(`🍬 ${modelName} update API response missing. Maintaining optimistic update data.`);
+                        // If no API response, return the data saved during optimistic update
+                        const singleItemQueryKey = [modelName, itemId];
+                        return (previousDataMap.get(singleItemQueryKey) || null);
+                    }
+                }
+                catch (apiError) {
+                    // Rollback and log error on API failure
+                    console.error(`🍬 ${modelName} update error, performing rollback:`, apiError);
+                    rollbackCache(query_1.queryClient, previousDataMap);
+                    throw apiError;
+                }
+            }
+            catch (error) {
+                console.error(`🍬 ${modelName} final update error:`, error);
+                return null;
+            }
+        }),
+        // Delete item (modified to use helper functions)
+        delete: (id, options) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!id) {
+                    console.error(`🍬 ${modelName} delete error: No valid id provided.`);
+                    return false;
+                }
+                // Determine auth mode (use provided option if available)
+                const authMode = (options === null || options === void 0 ? void 0 : options.authMode) || currentAuthMode;
+                // Get parameters based on auth mode
+                const { authModeParams } = yield getOwnerByAuthMode(authMode);
+                // Find related query keys
+                const relatedQueryKeys = findRelatedQueryKeys(modelName, query_1.queryClient);
+                // Backup item data before deletion (for rollback)
+                const previousDataMap = new Map();
+                // Backup previous data and perform optimistic update for individual item (set to null)
+                const singleItemQueryKey = [modelName, id];
+                const previousItemSingle = query_1.queryClient.getQueryData(singleItemQueryKey);
+                previousDataMap.set(singleItemQueryKey, previousItemSingle);
+                query_1.queryClient.setQueryData(singleItemQueryKey, null);
+                // Backup and perform optimistic update for list queries (remove item)
+                relatedQueryKeys.forEach((queryKey) => {
+                    if (queryKey.length > 1 && queryKey[1] !== id) {
+                        // Exclude single item keys
+                        const data = query_1.queryClient.getQueryData(queryKey);
+                        if (data) {
+                            previousDataMap.set(queryKey, data);
+                        }
+                        query_1.queryClient.setQueryData(queryKey, (oldData) => {
+                            const oldItems = Array.isArray(oldData) ? oldData : [];
+                            return oldItems.filter((item) => (item === null || item === void 0 ? void 0 : item.id) !== id);
+                        });
+                    }
+                });
+                try {
+                    // API call - apply auth mode
+                    console.log(`🍬 ${modelName} delete attempt [Auth: ${authMode}]:`, id);
+                    yield (0, client_1.getClient)().models[modelName].delete({ id }, authModeParams);
+                    console.log(`🍬 ${modelName} delete success:`, id);
+                    // On API success, invalidate all related queries to automatically refresh
+                    query_1.queryClient.invalidateQueries({
+                        queryKey: [modelName],
+                        refetchType: "active",
+                    });
+                    return true;
+                }
+                catch (error) {
+                    // Rollback on API error
+                    console.error(`🍬 ${modelName} delete API error, performing rollback:`, error);
+                    rollbackCache(query_1.queryClient, previousDataMap);
+                    throw error;
+                }
+            }
+            catch (error) {
+                console.error(`🍬 ${modelName} final delete error:`, error);
+                return false;
+            }
+        }),
+        // Batch delete multiple items (consider applying helper functions)
+        deleteList: (ids, options) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const results = {
+                    success: [],
+                    failed: [],
+                };
+                if (!ids || ids.length === 0) {
+                    console.warn(`🍬 ${modelName} batch delete: Empty ID array provided.`);
+                    return results;
+                }
+                // Determine auth mode (use provided option if available)
+                const authMode = (options === null || options === void 0 ? void 0 : options.authMode) || currentAuthMode;
+                // Get parameters based on auth mode
+                const { authModeParams } = yield getOwnerByAuthMode(authMode);
+                // Prepare related query keys and previous data map
+                const relatedQueryKeys = findRelatedQueryKeys(modelName, query_1.queryClient);
+                const previousDataMap = new Map();
+                const previousItemsCache = new Map(); // For individual item rollback
+                // Optimistic update - remove items from all caches
+                ids.forEach((id) => {
+                    // Backup previous data and perform optimistic update for individual item (null)
+                    const singleItemQueryKey = [modelName, id];
+                    const previousItemSingle = query_1.queryClient.getQueryData(singleItemQueryKey);
+                    previousItemsCache.set(id, previousItemSingle || null);
+                    previousDataMap.set(singleItemQueryKey, previousItemSingle); // Backup to map
+                    query_1.queryClient.setQueryData(singleItemQueryKey, null);
+                });
+                // Update all list query caches (remove items included in id list)
+                relatedQueryKeys.forEach((queryKey) => {
+                    if (queryKey.length > 1 && !ids.includes(queryKey[1])) {
+                        // Exclude single item keys and list keys where id is second element (handled individually)
+                        const data = query_1.queryClient.getQueryData(queryKey);
+                        if (data) {
+                            previousDataMap.set(queryKey, data);
+                        }
+                        query_1.queryClient.setQueryData(queryKey, (oldData) => {
+                            const oldItems = Array.isArray(oldData) ? oldData : [];
+                            return oldItems.filter((item) => item && !ids.includes(item.id));
+                        });
+                    }
+                });
+                try {
+                    console.log(`🍬 ${modelName} batch delete attempt [Auth: ${authMode}]: ${ids.length} items`);
+                    // Parallel API calls - apply auth mode
+                    const deletePromises = ids.map((id) => __awaiter(this, void 0, void 0, function* () {
+                        try {
+                            yield (0, client_1.getClient)().models[modelName].delete({ id }, authModeParams);
+                            results.success.push(id);
+                            return { id, success: true };
+                        }
+                        catch (error) {
+                            console.error(`🍬 ${modelName} batch delete failed for ID ${id}:`, error);
+                            results.failed.push(id);
+                            return { id, success: false, error };
+                        }
+                    }));
+                    yield Promise.all(deletePromises);
+                    // If there are failed items, rollback only those items
+                    if (results.failed.length > 0) {
+                        console.warn(`🍬 ${modelName} batch delete: ${results.failed.length} items failed, performing partial rollback`);
+                        for (const failedId of results.failed) {
+                            // Rollback individual item
+                            const previousItem = previousItemsCache.get(failedId);
+                            if (previousItem !== undefined) {
+                                // Restore if not undefined (was in cache)
+                                const singleItemQueryKey = [modelName, failedId];
+                                query_1.queryClient.setQueryData(singleItemQueryKey, previousItem);
+                            }
+                            // Restore failed item to list queries
+                            relatedQueryKeys.forEach((queryKey) => {
+                                if (queryKey.length > 1 &&
+                                    !ids.includes(queryKey[1])) {
+                                    // Restore failed item to list queries
+                                    query_1.queryClient.setQueryData(queryKey, (oldData) => {
+                                        const oldItems = Array.isArray(oldData) ? oldData : [];
+                                        const previousItem = previousItemsCache.get(failedId);
+                                        if (!previousItem)
+                                            return oldItems;
+                                        // Do not add duplicate item if already in list
+                                        if (oldItems.some((item) => item && item.id === failedId)) {
+                                            return oldItems;
+                                        }
+                                        return [...oldItems, previousItem];
+                                    });
+                                }
+                            });
+                        }
+                    }
+                    // Invalidate all related queries to force refresh (safety mechanism)
+                    relatedQueryKeys.forEach((queryKey) => query_1.queryClient.invalidateQueries({ queryKey }));
+                    ids.forEach((id) => query_1.queryClient.invalidateQueries({ queryKey: [modelName, id] }));
+                    console.log(`🍬 ${modelName} batch delete: ${results.success.length} items deleted, ${results.failed.length} items failed`);
+                    return results;
+                }
+                catch (generalError) {
+                    // General error occurred, performing full rollback
+                    console.error(`🍬 ${modelName} batch delete: General error occurred, performing full rollback:`, generalError);
+                    rollbackCache(query_1.queryClient, previousDataMap);
+                    // Invalidate all queries when a broad error occurs
+                    query_1.queryClient.invalidateQueries({ queryKey: [modelName] });
+                    results.failed = [...ids]; // Mark all IDs as failed
+                    throw generalError; // Re-throw the error
+                }
+            }
+            catch (error) {
+                console.error(`🍬 ${modelName} final batch delete error:`, error);
+                return { success: [], failed: ids }; // Return all IDs as failed
+            }
+        }),
+        // Create or update (modified to use helper functions)
+        upsert: (data, options) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!(data === null || data === void 0 ? void 0 : data.id)) {
+                    console.error(`🍬 ${modelName} upsert error: No valid data or id provided.`);
+                    return null;
+                }
+                // Determine auth mode (use provided options if available)
+                const authMode = (options === null || options === void 0 ? void 0 : options.authMode) || currentAuthMode;
+                // Get parameters based on auth mode
+                const { authModeParams } = yield getOwnerByAuthMode(authMode);
+                // Check existing item in cache (without API call)
+                // Call get first to ensure latest state. service.get checks cache and calls API if needed.
+                const existingItem = yield service.get(data.id);
+                const dataWithoutOwner = utils_1.Utils.removeOwnerField(data, "upsert");
+                const cleanedData = {};
+                Object.entries(dataWithoutOwner).forEach(([key, value]) => {
+                    if (key === "id" || value !== undefined) {
+                        cleanedData[key] = value;
+                    }
+                });
+                cleanedData.id = data.id; // Preserve ID
+                // Find related query keys
+                const relatedQueryKeys = findRelatedQueryKeys(modelName, query_1.queryClient);
+                // Perform optimistic update
+                const previousDataMap = yield performOptimisticUpdate(query_1.queryClient, modelName, relatedQueryKeys, data.id, cleanedData);
+                try {
+                    if (existingItem) {
+                        // Use update logic if item exists - apply auth mode
+                        console.log(`🍬 ${modelName} upsert(update) attempt [Auth: ${authMode}]:`, data.id);
+                        const { data: updatedItem } = yield (0, client_1.getClient)().models[modelName].update(cleanedData, authModeParams);
+                        if (updatedItem) {
+                            handleCacheUpdateOnSuccess(query_1.queryClient, modelName, relatedQueryKeys, data.id, updatedItem);
+                            console.log(`🍬 ${modelName} upsert(update) success:`, data.id);
+                            return updatedItem;
+                        }
+                        else {
+                            console.warn(`🍬 ${modelName} upsert(update) no API response. Keeping optimistic update data.`);
+                            const singleItemQueryKey = [modelName, data.id];
+                            return (previousDataMap.get(singleItemQueryKey) ||
+                                null);
+                        }
+                    }
+                    else {
+                        // Use create logic if item doesn't exist - apply auth mode
+                        console.log(`🍬 ${modelName} upsert(create) attempt [Auth: ${authMode}]:`, data.id);
+                        const { data: createdItem } = yield (0, client_1.getClient)().models[modelName].create(cleanedData, authModeParams);
+                        if (createdItem) {
+                            handleCacheUpdateOnSuccess(query_1.queryClient, modelName, relatedQueryKeys, data.id, createdItem);
+                            console.log(`🍬 ${modelName} upsert(create) success:`, data.id);
+                            return createdItem;
+                        }
+                        else {
+                            console.warn(`🍬 ${modelName} upsert(create) no API response. Keeping optimistic update data.`);
+                            const singleItemQueryKey = [modelName, data.id];
+                            return (previousDataMap.get(singleItemQueryKey) ||
+                                null);
+                        }
+                    }
+                }
+                catch (apiError) {
+                    // Rollback and log error on API error
+                    console.error(`🍬 ${modelName} upsert error, performing rollback:`, apiError);
+                    rollbackCache(query_1.queryClient, previousDataMap);
+                    throw apiError;
+                }
+            }
+            catch (error) {
+                console.error(`🍬 ${modelName} final upsert error:`, error);
+                return null;
+            }
+        }),
+        // Index-based query (added method)
+        customList: (queryName_1, args_1, ...args_2) => __awaiter(this, [queryName_1, args_1, ...args_2], void 0, function* (queryName, args, options = { forceRefresh: false }) {
+            var _a;
+            try {
+                // Determine auth mode (use provided options if available)
+                const authMode = (options === null || options === void 0 ? void 0 : options.authMode) || currentAuthMode;
+                // Get owner and parameters based on auth mode
+                const { owner, authModeParams } = yield getOwnerByAuthMode(authMode);
+                // Add owner value to queries requiring owner field when userPool auth
+                const enhancedArgs = Object.assign({}, args);
+                if (owner &&
+                    authMode === "userPool" &&
+                    queryName.toLowerCase().includes("owner")) {
+                    enhancedArgs.owner = owner;
+                }
+                // Detect relational query (if fields like dailyId, userId exist)
+                const relationField = Object.keys(enhancedArgs).find((key) => key.endsWith("Id"));
+                const isRelationalQuery = !!relationField;
+                const relationId = isRelationalQuery
+                    ? enhancedArgs[relationField]
+                    : null;
+                const relationName = isRelationalQuery
+                    ? relationField
+                        .replace(/Id$/, "") // 'dailyId' → 'daily'
+                        .replace(/^./, (c) => c.toUpperCase()) // 'daily' → 'Daily'
+                    : null;
+                // Create query key (include relation info for relational queries)
+                const queryKey = isRelationalQuery
+                    ? [
+                        modelName,
+                        relationName,
+                        relationId,
+                        "query",
+                        queryName,
+                        JSON.stringify(enhancedArgs),
+                    ]
+                    : [modelName, "query", queryName, JSON.stringify(enhancedArgs)];
+                // Check cache first (if forceRefresh is false)
+                if (!options.forceRefresh) {
+                    const cachedItems = query_1.queryClient.getQueryData(queryKey);
+                    if (cachedItems && cachedItems.length > 0) {
+                        console.log(`🍬 ${modelName} ${queryName} using cache`);
+                        return cachedItems.filter((item) => item !== null);
+                    }
+                }
+                console.log(`🍬 ${modelName} customList call [Auth: ${authMode}]:`, queryName, enhancedArgs);
+                // Check if index query method exists
+                if (!((_a = (0, client_1.getClient)().models[modelName]) === null || _a === void 0 ? void 0 : _a[queryName])) {
+                    throw new Error(`🍬 Query ${queryName} does not exist.`);
+                }
+                // Execute index query - apply auth mode
+                const { data: result } = yield (0, client_1.getClient)().models[modelName][queryName](enhancedArgs, authModeParams);
+                // Extract result data
+                const items = (result === null || result === void 0 ? void 0 : result.items) || (result === null || result === void 0 ? void 0 : result.data) || result || [];
+                console.log(`🍬 ${modelName} ${queryName} result:`, items.length, "items");
+                // Filter null values
+                const filteredItems = items.filter((item) => item !== null);
+                // Update cache
+                query_1.queryClient.setQueryData(queryKey, filteredItems);
+                // Update individual item cache
+                filteredItems.forEach((item) => {
+                    query_1.queryClient.setQueryData([modelName, item.id], item);
+                });
+                return filteredItems;
+            }
+            catch (error) {
+                console.error(`🍬 ${modelName} ${queryName} error:`, error);
+                // Invalidate customList query cache on error
+                // For relational queries, only invalidate related query
+                if (typeof args === "object") {
+                    const relationField = Object.keys(args).find((key) => key.endsWith("Id"));
+                    if (relationField) {
+                        const relationName = relationField
+                            .replace(/Id$/, "")
+                            .replace(/^./, (c) => c.toUpperCase());
+                        const queryKey = [
+                            modelName,
+                            relationName,
+                            args[relationField],
+                            "query",
+                            queryName,
+                            JSON.stringify(args),
+                        ];
+                        query_1.queryClient.invalidateQueries({ queryKey });
+                    }
+                    else {
+                        const queryKey = [
+                            modelName,
+                            "query",
+                            queryName,
+                            JSON.stringify(args),
+                        ];
+                        query_1.queryClient.invalidateQueries({ queryKey });
+                    }
+                }
+                return [];
+            }
+        }),
+        // Load from cache - Not directly implemented in TanStack Query
+        loadFromCache: () => {
+            // Note: This function is not directly supported in TanStack Query
+            // If needed, connect to Zustand store implementation here
+            console.warn(`🍬 ${modelName}.getStore() is not directly supported in TanStack Query.`);
+            // Return empty object temporarily or throw error
+            return {}; // or throw new Error("getStore is not supported in TanStack Query implementation");
+        },
+        // Cache reset - Using invalidateQueries in TanStack Query
+        resetCache: () => {
+            // Invalidate all queries related to this model
+            query_1.queryClient.invalidateQueries({ queryKey: [modelName] });
+        },
+        // React Hook returning method - Reimplemented based on TanStack Query
+        useHook: (options) => {
+            var _a, _b, _c, _d, _e, _f, _g, _h;
+            const hookQueryClient = (0, react_query_1.useQueryClient)();
+            // Determine query key
+            const queryKey = (0, react_1.useMemo)(() => {
+                var _a;
+                if (options === null || options === void 0 ? void 0 : options.customList) {
+                    return [
+                        modelName,
+                        "query",
+                        options.customList.queryName,
+                        JSON.stringify(options.customList.args),
+                    ];
+                }
+                if ((_a = options === null || options === void 0 ? void 0 : options.initialFetchOptions) === null || _a === void 0 ? void 0 : _a.filter) {
+                    return [
+                        modelName,
+                        "filter",
+                        JSON.stringify(options.initialFetchOptions.filter),
+                    ];
+                }
+                return [modelName];
+            }, [
+                modelName,
+                (_a = options === null || options === void 0 ? void 0 : options.initialFetchOptions) === null || _a === void 0 ? void 0 : _a.filter,
+                (_b = options === null || options === void 0 ? void 0 : options.customList) === null || _b === void 0 ? void 0 : _b.queryName,
+                (_c = options === null || options === void 0 ? void 0 : options.customList) === null || _c === void 0 ? void 0 : _c.args,
+            ]);
+            // Determine query function
+            const queryFn = (0, react_1.useCallback)((context) => __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                if (options === null || options === void 0 ? void 0 : options.customList) {
+                    console.log(`🍬 ${modelName} useHook customList call:`, options.customList.queryName, options.customList.args, options.customList.forceRefresh);
+                    return service.customList(options.customList.queryName, options.customList.args, { forceRefresh: options.customList.forceRefresh });
+                }
+                if ((_a = options === null || options === void 0 ? void 0 : options.initialFetchOptions) === null || _a === void 0 ? void 0 : _a.filter) {
+                    return service.list({
+                        filter: options.initialFetchOptions.filter,
+                        forceRefresh: true,
+                    });
+                }
+                return service.list();
+            }), [
+                (_d = options === null || options === void 0 ? void 0 : options.initialFetchOptions) === null || _d === void 0 ? void 0 : _d.filter,
+                (_e = options === null || options === void 0 ? void 0 : options.customList) === null || _e === void 0 ? void 0 : _e.queryName,
+                (_f = options === null || options === void 0 ? void 0 : options.customList) === null || _f === void 0 ? void 0 : _f.args,
+                (_g = options === null || options === void 0 ? void 0 : options.customList) === null || _g === void 0 ? void 0 : _g.forceRefresh,
+                service,
+            ]);
+            const queryOptions = {
+                queryKey,
+                queryFn,
+                enabled: ((_h = options === null || options === void 0 ? void 0 : options.initialFetchOptions) === null || _h === void 0 ? void 0 : _h.fetch) !== false,
+                staleTime: 1000 * 30, // Keep fresh for 30 seconds (refresh more frequently)
+                refetchOnMount: true, // Refetch on component mount
+                refetchOnWindowFocus: false, // Don't auto-refetch on window focus
+                refetchOnReconnect: true, // Refetch on network reconnect
+            };
+            const { data: items = [], isLoading, error, refetch, } = (0, react_query_1.useQuery)(queryOptions);
+            // Interface functions implementation
+            const getItem = (0, react_1.useCallback)((id) => {
+                // Use useQueryData to get latest single item from current cache
+                return hookQueryClient.getQueryData([modelName, id]);
+            }, [hookQueryClient, modelName]);
+            const createItem = (0, react_1.useCallback)((data) => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const result = yield service.create(data);
+                    // Automatically refresh list after successful create
+                    yield refetch();
+                    return result;
+                }
+                catch (_error) {
+                    console.error(`🍬 ${modelName} useHook create error:`, _error);
+                    throw _error; // Re-throw error
+                }
+            }), [service, refetch] // Add refetch dependency
+            );
+            const updateItem = (0, react_1.useCallback)((data) => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const result = yield service.update(data);
+                    // Automatically refresh list after successful update
+                    yield refetch();
+                    return result;
+                }
+                catch (_error) {
+                    console.error(`🍬 ${modelName} useHook update error:`, _error);
+                    throw _error;
+                }
+            }), [service, refetch] // Add refetch dependency
+            );
+            const deleteItem = (0, react_1.useCallback)((id) => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const result = yield service.delete(id);
+                    // Automatically refresh list after successful delete
+                    yield refetch();
+                    return result;
+                }
+                catch (error) {
+                    console.error(`🍬 ${modelName} useHook delete error:`, error);
+                    throw error;
+                }
+            }), [service, refetch] // refetch dependency added
+            );
+            const refresh = (0, react_1.useCallback)((refreshOptions) => __awaiter(this, void 0, void 0, function* () {
+                console.log(`🍬 ${modelName} useHook refresh called`, queryKey);
+                const { data } = yield refetch({ throwOnError: true }); // Throw on error
+                return data || [];
+            }), [refetch, queryKey]);
+            const customListFn = (0, react_1.useCallback)((queryName, args, options) => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const result = yield service.customList(queryName, args, options);
+                    return result;
+                }
+                catch (error) {
+                    console.error(`🍬 ${modelName} useHook customList error:`, error);
+                    throw error;
+                }
+            }), [service]);
+            return {
+                items,
+                isLoading,
+                error: error,
+                getItem,
+                refresh,
+                create: createItem,
+                update: updateItem,
+                delete: deleteItem,
+                customList: customListFn,
+            };
+        },
+        // Hook for managing single item - Reimplemented based on TanStack Query
+        useItemHook: (id) => {
+            const hookQueryClient = (0, react_query_1.useQueryClient)();
+            const singleItemQueryKey = [modelName, id];
+            // First check data from cache
+            const cachedData = hookQueryClient.getQueryData(singleItemQueryKey);
+            // Single item query
+            const { data: item, isLoading, error, refetch, } = (0, react_query_1.useQuery)({
+                queryKey: singleItemQueryKey,
+                queryFn: () => service.get(id),
+                initialData: cachedData, // Use cached data as initial value if available
+                staleTime: 1000 * 60, // Keep data "fresh" for 1 minute
+                refetchOnMount: "always", // Always attempt to refetch on mount
+                enabled: !!id, // Only enable query when id exists
+            });
+            // useMutation hooks call service methods,
+            // Service methods handle optimistic updates and cache updates/rollbacks internally.
+            // Mutations inside useHook only serve to call service methods.
+            const updateMutation = (0, react_query_1.useMutation)({
+                mutationFn: (data) => service.update(data),
+                // onSuccess, onMutate, onError logic moved to service method
+            });
+            const deleteMutation = (0, react_query_1.useMutation)({
+                mutationFn: () => service.delete(id),
+                // onSuccess, onMutate, onError logic moved to service method
+            });
+            // Interface function implementations
+            const refreshItem = (0, react_1.useCallback)(() => __awaiter(this, void 0, void 0, function* () {
+                console.log(`🍬 ${modelName} useItemHook refresh called`, singleItemQueryKey);
+                const { data } = yield refetch({ throwOnError: true }); // Throw on error
+                return data || null;
+            }), [refetch, singleItemQueryKey]); // Added queryKey dependency
+            const updateItem = (0, react_1.useCallback)((data) => __awaiter(this, void 0, void 0, function* () {
+                // No additional work needed here as cache is already updated in service.update
+                try {
+                    // Explicitly add id to resolve type error
+                    const updateData = Object.assign(Object.assign({}, data), { id });
+                    const result = yield updateMutation.mutateAsync(updateData);
+                    return result;
+                }
+                catch (error) {
+                    console.error(`🍬 ${modelName} useItemHook update error:`, error);
+                    throw error;
+                }
+            }), [updateMutation, id]);
+            const deleteItem = (0, react_1.useCallback)(() => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const result = yield deleteMutation.mutateAsync();
+                    return result;
+                }
+                catch (error) {
+                    console.error(`🍬 ${modelName} useItemHook delete error:`, error);
+                    throw error;
+                }
+            }), [deleteMutation]);
+            // Change loading state to false when isLoading is true and cached data exists
+            const effectiveLoading = isLoading && !cachedData;
+            return {
+                item: item || null,
+                isLoading: effectiveLoading, // Not loading if cached data exists
+                error: error, // Explicitly specify error type
+                refresh: refreshItem,
+                update: updateItem,
+                delete: deleteItem,
+            };
+        },
+        // Method to add model-specific extension features
+        withExtensions: (extensions) => {
+            // Add extension features to existing service object
+            return Object.assign(Object.assign({}, service), extensions);
+        },
+        // Add TanStack Query Store access method (use when needed)
+        getStore: () => {
+            // TanStack Query doesn't directly expose Zustand store
+            // Need to connect Zustand store implementation here if needed
+            console.warn(`🍬 ${modelName}.getStore() is not directly supported in TanStack Query.`);
+            // Temporarily return empty object or throw error
+            return {}; // Or throw new Error("getStore is not supported in TanStack Query implementation");
+        },
+    };
+    return service;
+}