amplifyquery 1.0.21 → 2.0.2

package/dist/service.js

@@ -73,17 +73,25 @@ function getOwnerByAuthMode(authMode) {
         if (authMode === "userPool") {
             try {
                 const { username, userId } = yield (0, auth_1.getCurrentUser)();
-                // Canonical "owner" in Amplify is typically the Cognito user sub / userId.
-                // Some legacy codepaths used `${userId}::${username}`. We keep it as a fallback
-                // candidate so list-by-owner can still find older records.
-                const canonicalOwner = userId;
-                // Avoid useless legacy candidates like `${userId}::${userId}` (can happen depending on username config).
-                const legacyOwner = username && userId && username !== userId ? `${userId}::${username}` : "";
-                owner = canonicalOwner;
-                ownerCandidates = [canonicalOwner].filter(Boolean);
-                if (legacyOwner && legacyOwner !== canonicalOwner) {
-                    ownerCandidates.push(legacyOwner);
-                }
+                // IMPORTANT:
+                // Amplify "owner" authorization commonly uses `cognito:username` by default,
+                // but some projects store `sub` (userId) instead. To avoid "refetch clears list"
+                // issues when using list-by-owner secondary indexes, we try multiple candidates.
+                //
+                // Candidates priority (unique, non-empty):
+                // - userId (sub)
+                // - username (cognito:username)
+                // - legacy `${userId}::${username}` (older patterns)
+                const canonicalSub = typeof userId === "string" ? userId : "";
+                const canonicalUsername = typeof username === "string" ? username : "";
+                const legacyOwner = canonicalSub && canonicalUsername && canonicalUsername !== canonicalSub
+                    ? `${canonicalSub}::${canonicalUsername}`
+                    : "";
+                // Keep `owner` for compatibility (used in some create/update paths), prefer sub.
+                owner = canonicalSub || canonicalUsername;
+                const candidates = [canonicalSub, canonicalUsername, legacyOwner].filter((v) => typeof v === "string" && v.length > 0);
+                // De-dupe while preserving order
+                ownerCandidates = Array.from(new Set(candidates));
             }
             catch (error) {
                 console.error("Error getting user authentication info:", error);
@@ -667,7 +675,7 @@ function createAmplifyService(modelName, defaultAuthMode) {
                     }
                     const client = (0, client_1.getClient)();
                     const model = (_b = client.models) === null || _b === void 0 ? void 0 : _b[modelName];
-                    // Execute owner query (try canonical owner first, then legacy owner formats)
+                    // Execute owner query (try multiple owner candidates)
                     const ownersToTry = Array.isArray(ownerCandidates) && ownerCandidates.length > 0
                         ? ownerCandidates
                         : owner
@@ -690,6 +698,21 @@ function createAmplifyService(modelName, defaultAuthMode) {
                         }
                         // If empty, try next candidate (legacy owner format)
                     }
+                    // If owner-query returns empty for all candidates, fall back to default list().
+                    // This prevents "data disappears on refetch" when the project stores owner using
+                    // a different identity claim than expected (e.g., username vs sub) OR when the
+                    // owner secondary index exists but doesn't match stored owner values.
+                    if (!result) {
+                        (0, config_1.debugWarn)(`🍬 ${modelName} list: owner-query returned 0 items for all candidates, falling back to model.list()`, { ownersToTry, authMode });
+                        const { data: fallback } = yield model.list({}, authModeParams);
+                        const fallbackItems = ((fallback === null || fallback === void 0 ? void 0 : fallback.items) ||
+                            (fallback === null || fallback === void 0 ? void 0 : fallback.data) ||
+                            fallback ||
+                            []).filter((item) => item !== null);
+                        // Use the same shape below by setting `result` to array-ish
+                        result = fallbackItems;
+                        usedOwner = null;
+                    }
                     if (usedOwner && usedOwner !== ownersToTry[0]) {
                         (0, config_1.debugWarn)(`🍬 ${modelName} list: owner-query returned results only for legacy owner format`, { tried: ownersToTry, usedOwner });
                     }
@@ -1122,14 +1145,13 @@ function createAmplifyService(modelName, defaultAuthMode) {
                 // 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 { owner, ownerCandidates, authModeParams } = yield getOwnerByAuthMode(authMode);
+                // Add owner value to queries requiring owner field when userPool auth.
+                // IMPORTANT: many projects store owner as `cognito:username`, not `sub`.
+                // If this is an owner-based index query, try multiple owner candidates to
+                // avoid returning empty results and accidentally clearing UI state on refetch.
+                const isOwnerQuery = authMode === "userPool" && queryName.toLowerCase().includes("owner");
                 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;
@@ -1165,8 +1187,40 @@ function createAmplifyService(modelName, defaultAuthMode) {
                 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);
+                const model = (0, client_1.getClient)().models[modelName];
+                // Execute index query - apply auth mode (with owner-candidate fallback)
+                let result = null;
+                if (isOwnerQuery) {
+                    const candidates = [
+                        // If caller explicitly passed owner, try that first
+                        typeof (args === null || args === void 0 ? void 0 : args.owner) === "string" ? args.owner : "",
+                        ...(Array.isArray(ownerCandidates) ? ownerCandidates : []),
+                        typeof owner === "string" ? owner : "",
+                    ].filter((v) => typeof v === "string" && v.length > 0);
+                    const ownersToTry = Array.from(new Set(candidates));
+                    if (ownersToTry.length === 0) {
+                        throw new Error(`🍬 owner is missing for ${modelName}.${queryName}`);
+                    }
+                    for (const candidateOwner of ownersToTry) {
+                        const nextArgs = Object.assign(Object.assign({}, enhancedArgs), { owner: candidateOwner });
+                        const { data } = yield model[queryName](nextArgs, authModeParams);
+                        const items = ((data === null || data === void 0 ? void 0 : data.items) || (data === null || data === void 0 ? void 0 : data.data) || data || []).filter((item) => item !== null);
+                        if (items.length > 0) {
+                            result = data;
+                            if (candidateOwner !== ownersToTry[0]) {
+                                (0, config_1.debugWarn)(`🍬 ${modelName} ${queryName}: returned results only for non-primary owner candidate`, { tried: ownersToTry, usedOwner: candidateOwner });
+                            }
+                            break;
+                        }
+                    }
+                    // If still empty, return empty list (do not throw unless requested)
+                    if (!result) {
+                        result = [];
+                    }
+                }
+                else {
+                    ({ data: result } = yield model[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 || [];
                 (0, config_1.debugLog)(`🍬 ${modelName} ${queryName} result:`, items.length, "items");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "amplifyquery",
-  "version": "1.0.21",
+  "version": "2.0.2",
   "description": "Amplify+Query",
   "keywords": [
     "Amplify",
@@ -29,6 +29,7 @@
     "dev": "expo-module build --watch",
     "lint": "expo-module lint",
     "typecheck": "expo-module typecheck",
+    "codegen:service": "node ./codegen/generateAmplifyService.js",
     "prepare": "expo-module prepare",
     "prepublishOnly": "expo-module prepublishOnly",
     "test": "expo-module test"