amplifyquery 1.0.0

package/dist/singleton.d.ts

@@ -0,0 +1,14 @@
+import { AmplifyDataService, SingletonAmplifyService } from "./types";
+/**
+ * Function to create an extension service for singleton models
+ * @param baseService Base service
+ * @param getModelId Function to get the unique ID of the model
+ * @returns Extended service supporting singleton pattern
+ */
+export declare function createSingletonService<T>(baseService: AmplifyDataService<T>, getModelId: () => Promise<string>): SingletonAmplifyService<T>;
+/**
+ * Define functions to get model IDs by model
+ */
+export declare const getModelIds: {
+    User: () => Promise<string>;
+};

package/dist/singleton.js

@@ -0,0 +1,144 @@
+"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.getModelIds = void 0;
+exports.createSingletonService = createSingletonService;
+const client_1 = require("./client");
+const auth_1 = require("aws-amplify/auth");
+/**
+ * Function to create an extension service for singleton models
+ * @param baseService Base service
+ * @param getModelId Function to get the unique ID of the model
+ * @returns Extended service supporting singleton pattern
+ */
+function createSingletonService(baseService, getModelId) {
+    // Extract modelName from baseService
+    const { modelName } = baseService;
+    // Create singleton service object
+    const singletonService = Object.assign(Object.assign({}, baseService), { 
+        // Add singleton instance management methods
+        getCurrent: (options) => __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            try {
+                const modelId = yield getModelId();
+                return baseService.get(modelId, options);
+            }
+            catch (error) {
+                console.error(`${modelName} singleton instance lookup error:`, error);
+                // Safely call getStore
+                try {
+                    (_c = (_b = (_a = baseService
+                        .getStore) === null || _a === void 0 ? void 0 : _a.call(baseService)) === null || _b === void 0 ? void 0 : _b.setError) === null || _c === void 0 ? void 0 : _c.call(_b, error instanceof Error ? error : new Error(String(error)));
+                }
+                catch (storeError) {
+                    // Ignore if getStore doesn't exist or call fails
+                }
+                return null;
+            }
+        }), updateCurrent: (data) => __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            try {
+                const modelId = yield getModelId();
+                return baseService.update(Object.assign(Object.assign({}, data), { id: modelId }));
+            }
+            catch (error) {
+                console.error(`${modelName} singleton instance update error:`, error);
+                // Safely call getStore
+                try {
+                    (_c = (_b = (_a = baseService
+                        .getStore) === null || _a === void 0 ? void 0 : _a.call(baseService)) === null || _b === void 0 ? void 0 : _b.setError) === null || _c === void 0 ? void 0 : _c.call(_b, error instanceof Error ? error : new Error(String(error)));
+                }
+                catch (storeError) {
+                    // Ignore if getStore doesn't exist or call fails
+                }
+                return null;
+            }
+        }), upsertCurrent: (data) => __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
+            try {
+                const modelId = yield getModelId();
+                // Check the latest status by forced refresh
+                const existingItem = yield baseService.get(modelId, {
+                    forceRefresh: true,
+                });
+                if (existingItem) {
+                    // Update
+                    return baseService.update(Object.assign(Object.assign({}, data), { id: modelId }));
+                }
+                else {
+                    // Create (Direct call to Amplify Client - prevents random ID generation of generic create)
+                    const modelData = Object.assign(Object.assign({}, data), { id: modelId });
+                    // Safely call getStore
+                    try {
+                        (_c = (_b = (_a = baseService.getStore) === null || _a === void 0 ? void 0 : _a.call(baseService)) === null || _b === void 0 ? void 0 : _b.setLoading) === null || _c === void 0 ? void 0 : _c.call(_b, true);
+                    }
+                    catch (storeError) {
+                        // Ignore if getStore doesn't exist or call fails
+                    }
+                    try {
+                        // Call appropriate model from Amplify Models
+                        const { data: createdItem } = yield (0, client_1.getClient)().models[modelName].create(modelData);
+                        if (createdItem) {
+                            try {
+                                (_f = (_e = (_d = baseService.getStore) === null || _d === void 0 ? void 0 : _d.call(baseService)) === null || _e === void 0 ? void 0 : _e.setItem) === null || _f === void 0 ? void 0 : _f.call(_e, createdItem);
+                            }
+                            catch (storeError) {
+                                // Ignore if getStore doesn't exist or call fails
+                            }
+                        }
+                        try {
+                            (_j = (_h = (_g = baseService.getStore) === null || _g === void 0 ? void 0 : _g.call(baseService)) === null || _h === void 0 ? void 0 : _h.setLoading) === null || _j === void 0 ? void 0 : _j.call(_h, false);
+                        }
+                        catch (storeError) {
+                            // Ignore if getStore doesn't exist or call fails
+                        }
+                        return createdItem !== null && createdItem !== void 0 ? createdItem : null;
+                    }
+                    catch (apiError) {
+                        try {
+                            (_m = (_l = (_k = baseService.getStore) === null || _k === void 0 ? void 0 : _k.call(baseService)) === null || _l === void 0 ? void 0 : _l.setLoading) === null || _m === void 0 ? void 0 : _m.call(_l, false);
+                            (_q = (_p = (_o = baseService
+                                .getStore) === null || _o === void 0 ? void 0 : _o.call(baseService)) === null || _p === void 0 ? void 0 : _p.setError) === null || _q === void 0 ? void 0 : _q.call(_p, apiError instanceof Error
+                                ? apiError
+                                : new Error(String(apiError)));
+                        }
+                        catch (storeError) {
+                            // Ignore if getStore doesn't exist or call fails
+                        }
+                        console.error(`${modelName} singleton instance Upsert error:`, apiError);
+                        throw apiError; // Propagate error upwards
+                    }
+                }
+            }
+            catch (error) {
+                console.error(`${modelName} singleton instance final Upsert error:`, error);
+                return null;
+            }
+        }) });
+    return singletonService;
+}
+/**
+ * Define functions to get model IDs by model
+ */
+exports.getModelIds = {
+    // Get user ID
+    User: () => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            const { userId } = yield (0, auth_1.getCurrentUser)();
+            return userId;
+        }
+        catch (e) {
+            console.error("Failed to get user ID:", e);
+            throw new Error("Unable to retrieve user authentication information.");
+        }
+    }),
+    // Users can add their own functions to get singleton model IDs here as needed.
+};

