@codeleap/query 7.0.0 → 7.0.2

package/dist/lib/QueryOperations/index.js

@@ -0,0 +1,288 @@
+"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.QueryOperations = void 0;
+const react_query_1 = require("@tanstack/react-query");
+const QueryClientEnhanced_1 = require("../QueryClientEnhanced");
+/**
+ * Builder class for creating type-safe query and mutation operations
+ * @template TMutations - Record type containing all registered mutation functions
+ * @template TQueries - Record type containing all registered query functions
+ *
+ * @description
+ * QueryOperations provides a fluent interface for building collections of queries and mutations
+ * with full type safety. It acts as a centralized registry for all data operations and provides
+ * corresponding React hooks that are automatically typed based on the registered functions.
+ *
+ * Key features:
+ * - Fluent builder pattern for registering operations
+ * - Automatic type inference for parameters and return types
+ * - Type-safe React hooks generation
+ * - Immutable operation registration (returns new instances)
+ */
+class QueryOperations {
+    /**
+     * Creates a new QueryOperations instance
+     * @param _options - Configuration options including QueryClient
+     * @param _mutations - Record of registered mutation functions (internal)
+     * @param _queries - Record of registered query functions (internal)
+     */
+    constructor(_options, _mutations = {}, _queries = {}) {
+        this._options = _options;
+        this._mutations = _mutations;
+        this._queries = _queries;
+    }
+    /**
+     * Gets all registered mutation functions
+     * @returns Readonly record of mutation functions
+     */
+    get mutations() {
+        return this._mutations;
+    }
+    get queryClient() {
+        if (this._options.queryClient instanceof QueryClientEnhanced_1.QueryClientEnhanced) {
+            return this._options.queryClient.client;
+        }
+        return this._options.queryClient;
+    }
+    /**
+     * Gets all registered query functions
+     * @returns Readonly record of query functions
+     */
+    get queries() {
+        return this._queries;
+    }
+    /**
+     * Registers a new mutation function
+     * @template K - The name/key for the mutation
+     * @template T - The input data type for the mutation
+     * @template R - The return data type for the mutation
+     * @param name - Unique name identifier for the mutation
+     * @param fn - The mutation function that performs the operation
+     * @returns New QueryOperations instance with the mutation added
+     *
+     * @example
+     * ```typescript
+     * const operations = createQueryOperations({ queryClient })
+     *   .mutation('createUser', async (userData: CreateUserData) => {
+     *     return api.post('/users', userData)
+     *   })
+     *   .mutation('updateUser', async (userData: UpdateUserData) => {
+     *     return api.put(`/users/${userData.id}`, userData)
+     *   })
+     * ```
+     */
+    mutation(name, fn) {
+        return new QueryOperations(this._options, Object.assign(Object.assign({}, this._mutations), { [name]: fn }), this._queries);
+    }
+    /**
+     * Registers a new query function
+     * @template K - The name/key for the query
+     * @template T - The parameters type for the query
+     * @template R - The return data type for the query
+     * @param name - Unique name identifier for the query
+     * @param fn - The query function that fetches the data
+     * @returns New QueryOperations instance with the query added
+     *
+     * @example
+     * ```typescript
+     * const operations = createQueryOperations({ queryClient })
+     *   .query('getUser', async (userId: string) => {
+     *     return api.get(`/users/${userId}`)
+     *   })
+     *   .query('getUsers', async (filters?: UserFilters) => {
+     *     return api.get('/users', { params: filters })
+     *   })
+     * ```
+     */
+    query(name, fn) {
+        return new QueryOperations(this._options, this._mutations, Object.assign(Object.assign({}, this._queries), { [name]: fn }));
+    }
+    /**
+     * React hook for executing mutations with full type safety
+     * @template K - The mutation key type
+     * @param mutationKey - The name of the registered mutation to use
+     * @param options - React Query mutation options (excluding mutationFn and mutationKey)
+     * @returns React Query mutation object with inferred types
+     *
+     * @description
+     * This hook automatically provides type-safe parameters and return types based on the
+     * registered mutation function. It handles error cases and provides proper TypeScript
+     * inference for the mutation data and variables.
+     *
+     * @example
+     * ```typescript
+     * const createUserMutation = operations.useMutation('createUser', {
+     *   onSuccess: (user) => {
+     *     // 'user' is automatically typed as the return type of createUser
+     *     console.log('Created user:', user.id)
+     *   }
+     * })
+     *
+     * // Usage - parameters are type-checked
+     * createUserMutation.mutate({ name: 'John', email: 'john@example.com' })
+     * ```
+     */
+    useMutation(mutationKey, options) {
+        const mutationFn = this._mutations[mutationKey];
+        return (0, react_query_1.useMutation)(Object.assign({ mutationKey: this.getMutationKey(mutationKey), mutationFn: (data) => __awaiter(this, void 0, void 0, function* () {
+                if (!mutationFn) {
+                    throw new Error(`Mutation "${String(mutationKey)}" not found`);
+                }
+                return mutationFn(data);
+            }) }, options));
+    }
+    /**
+     * React hook for executing queries with full type safety
+     * @template K - The query key type
+     * @param queryKey - The name of the registered query to use
+     * @param params - Parameters to pass to the query function (optional if query doesn't require params)
+     * @param options - React Query options (excluding queryKey and queryFn)
+     * @returns React Query query object with inferred types
+     *
+     * @description
+     * This hook automatically provides type-safe parameters and return types based on the
+     * registered query function. It generates appropriate query keys and handles parameter
+     * validation.
+     *
+     * @example
+     * ```typescript
+     * // Query with parameters
+     * const userQuery = operations.useQuery('getUser', 'user-123', {
+     *   enabled: !!userId
+     * })
+     *
+     * // Query without parameters
+     * const usersQuery = operations.useQuery('getUsers', undefined, {
+     *   refetchInterval: 30000
+     * })
+     *
+     * // Query with optional parameters
+     * const filteredUsersQuery = operations.useQuery('getUsers', { status: 'active' })
+     * ```
+     */
+    useQuery(queryKey, params, options) {
+        const queryFn = this._queries[queryKey];
+        return (0, react_query_1.useQuery)(Object.assign({ queryKey: this.getQueryKey(queryKey, params), queryFn: () => __awaiter(this, void 0, void 0, function* () {
+                if (!queryFn) {
+                    throw new Error(`Query "${String(queryKey)}" not found`);
+                }
+                return queryFn(params);
+            }) }, options));
+    }
+    /**
+     * Generates a properly typed query key for React Query
+     * @template K - The query key type
+     * @param queryKey - The name of the query
+     * @param params - Optional parameters for the query
+     * @returns Query key array, with params included only when necessary
+     *
+     * @description
+     * This method creates React Query compatible keys that include parameters when present.
+     * The return type is conditionally typed based on whether the query requires parameters.
+     *
+     * @example
+     * ```typescript
+     * // Returns ['getUser', 'user-123']
+     * const keyWithParams = operations.getQueryKey('getUser', 'user-123')
+     *
+     * // Returns ['getUsers']
+     * const keyWithoutParams = operations.getQueryKey('getUsers')
+     * ```
+     */
+    getQueryKey(queryKey, params) {
+        return (params !== undefined ? [queryKey, params] : [queryKey]);
+    }
+    /**
+     * Generates a mutation key for React Query
+     * @template K - The mutation key type
+     * @param mutationKey - The name of the mutation
+     * @returns Mutation key array containing only the mutation name
+     *
+     * @example
+     * ```typescript
+     * // Returns ['createUser']
+     * const mutationKey = operations.getMutationKey('createUser')
+     * ```
+     */
+    getMutationKey(mutationKey) {
+        return [mutationKey];
+    }
+    /**
+     * Prefetches a query to populate the cache ahead of time
+     * @template K - The query key type
+     * @param queryKey - The name of the registered query to prefetch
+     * @param params - Parameters to pass to the query function (optional if query doesn't require params)
+     * @param options - React Query prefetch options
+     * @returns Promise that resolves when the prefetch is complete
+     *
+     * @example
+     * ```typescript
+     * // Prefetch user data when hovering over a user link
+     * const handleUserHover = async (userId: string) => {
+     *   await operations.prefetchQuery('getUser', userId, {
+     *     staleTime: 5 * 60 * 1000 // 5 minutes
+     *   })
+     * }
+     *
+     * // Prefetch data on route change
+     * useEffect(() => {
+     *   operations.prefetchQuery('getUsers', { status: 'active' })
+     * }, [])
+     * ```
+     */
+    prefetchQuery(queryKey, params, options) {
+        const prefetchQueryKey = this.getQueryKey(queryKey, params);
+        const queryFn = this._queries[queryKey];
+        return this.queryClient.prefetchQuery(Object.assign({ queryKey: prefetchQueryKey, queryFn: queryFn }, options));
+    }
+    /**
+     * Retrieves cached query data if it exists
+     * @template K - The query key type
+     * @template T - The expected return type (defaults to inferred query return type)
+     * @param queryKey - The name of the registered query
+     * @param params - Parameters used when the query was cached (optional if query doesn't require params)
+     * @returns The cached data if it exists, undefined otherwise
+     *
+     * @example
+     * ```typescript
+     * // Get cached user data
+     * const cachedUser = operations.getQueryData('getUser', 'user-123')
+     * if (cachedUser) {
+     *   console.log('User already in cache:', cachedUser.name)
+     * }
+     *
+     * // Check if users list is cached before showing loading state
+     * const cachedUsers = operations.getQueryData('getUsers')
+     * const showSkeleton = !cachedUsers
+     *
+     * // Access cached data in event handlers
+     * const handleUserAction = () => {
+     *   const currentUser = operations.getQueryData('getCurrentUser')
+     *   if (currentUser?.role === 'admin') {
+     *     // Perform admin action
+     *   }
+     * }
+     * ```
+     */
+    getQueryData(queryKey, params, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const prefetchQueryKey = this.getQueryKey(queryKey, params);
+            const cachedData = this.queryClient.getQueryData(prefetchQueryKey);
+            if (!cachedData) {
+                yield this.prefetchQuery(queryKey, params, options);
+            }
+            return this.queryClient.getQueryData(prefetchQueryKey);
+        });
+    }
+}
+exports.QueryOperations = QueryOperations;
+//# sourceMappingURL=index.js.map

