amplifyquery 1.0.0

package/dist/utils.js

@@ -0,0 +1,437 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthService = exports.StorageService = exports.Utils = void 0;
+exports.setAppUrl = setAppUrl;
+exports.getAppUrl = getAppUrl;
+exports.createRelationalHook = createRelationalHook;
+const react_query_1 = require("@tanstack/react-query");
+const auth_1 = require("aws-amplify/auth");
+const storage_1 = require("aws-amplify/storage");
+const expo_crypto_1 = require("expo-crypto");
+const FileSystem = __importStar(require("expo-file-system"));
+const react_1 = require("react");
+const react_native_mmkv_1 = require("react-native-mmkv");
+// Create MMKV storage instance
+const storage = new react_native_mmkv_1.MMKV({ id: "mmkv.amplify-query" });
+// Key for managing app URL
+const APP_URL_KEY = "amplify_query_app_url";
+/**
+ * Set the base URL for the app
+ * @param url Base URL for the app
+ */
+function setAppUrl(url) {
+    storage.set(APP_URL_KEY, url);
+}
+/**
+ * Get the base URL for the app
+ * @returns Configured app URL or empty string
+ */
+function getAppUrl() {
+    return storage.getString(APP_URL_KEY) || "";
+}
+/**
+ * Utility functions
+ */
+exports.Utils = {
+    /**
+     * Get the ID of the currently logged-in user.
+     */
+    getUserId: () => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            const user = yield (0, auth_1.getCurrentUser)();
+            return user.userId;
+        }
+        catch (e) {
+            console.error("Failed to get user ID:", e);
+            throw new Error("Could not retrieve user authentication information.");
+        }
+    }),
+    /**
+     * Timestamp formatting function
+     */
+    formatTimestamp: (date = new Date()) => {
+        return date.toISOString();
+    },
+    /**
+     * Extract YYYY-MM-DD format from date string
+     */
+    getDateString: (dateStr) => {
+        if (!dateStr)
+            return "";
+        return dateStr.split("T")[0];
+    },
+    /**
+     * Utility function to remove the owner field and print a warning
+     * @param data Data object to process
+     * @param operation Operation being performed (create or update)
+     * @returns Data object with owner field removed
+     */
+    removeOwnerField: (data, operation) => {
+        const { owner } = data, dataWithoutOwner = __rest(data, ["owner"]);
+        if (owner) {
+            console.warn(`The owner field exists. This field is added automatically and will be excluded from the ${operation} operation.`);
+        }
+        return dataWithoutOwner;
+    },
+};
+/**
+ * Storage related utilities
+ */
+exports.StorageService = {
+    // URL cache internal type definition
+    _types: {
+        // URL cache interface (used internally only)
+        Item: {},
+        // Cache data structure (stored as key-value)
+        CacheData: {},
+    },
+    // Memory cache (for fast access)
+    _urlCache: new Map(),
+    // MMKV cache storage key
+    _CACHE_KEY: "storage_url_cache",
+    // Initialization status
+    _initialized: false,
+    /**
+     * Initialize the memory cache.
+     * Loads URL cache from MMKV storage.
+     */
+    _initCache: () => {
+        if (exports.StorageService._initialized)
+            return;
+        try {
+            // Retrieve URL cache data from MMKV
+            const cachedData = storage.getString(exports.StorageService._CACHE_KEY);
+            // Restore to memory cache
+            if (cachedData && cachedData.length > 0) {
+                const parsedData = JSON.parse(cachedData);
+                const now = Date.now();
+                // Add only non-expired items to memory cache
+                Object.entries(parsedData).forEach(([key, item]) => {
+                    if (item.expiresAt > now) {
+                        exports.StorageService._urlCache.set(key, {
+                            url: item.url,
+                            expiresAt: item.expiresAt,
+                        });
+                    }
+                });
+            }
+            exports.StorageService._initialized = true;
+        }
+        catch (error) {
+            console.error("URL cache initialization error:", error);
+            // Clear cache on error
+            exports.StorageService.clearUrlCache();
+            exports.StorageService._initialized = true;
+        }
+    },
+    /**
+     * Save cache to MMKV storage.
+     */
+    _saveCache: () => {
+        try {
+            const cacheData = {};
+            // Convert memory cache to persistent storage format
+            exports.StorageService._urlCache.forEach((item, key) => {
+                cacheData[key] = {
+                    url: item.url,
+                    expiresAt: item.expiresAt,
+                };
+            });
+            // Save to MMKV
+            storage.set(exports.StorageService._CACHE_KEY, JSON.stringify(cacheData));
+        }
+        catch (error) {
+            console.error("URL cache save error:", error);
+        }
+    },
+    /**
+     * Upload an image file to Storage.
+     * @param file File to upload (Blob or File object)
+     * @param key Path and filename to save as (auto-generated if not specified)
+     * @returns Key of the uploaded file
+     */
+    uploadImage: (file, key) => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            const fileKey = key || `images/${(0, expo_crypto_1.randomUUID)()}.${file.type.split("/")[1] || "jpg"}`;
+            const result = yield (0, storage_1.uploadData)({
+                path: fileKey,
+                data: file,
+                options: {
+                    contentType: file.type,
+                },
+            }).result;
+            return result.path;
+        }
+        catch (error) {
+            console.error("File upload failed:", error);
+            throw error;
+        }
+    }),
+    /**
+     * Get the URL of a stored file. (Auto-caching)
+     * @param key File key
+     * @param options Caching options (forceRefresh: ignore cache and fetch new URL)
+     * @returns File URL
+     */
+    getFileUrl: (key, options) => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            // Initialize cache (only runs on first call)
+            if (!exports.StorageService._initialized) {
+                exports.StorageService._initCache();
+            }
+            // If not ignoring cache and URL is in cache, return from cache
+            const cachedItem = exports.StorageService._urlCache.get(key);
+            const now = Date.now();
+            // If cached URL exists, is not expired, and not forced refresh
+            if (cachedItem && cachedItem.expiresAt > now && !(options === null || options === void 0 ? void 0 : options.forceRefresh)) {
+                return cachedItem.url;
+            }
+            // If not in cache, expired, or forced refresh, get new URL
+            // Number of seconds till the URL expires.
+            // The expiration time of the presigned url is dependent on the session and will max out at 1 hour.
+            const result = yield (0, storage_1.getUrl)({
+                path: key,
+                options: {
+                    // Default 1 hour expiration, adjustable if needed
+                    expiresIn: 60 * 60, // 1 hour
+                },
+            });
+            const url = result.url.toString();
+            // Convert expiration time to timestamp
+            const expiresAt = result.expiresAt.getTime();
+            // Save to cache
+            exports.StorageService._urlCache.set(key, {
+                url,
+                expiresAt,
+            });
+            // Also save to persistent storage
+            exports.StorageService._saveCache();
+            return url;
+        }
+        catch (error) {
+            console.error("Failed to get file URL:", error);
+            throw error;
+        }
+    }),
+    /**
+     * Delete a stored file.
+     * @param key Key of the file to delete
+     */
+    deleteFile: (key) => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            yield (0, storage_1.remove)({ path: key });
+            // Remove from cache on file deletion
+            exports.StorageService._urlCache.delete(key);
+            // Update persistent storage
+            exports.StorageService._saveCache();
+        }
+        catch (error) {
+            console.error("File deletion failed:", error);
+            throw error;
+        }
+    }),
+    /**
+     * Clear the URL cache.
+     */
+    clearUrlCache: () => {
+        exports.StorageService._urlCache.clear();
+        storage.delete(exports.StorageService._CACHE_KEY);
+    },
+    /**
+     * Remove a specific key's URL cache.
+     * @param key Key of the URL to remove
+     */
+    clearUrlCacheForKey: (key) => {
+        exports.StorageService._urlCache.delete(key);
+        // Update persistent storage
+        exports.StorageService._saveCache();
+    },
+    /**
+     * Remove only expired URL caches.
+     */
+    clearExpiredUrlCache: () => {
+        const now = Date.now();
+        for (const [key, item] of exports.StorageService._urlCache.entries()) {
+            if (item.expiresAt <= now) {
+                exports.StorageService._urlCache.delete(key);
+            }
+        }
+        // Update persistent storage
+        exports.StorageService._saveCache();
+    },
+    /**
+     * Download an audio file.
+     * @param audioKey Key of the audio file to download
+     * @returns Local file system path of the downloaded file
+     */
+    downloadAudioFile: (audioKey) => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            // Create directory path where the file will be saved
+            const audioDir = `${FileSystem.cacheDirectory}sounds/`;
+            const localFilePath = `${audioDir}${audioKey}`;
+            // Check if directory exists, create if not
+            const dirInfo = yield FileSystem.getInfoAsync(audioDir);
+            if (!dirInfo.exists) {
+                yield FileSystem.makeDirectoryAsync(audioDir, { intermediates: true });
+            }
+            // Check if file already exists
+            const fileInfo = yield FileSystem.getInfoAsync(localFilePath);
+            if (fileInfo.exists) {
+                console.log("Audio file already exists locally:", localFilePath);
+                return localFilePath;
+            }
+            // Get file URL from S3
+            const s3Url = yield (0, storage_1.getUrl)({ path: `public/sound/${audioKey}` });
+            // Download file
+            const downloadResult = yield FileSystem.downloadAsync(s3Url.url.toString(), localFilePath);
+            console.log("Audio file downloaded successfully:", downloadResult.uri);
+            return downloadResult.uri;
+        }
+        catch (error) {
+            console.error("Audio file download failed:", error);
+            throw error;
+        }
+    }),
+};
+/**
+ * Authentication related utilities
+ */
+exports.AuthService = {
+    /**
+     * Get information about the currently logged-in user.
+     */
+    getCurrentUserInfo: () => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            const user = yield (0, auth_1.getCurrentUser)();
+            return {
+                userId: user.userId,
+                username: user.username,
+            };
+        }
+        catch (e) {
+            console.error("Error getting current user info:", e);
+            throw new Error("Could not retrieve user authentication information.");
+        }
+    }),
+};
+/**
+ * Utility to create a relational query hook.
+ * Creates a hook to query related items based on a specific foreign key.
+ *
+ * @param service Base service object
+ * @param relationName Name of the relation (e.g., Daily, User)
+ * @param queryName API query name (e.g., listMissionsByDaily)
+ * @param idParamName ID parameter name (e.g., dailyId, userId)
+ * @returns Relational query hook function
+ */
+function createRelationalHook(service, relationName, queryName, idParamName = `${relationName.toLowerCase()}Id`) {
+    return (id) => {
+        // Create query key - set dedicated cache key for specific relation ID
+        const queryKey = [
+            service.modelName,
+            relationName,
+            id, // Explicitly include relation ID in query key for cache separation
+            "query",
+            queryName,
+            JSON.stringify({ [idParamName]: id }),
+        ];
+        // Get only CRUD methods from existing hook
+        const baseHook = service.useHook({
+            initialFetchOptions: { fetch: false },
+        });
+        // Execute query to fetch actual data
+        const { data = [], isLoading, error, refetch, } = (0, react_query_1.useQuery)({
+            queryKey,
+            queryFn: () => service.customList(queryName, { [idParamName]: id }),
+            enabled: !!id, // Enable query only when ID exists
+            // Configure caching for optimized data per relation ID
+            staleTime: 1000 * 30, // Keep fresh for 30 seconds
+            gcTime: 1000 * 60 * 5, // Keep in cache for 5 minutes
+        });
+        // Custom CRUD methods specific to the ID
+        const createItem = (0, react_1.useCallback)((data) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                // Add relation ID field
+                const dataWithRelation = Object.assign(Object.assign({}, data), { [idParamName]: id });
+                // Auto-update cache per relation ID after creation
+                const result = yield service.create(dataWithRelation);
+                // Force refresh list per relation ID
+                yield refetch();
+                return result;
+            }
+            catch (error) {
+                console.error(`🍬 ${service.modelName} relational create error:`, error);
+                throw error;
+            }
+        }), [service, id, refetch]);
+        // Integrate data and loading state from useQuery, methods from baseHook
+        return {
+            items: data,
+            isLoading,
+            error,
+            getItem: baseHook.getItem,
+            refresh: () => __awaiter(this, void 0, void 0, function* () {
+                console.log(`🍬 ${service.modelName} relational refresh called`, id);
+                const { data } = yield refetch({ throwOnError: true });
+                return data || [];
+            }),
+            create: createItem, // ID-specific method
+            update: baseHook.update,
+            delete: baseHook.delete,
+            customList: baseHook.customList,
+        };
+    };
+}

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "amplifyquery",
+  "version": "1.0.0",
+  "description": "Amplify+Query",
+  "keywords": [
+    "Amplify",
+    "React Query",
+    "TypeScript"
+  ],
+  "homepage": "https://github.com/Sun-Woo-Kim/AmplifyQuery#readme",
+  "bugs": {
+    "url": "https://github.com/Sun-Woo-Kim/AmplifyQuery/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Sun-Woo-Kim/AmplifyQuery.git"
+  },
+  "license": "MIT",
+  "author": "Sun-Woo-Kim",
+  "type": "commonjs",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "clean": "rm -rf dist",
+    "dev": "tsc --watch",
+    "prepare": "npm run build",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "dependencies": {
+    "@aws-amplify/api": "^6.3.11",
+    "@aws-amplify/core": "^6.11.4",
+    "@aws-amplify/datastore": "^5.0.82",
+    "@babel/core": "^7.27.1",
+    "@react-native-async-storage/async-storage": "^2.1.2",
+    "@tanstack/react-query": "^5.76.1",
+    "@tanstack/react-query-persist-client": "^5.76.1",
+    "@types/react": "^19.1.4",
+    "amplify": "^0.0.11",
+    "aws-amplify": "^6.14.4",
+    "expo": "^53.0.9",
+    "expo-crypto": "^14.1.4",
+    "expo-file-system": "^18.1.10",
+    "react": "^19.1.0",
+    "react-native": "^0.79.2",
+    "react-native-mmkv": "^3.2.0",
+    "typescript": "^5.8.3",
+    "zustand": "^5.0.4"
+  }
+}