package/dist/store.d.ts

@@ -0,0 +1,5 @@
+import { BaseModel, StoreState } from "./types";
+/**
+ * Create cache store for each model
+ */
+export declare function createModelStore<T extends BaseModel>(modelName: string): import("zustand").UseBoundStore<import("zustand").StoreApi<StoreState<T>>>;

package/dist/store.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createModelStore = createModelStore;
+const zustand_1 = require("zustand");
+/**
+ * Create cache store for each model
+ */
+function createModelStore(modelName) {
+    return (0, zustand_1.create)((set, get) => ({
+        items: [],
+        itemsMap: new Map(),
+        lastFetched: null,
+        isLoading: false,
+        error: null,
+        setItems: (items) => {
+            const itemsMap = new Map();
+            items.forEach((item) => itemsMap.set(item.id, item));
+            set({
+                items,
+                itemsMap,
+                lastFetched: Date.now(),
+                error: null,
+            });
+        },
+        setItem: (item) => {
+            const items = [...get().items];
+            const itemsMap = new Map(get().itemsMap);
+            // Search for existing item
+            const index = items.findIndex((i) => i.id === item.id);
+            if (index >= 0) {
+                // Update existing item
+                items[index] = item;
+            }
+            else {
+                // Add new item
+                items.push(item);
+            }
+            // Update map
+            itemsMap.set(item.id, item);
+            set({
+                items,
+                itemsMap,
+                lastFetched: Date.now(),
+                error: null,
+            });
+        },
+        removeItem: (id) => {
+            const items = get().items.filter((item) => item.id !== id);
+            const itemsMap = new Map(get().itemsMap);
+            itemsMap.delete(id);
+            set({
+                items,
+                itemsMap,
+                error: null,
+            });
+        },
+        setLoading: (isLoading) => set({ isLoading }),
+        setError: (error) => set({ error }),
+        resetState: () => set({
+            items: [],
+            itemsMap: new Map(),
+            lastFetched: null,
+            isLoading: false,
+            error: null,
+        }),
+    }));
+}