package/dist/lib/QueryOperations/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/lib/QueryOperations/index.ts"],"names":[],"mappings":"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"}

package/dist/lib/QueryOperations/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/lib/QueryOperations/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/lib/QueryOperations/types.ts"],"names":[],"mappings":""}

package/dist/lib/index.js

@@ -0,0 +1,22 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./QueryClientEnhanced"), exports);
+__exportStar(require("./QueryKeys"), exports);
+__exportStar(require("./Mutations"), exports);
+__exportStar(require("./QueryManager"), exports);
+__exportStar(require("./QueryOperations"), exports);
+//# sourceMappingURL=index.js.map

package/dist/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/lib/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,wDAAqC;AACrC,8CAA2B;AAC3B,8CAA2B;AAC3B,iDAA8B;AAC9B,oDAAiC"}

package/dist/types/core.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=core.js.map

package/dist/types/core.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.js","sourceRoot":"","sources":["../../src/types/core.ts"],"names":[],"mappings":""}

package/dist/types/create.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=create.js.map

package/dist/types/create.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create.js","sourceRoot":"","sources":["../../src/types/create.ts"],"names":[],"mappings":""}

package/dist/types/delete.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=delete.js.map

package/dist/types/delete.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"delete.js","sourceRoot":"","sources":["../../src/types/delete.ts"],"names":[],"mappings":""}