package/dist/types.d.ts

@@ -0,0 +1,138 @@
+/**
+ * Store state type
+ */
+export type StoreState<T> = {
+    items: T[];
+    itemsMap: Map<string, T>;
+    lastFetched: number | null;
+    isLoading: boolean;
+    error: Error | null;
+    setItems: (items: T[]) => void;
+    setItem: (item: T) => void;
+    removeItem: (id: string) => void;
+    setLoading: (isLoading: boolean) => void;
+    setError: (error: Error | null) => void;
+    resetState: () => void;
+};
+/**
+ * Hook interface type
+ */
+export type ModelHook<T> = {
+    items: T[];
+    isLoading: boolean;
+    error: Error | null;
+    getItem: (id: string) => T | null | undefined;
+    refresh: (options?: {
+        filter?: Record<string, any>;
+    }) => Promise<T[]>;
+    create: (data: Partial<T>) => Promise<T | null>;
+    update: (data: Partial<T> & {
+        id: string;
+    }) => Promise<T | null>;
+    delete: (id: string) => Promise<boolean>;
+    customList: (queryName: string, args: Record<string, any>, options?: {
+        forceRefresh?: boolean;
+    }) => Promise<T[]>;
+};
+/**
+ * Single item Hook interface type
+ */
+export type ItemHook<T> = {
+    item: T | null;
+    isLoading: boolean;
+    error: Error | null;
+    refresh: () => Promise<T | null>;
+    update: (data: Partial<T>) => Promise<T | null>;
+    delete: () => Promise<boolean>;
+};
+export type AuthMode = "apiKey" | "iam" | "identityPool" | "oidc" | "userPool" | "lambda" | "none";
+export interface AuthOptions {
+    authMode?: AuthMode;
+}
+/**
+ * Amplify Data service type
+ */
+export interface AmplifyDataService<T> {
+    create: (data: Partial<T>, options?: AuthOptions) => Promise<T | null>;
+    createList: (dataList: Partial<T>[], options?: AuthOptions) => Promise<(T | null)[]>;
+    get: (id: string, options?: {
+        forceRefresh?: boolean;
+        authMode?: AuthMode;
+    }) => Promise<T | null>;
+    list: (options?: {
+        filter?: Record<string, any>;
+        forceRefresh?: boolean;
+        authMode?: AuthMode;
+    }) => Promise<T[]>;
+    customList: (queryName: string, args: Record<string, any>, options?: {
+        forceRefresh?: boolean;
+        authMode?: AuthMode;
+    }) => Promise<T[]>;
+    update: (data: Partial<T> & {
+        id: string;
+    }, options?: AuthOptions) => Promise<T | null>;
+    delete: (id: string, options?: AuthOptions) => Promise<boolean>;
+    deleteList: (ids: string[], options?: AuthOptions) => Promise<{
+        success: string[];
+        failed: string[];
+    }>;
+    upsert: (data: Partial<T> & {
+        id: string;
+    }, options?: AuthOptions) => Promise<T | null>;
+    getStore?: () => StoreState<T>;
+    loadFromCache: () => T[];
+    resetCache: () => void;
+    useHook: (options?: {
+        initialFetchOptions?: {
+            fetch?: boolean;
+            filter?: Record<string, any>;
+        };
+        customList?: {
+            queryName: string;
+            args: Record<string, any>;
+            forceRefresh?: boolean;
+        };
+    }) => ModelHook<T>;
+    useItemHook: (id: string) => ItemHook<T>;
+    modelName: string;
+    withExtensions: <E>(extensions: E) => AmplifyDataService<T> & E;
+    setAuthMode: (authMode: AuthMode) => void;
+    getAuthMode: () => AuthMode;
+    withAuthMode: (authMode: AuthMode) => AmplifyDataService<T>;
+}
+export interface SingletonAmplifyService<T> extends AmplifyDataService<T> {
+    getCurrent: (options?: {
+        forceRefresh?: boolean;
+    }) => Promise<T | null>;
+    updateCurrent: (data: Partial<T>) => Promise<T | null>;
+    upsertCurrent: (data: Partial<T>) => Promise<T | null>;
+}
+export interface BaseModel {
+    id: string;
+    createdAt: string;
+    updatedAt: string;
+}
+/**
+ * GraphQL client interface
+ * Compatible with clients generated by AWS Amplify's generateClient() function.
+ */
+export interface GraphQLClient {
+    models: Record<string, any>;
+    queries: Record<string, any>;
+    mutations: Record<string, any>;
+}
+import { QueryClientConfig } from "@tanstack/react-query";
+/**
+ * Library configuration options
+ */
+export interface AmplifyQueryConfig {
+    client: GraphQLClient;
+    defaultAuthMode?: AuthMode;
+    isCachingEnabled?: boolean;
+    queryClientConfig?: QueryClientConfig;
+    storage?: {
+        mmkvId?: string;
+        cacheKey?: string;
+        maxAge?: number;
+    };
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils.d.ts

@@ -0,0 +1,130 @@
+import { AmplifyDataService, ModelHook, BaseModel } from "./types";
+/**
+ * Set the base URL for the app
+ * @param url Base URL for the app
+ */
+export declare function setAppUrl(url: string): void;
+/**
+ * Get the base URL for the app
+ * @returns Configured app URL or empty string
+ */
+export declare function getAppUrl(): string;
+/**
+ * Utility functions
+ */
+export declare const Utils: {
+    /**
+     * Get the ID of the currently logged-in user.
+     */
+    getUserId: () => Promise<string>;
+    /**
+     * Timestamp formatting function
+     */
+    formatTimestamp: (date?: Date) => string;
+    /**
+     * Extract YYYY-MM-DD format from date string
+     */
+    getDateString: (dateStr: string | undefined) => string;
+    /**
+     * 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: <T extends Record<string, any>>(data: T, operation: "create" | "update" | "upsert") => Omit<T, "owner">;
+};
+/**
+ * Storage related utilities
+ */
+export declare const StorageService: {
+    _types: {
+        Item: {
+            url: string;
+            expiresAt: number;
+        };
+        CacheData: {
+            [key: string]: {
+                url: string;
+                expiresAt: number;
+            };
+        };
+    };
+    _urlCache: Map<string, {
+        url: string;
+        expiresAt: number;
+    }>;
+    _CACHE_KEY: string;
+    _initialized: boolean;
+    /**
+     * Initialize the memory cache.
+     * Loads URL cache from MMKV storage.
+     */
+    _initCache: () => void;
+    /**
+     * Save cache to MMKV storage.
+     */
+    _saveCache: () => void;
+    /**
+     * 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: Blob | File, key?: string) => Promise<string>;
+    /**
+     * 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: string, options?: {
+        forceRefresh?: boolean;
+    }) => Promise<string>;
+    /**
+     * Delete a stored file.
+     * @param key Key of the file to delete
+     */
+    deleteFile: (key: string) => Promise<void>;
+    /**
+     * Clear the URL cache.
+     */
+    clearUrlCache: () => void;
+    /**
+     * Remove a specific key's URL cache.
+     * @param key Key of the URL to remove
+     */
+    clearUrlCacheForKey: (key: string) => void;
+    /**
+     * Remove only expired URL caches.
+     */
+    clearExpiredUrlCache: () => void;
+    /**
+     * Download an audio file.
+     * @param audioKey Key of the audio file to download
+     * @returns Local file system path of the downloaded file
+     */
+    downloadAudioFile: (audioKey: string) => Promise<string>;
+};
+/**
+ * Authentication related utilities
+ */
+export declare const AuthService: {
+    /**
+     * Get information about the currently logged-in user.
+     */
+    getCurrentUserInfo: () => Promise<{
+        userId: string;
+        username: string;
+    }>;
+};
+/**
+ * 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
+ */
+export declare function createRelationalHook<T extends BaseModel, R extends BaseModel = any>(service: AmplifyDataService<T>, relationName: string, queryName: string, idParamName?: string): (id: string) => ModelHook<T>;