package/dist/types/index.js

@@ -0,0 +1,24 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./core"), exports);
+__exportStar(require("./list"), exports);
+__exportStar(require("./utility"), exports);
+__exportStar(require("./retrieve"), exports);
+__exportStar(require("./create"), exports);
+__exportStar(require("./update"), exports);
+__exportStar(require("./delete"), exports);
+//# sourceMappingURL=index.js.map

package/dist/types/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,yCAAsB;AACtB,yCAAsB;AACtB,4CAAyB;AACzB,6CAA0B;AAC1B,2CAAwB;AACxB,2CAAwB;AACxB,2CAAwB"}

package/dist/types/list.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=list.js.map

package/dist/types/list.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"list.js","sourceRoot":"","sources":["../../src/types/list.ts"],"names":[],"mappings":""}

package/dist/types/retrieve.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=retrieve.js.map

package/dist/types/retrieve.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"retrieve.js","sourceRoot":"","sources":["../../src/types/retrieve.ts"],"names":[],"mappings":""}

package/dist/types/update.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=update.js.map

package/dist/types/update.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"update.js","sourceRoot":"","sources":["../../src/types/update.ts"],"names":[],"mappings":""}

package/dist/types/utility.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=utility.js.map

package/dist/types/utility.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utility.js","sourceRoot":"","sources":["../../src/types/utility.ts"],"names":[],"mappings":""}

package/dist/utils/index.js

@@ -0,0 +1,18 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./misc"), exports);
+//# sourceMappingURL=index.js.map

package/dist/utils/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,yCAAsB"}

package/dist/utils/misc.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateTempId = exports.tempIdPrefix = void 0;
+function uuidV4() {
+    function randomHex() {
+        return Math.floor(Math.random() * 16).toString(16);
+    }
+    let uuid = '';
+    for (let i = 0; i < 8; i++) {
+        uuid += randomHex();
+    }
+    uuid += '-';
+    for (let i = 0; i < 4; i++) {
+        uuid += randomHex();
+    }
+    uuid += '-';
+    uuid += '4';
+    for (let i = 0; i < 3; i++) {
+        uuid += randomHex();
+    }
+    uuid += '-';
+    uuid += ['8', '9', 'a', 'b'][Math.floor(Math.random() * 4)];
+    for (let i = 0; i < 3; i++) {
+        uuid += randomHex();
+    }
+    uuid += '-';
+    for (let i = 0; i < 12; i++) {
+        uuid += randomHex();
+    }
+    return uuid;
+}
+/** Prefix used on every optimistically-created item id. Check `id.startsWith(tempIdPrefix)` to distinguish placeholder items from server-assigned ids. */
+exports.tempIdPrefix = 'temp-id';
+/** Returns a unique placeholder id for optimistic creates. The format is `temp-id-<uuidv4>` and is guaranteed never to collide with server-assigned ids. */
+const generateTempId = () => {
+    return exports.tempIdPrefix + '-' + uuidV4();
+};
+exports.generateTempId = generateTempId;
+//# sourceMappingURL=misc.js.map

package/dist/utils/misc.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"misc.js","sourceRoot":"","sources":["../../src/utils/misc.ts"],"names":[],"mappings":";;;AAAA,SAAS,MAAM;IACb,SAAS,SAAS;QAChB,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;IACrD,CAAC;IAED,IAAI,IAAI,GAAG,EAAE,CAAA;IAEb,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;QAC3B,IAAI,IAAI,SAAS,EAAE,CAAA;IACrB,CAAC;IAED,IAAI,IAAI,GAAG,CAAA;IAEX,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;QAC3B,IAAI,IAAI,SAAS,EAAE,CAAA;IACrB,CAAC;IAED,IAAI,IAAI,GAAG,CAAA;IAEX,IAAI,IAAI,GAAG,CAAC;IACZ,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;QAC3B,IAAI,IAAI,SAAS,EAAE,CAAA;IACrB,CAAC;IACD,IAAI,IAAI,GAAG,CAAA;IAEX,IAAI,IAAI,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC;IAC5D,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;QAC3B,IAAI,IAAI,SAAS,EAAE,CAAA;IACrB,CAAC;IACD,IAAI,IAAI,GAAG,CAAA;IAEX,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,EAAE,EAAE,CAAC;QAC5B,IAAI,IAAI,SAAS,EAAE,CAAA;IACrB,CAAC;IAED,OAAO,IAAI,CAAA;AACb,CAAC;AAED,0JAA0J;AAC7I,QAAA,YAAY,GAAG,SAAS,CAAA;AAErC,4JAA4J;AACrJ,MAAM,cAAc,GAAG,GAAG,EAAE;IACjC,OAAO,oBAAY,GAAG,GAAG,GAAG,MAAM,EAAE,CAAA;AACtC,CAAC,CAAA;AAFY,QAAA,cAAc,kBAE1B"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@codeleap/query",
-  "version": "7.0.0",
-  "main": "src/index.ts",
+  "version": "7.0.2",
+  "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {
     ".": {
@@ -22,9 +22,9 @@
     "directory": "packages/query"
   },
   "devDependencies": {
-    "@codeleap/config": "7.0.0",
-    "@codeleap/types": "7.0.0",
-    "@codeleap/utils": "7.0.0",
+    "@codeleap/config": "7.0.1",
+    "@codeleap/types": "7.0.1",
+    "@codeleap/utils": "7.0.1",
     "ts-node-dev": "1.1.8"
   },
   "scripts": {
@@ -32,7 +32,7 @@
     "typecheck": "bun tsc --noEmit -p ./tsconfig.json"
   },
   "peerDependencies": {
-    "@codeleap/types": "7.0.0",
+    "@codeleap/types": "7.0.1",
     "typescript": "6.0.3",
     "@tanstack/react-query": "5.100.9"
   },