awesome-key-factory 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Bhaskar Sharma
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,130 @@
+# awesome-key-factory
+
+A type-safe key factory for managing react-query keys with full TypeScript support.
+
+## 📚 Documentation
+
+- **[Documentation Site](https://bhaskar20.github.io/awesome-key-factory/)** - Beautiful, interactive documentation built with VitePress (recommended)
+- **[Full Documentation](./DOCUMENTATION.md)** - Complete guide with all features and examples
+
+## Installation
+
+```bash
+yarn add awesome-key-factory
+# or
+npm install awesome-key-factory
+```
+
+## Usage
+
+### Basic Example
+
+```typescript
+import { createKeyFactory } from 'awesome-key-factory';
+
+const keys = createKeyFactory('baseKey', {
+  a: (params: {}) => ['key1', 'key2'],
+  b: {
+    c: ['key3', 'key4'],
+  },
+});
+
+// Access any level
+keys.a({}) // => ['baseKey', 'a', 'key1', 'key2']
+keys.b.c() // => ['baseKey', 'b', 'c', 'key3', 'key4']
+keys.b() // => ['baseKey', 'b'] (any level can be called as a function)
+```
+
+### With Parameters
+
+```typescript
+const queryKeys = createKeyFactory('app', {
+  users: {
+    all: () => [],
+    detail: (params: { id: string }) => [params.id],
+    posts: (params: { userId: string }) => [params.userId, 'posts'],
+  },
+  posts: {
+    all: () => [],
+    detail: (params: { id: string }) => [params.id],
+  },
+});
+
+// Usage in react-query
+useQuery({
+  queryKey: queryKeys.users.detail({ id: '123' }),
+  queryFn: () => fetchUser('123'),
+});
+
+useQuery({
+  queryKey: queryKeys.users.posts({ userId: '456' }),
+  queryFn: () => fetchUserPosts('456'),
+});
+```
+
+### Array Shorthand
+
+You can use arrays as a shorthand for functions that return static keys:
+
+```typescript
+const keys = createKeyFactory('shop', {
+  products: {
+    list: ['all'], // equivalent to () => ['all']
+    byId: (params: { id: string }) => [params.id],
+  },
+});
+
+keys.products.list() // => ['shop', 'products', 'list', 'all']
+```
+
+### Deep Nesting
+
+```typescript
+const keys = createKeyFactory('api', {
+  v1: {
+    users: {
+      posts: {
+        comments: (params: { postId: string }) => [params.postId],
+      },
+    },
+  },
+});
+
+keys.v1.users.posts.comments({ postId: '123' })
+// => ['api', 'v1', 'users', 'posts', 'comments', '123']
+
+keys.v1.users.posts() // => ['api', 'v1', 'users', 'posts']
+keys.v1.users() // => ['api', 'v1', 'users']
+keys.v1() // => ['api', 'v1']
+```
+
+## Features
+
+- ✅ **Fully TypeScript typed** - Get autocomplete and type safety for all your keys
+- ✅ **Nested key access** - Access nested keys through the full path (`keys.b.c`)
+- ✅ **Function parameters** - Pass typed parameters to your key functions
+- ✅ **Array shorthand** - Use arrays for static key lists
+- ✅ **Any level access** - Call any level in the hierarchy as a function to get its path
+
+## API
+
+### `createKeyFactory<BaseKey, Schema>(baseKey, schema)`
+
+Creates a type-safe key factory.
+
+**Parameters:**
+- `baseKey` (string): The base key that will be prepended to all generated keys
+- `schema` (object): An object defining the key structure with nested objects and functions
+
+**Returns:** A factory object where each level can be accessed as a function
+
+## Documentation
+
+For complete documentation, examples, and best practices, see:
+
+- **[Documentation](https://bhaskar20.github.io/awesome-key-factory/)** - Beautiful, modern documentation site with search, dark mode, and more
+- **[DOCUMENTATION.md](./DOCUMENTATION.md)** - Comprehensive markdown documentation
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Type helper to check if a function has no parameters
+ */
+type HasNoParams<T> = T extends () => any ? true : false;
+/**
+ * Type helper to extract the parameter type from a function
+ */
+type ParamsOf<T> = T extends (params: infer P) => any ? P : T extends () => any ? Record<string, never> : never;
+/**
+ * Type helper to create function signature with optional params when Record<string, never>
+ * Functions with no parameters can be called with 0 args or with an empty object
+ */
+type FunctionWithParams<P, R, T> = HasNoParams<T> extends true ? (() => R) & ((params?: Record<string, never>) => R) : P extends Record<string, never> ? (params?: P) => R : (params: P) => R;
+/**
+ * Type helper to extract the return type from a function
+ */
+type ReturnOf<T> = T extends (...args: any[]) => infer R ? R : never;
+/**
+ * Type helper to get the key array type from a function or array
+ */
+type KeyArray<T> = T extends (...args: any[]) => infer R ? R extends readonly (infer K)[] ? K[] : never : T extends readonly (infer K)[] ? K[] : never;
+/**
+ * Check if a type is an array
+ */
+type IsArray<T> = T extends readonly (infer _)[] ? true : false;
+/**
+ * Get the function type for a specific key in the schema
+ */
+type GetKeyFunction<T, K extends string, BaseKey extends string, Path extends readonly string[] = []> = K extends keyof T ? T[K] extends (...args: any[]) => any ? FunctionWithParams<ParamsOf<T[K]>, [
+    ...Path,
+    BaseKey,
+    K,
+    ...KeyArray<ReturnOf<T[K]>>
+], T[K]> : IsArray<T[K]> extends true ? (params?: Record<string, never>) => [...Path, BaseKey, K, ...KeyArray<T[K]>] : T[K] extends Record<string, any> ? KeyFactory<T[K], BaseKey, [...Path, BaseKey, K]> & {
+    (): [...Path, BaseKey, K];
+} : never : never;
+/**
+ * Union of all string keys in a type
+ */
+type StringKeys<T> = Extract<keyof T, string>;
+/**
+ * Union of all function types for bracket notation access
+ */
+type BracketAccess<T, BaseKey extends string, Path extends readonly string[] = []> = {
+    [K in StringKeys<T>]: GetKeyFunction<T, K, BaseKey, Path>;
+}[StringKeys<T>];
+/**
+ * Recursive type to transform the input schema into the output factory type
+ */
+type KeyFactory<T, BaseKey extends string, Path extends readonly string[] = []> = {
+    [K in keyof T]: T[K] extends (...args: any[]) => any ? FunctionWithParams<ParamsOf<T[K]>, [
+        ...Path,
+        BaseKey,
+        K & string,
+        ...KeyArray<ReturnOf<T[K]>>
+    ], T[K]> : IsArray<T[K]> extends true ? (params?: Record<string, never>) => [...Path, BaseKey, K & string, ...KeyArray<T[K]>] : T[K] extends Record<string, any> ? KeyFactory<T[K], BaseKey, [...Path, BaseKey, K & string]> & {
+        (): [...Path, BaseKey, K & string];
+    } : never;
+} & {
+    [K in StringKeys<T>]: GetKeyFunction<T, K, BaseKey, Path>;
+} & {
+    [key: string]: BracketAccess<T, BaseKey, Path> | any;
+};
+/**
+ * Creates a type-safe key factory for react-query keys
+ *
+ * @param baseKey - The base key that will be prepended to all generated keys
+ * @param schema - An object defining the key structure with nested objects and functions
+ * @returns A factory object where each level can be accessed as a function
+ *
+ * @example
+ * ```typescript
+ * const keys = createKeyFactory("baseKey", {
+ *   a: (params: {}) => ["key1", "key2"],
+ *   b: {
+ *     c: ["key3", "key4"]
+ *   }
+ * });
+ *
+ * keys.a({}) // => ["baseKey", "a", "key1", "key2"]
+ * keys.b.c({}) // => ["baseKey", "b", "c", "key3", "key4"]
+ * keys.b() // => ["baseKey", "b"]
+ * ```
+ */
+export declare function createKeyFactory<BaseKey extends string, Schema extends Record<string, any>>(baseKey: BaseKey, schema: Schema): KeyFactory<Schema, BaseKey>;
+export {};

package/dist/index.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createKeyFactory = createKeyFactory;
+/**
+ * Creates a type-safe key factory for react-query keys
+ *
+ * @param baseKey - The base key that will be prepended to all generated keys
+ * @param schema - An object defining the key structure with nested objects and functions
+ * @returns A factory object where each level can be accessed as a function
+ *
+ * @example
+ * ```typescript
+ * const keys = createKeyFactory("baseKey", {
+ *   a: (params: {}) => ["key1", "key2"],
+ *   b: {
+ *     c: ["key3", "key4"]
+ *   }
+ * });
+ *
+ * keys.a({}) // => ["baseKey", "a", "key1", "key2"]
+ * keys.b.c({}) // => ["baseKey", "b", "c", "key3", "key4"]
+ * keys.b() // => ["baseKey", "b"]
+ * ```
+ */
+function createKeyFactory(baseKey, schema) {
+    function createFactory(currentSchema, currentBaseKey, currentPath = []) {
+        const factory = {};
+        // Add a function to get the current path
+        factory.__call = () => [...currentPath, currentBaseKey];
+        for (const key in currentSchema) {
+            const value = currentSchema[key];
+            if (typeof value === "function") {
+                // It's a function that returns keys
+                factory[key] = (params) => {
+                    const keys = value(params);
+                    return [...currentPath, currentBaseKey, key, ...keys];
+                };
+            }
+            else if (typeof value === "object" &&
+                value !== null &&
+                !Array.isArray(value)) {
+                // It's a nested object
+                const nestedFactory = createFactory(value, key, [
+                    ...currentPath,
+                    currentBaseKey,
+                ]);
+                // Also add a direct accessor that returns the path to this level
+                factory[key] = Object.assign(() => [...currentPath, currentBaseKey, key], nestedFactory);
+            }
+            else if (Array.isArray(value)) {
+                // It's an array of keys (shorthand for a function that returns the array)
+                factory[key] = (_params) => [
+                    ...currentPath,
+                    currentBaseKey,
+                    key,
+                    ...value,
+                ];
+            }
+        }
+        // Make the factory callable
+        return new Proxy(factory, {
+            get(target, prop) {
+                if (prop === "__call") {
+                    return target.__call;
+                }
+                if (prop in target) {
+                    return target[prop];
+                }
+                throw new Error(`Key "${String(prop)}" does not exist at this level. Access it through the proper hierarchy.`);
+            },
+            apply(target, _thisArg, _argumentsList) {
+                return target.__call();
+            },
+        });
+    }
+    return createFactory(schema, baseKey);
+}

package/dist/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.test.js

@@ -0,0 +1,420 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("./index");
+describe("createKeyFactory", () => {
+    describe("basic functionality", () => {
+        it("should create keys with base key and function", () => {
+            const keys = (0, index_1.createKeyFactory)("baseKey", {
+                a: (_params) => ["key1", "key2"],
+            });
+            expect(keys.a({})).toEqual(["baseKey", "a", "key1", "key2"]);
+        });
+        it("should use params to create keys dynamically", () => {
+            const keys = (0, index_1.createKeyFactory)("baseKey", {
+                a: (params) => [params.id, params.status, "key1"],
+            });
+            expect(keys.a({ id: "123", status: "active" })).toEqual([
+                "baseKey",
+                "a",
+                "123",
+                "active",
+                "key1",
+            ]);
+        });
+        it("should create keys with nested objects", () => {
+            const keys = (0, index_1.createKeyFactory)("baseKey", {
+                b: {
+                    c: ["key3", "key4"],
+                },
+            });
+            expect(keys.b.c()).toEqual(["baseKey", "b", "c", "key3", "key4"]);
+        });
+        it("should allow accessing intermediate levels", () => {
+            const keys = (0, index_1.createKeyFactory)("baseKey", {
+                b: {
+                    c: ["key3", "key4"],
+                },
+            });
+            expect(keys.b()).toEqual(["baseKey", "b"]);
+        });
+        it("should handle the example from the requirements", () => {
+            const keys = (0, index_1.createKeyFactory)("baseKey", {
+                a: () => ["key1", "key2"],
+                b: {
+                    c: () => ["key3", "key4"],
+                },
+            });
+            expect(keys.a({})).toEqual(["baseKey", "a", "key1", "key2"]);
+            expect(keys.b.c()).toEqual(["baseKey", "b", "c", "key3", "key4"]);
+            expect(() => keys.c()).toThrow();
+            expect(keys.b()).toEqual(["baseKey", "b"]);
+        });
+    });
+    describe("function parameters", () => {
+        it("should pass parameters to key functions", () => {
+            const keys = (0, index_1.createKeyFactory)("users", {
+                byId: (params) => [params.id, params.type],
+            });
+            expect(keys.byId({ id: "123", type: "admin" })).toEqual([
+                "users",
+                "byId",
+                "123",
+                "admin",
+            ]);
+        });
+        it("should handle empty parameters", () => {
+            const keys = (0, index_1.createKeyFactory)("posts", {
+                all: (_params) => [],
+            });
+            expect(keys.all({})).toEqual(["posts", "all"]);
+        });
+        it("should handle multiple parameters", () => {
+            const keys = (0, index_1.createKeyFactory)("users", {
+                posts: {
+                    byId: (params) => [params.userId, params.postId],
+                },
+            });
+            expect(keys.posts.byId({ userId: "1", postId: "2" })).toEqual([
+                "users",
+                "posts",
+                "byId",
+                "1",
+                "2",
+            ]);
+        });
+    });
+    describe("nested structures", () => {
+        it("should handle deeply nested objects", () => {
+            const keys = (0, index_1.createKeyFactory)("app", {
+                users: {
+                    posts: {
+                        comments: ["all"],
+                    },
+                },
+            });
+            expect(keys.users.posts.comments()).toEqual([
+                "app",
+                "users",
+                "posts",
+                "comments",
+                "all",
+            ]);
+            expect(keys.users.posts()).toEqual(["app", "users", "posts"]);
+            expect(keys.users()).toEqual(["app", "users"]);
+        });
+        it("should handle multiple nested levels with functions", () => {
+            const keys = (0, index_1.createKeyFactory)("api", {
+                v1: {
+                    users: (params) => [params.id],
+                    posts: {
+                        list: (params) => [params.page.toString()],
+                        detail: (params) => [params.id],
+                    },
+                },
+            });
+            expect(keys.v1.users({ id: "123" })).toEqual([
+                "api",
+                "v1",
+                "users",
+                "123",
+            ]);
+            expect(keys.v1.posts.list({ page: 1 })).toEqual([
+                "api",
+                "v1",
+                "posts",
+                "list",
+                "1",
+            ]);
+            expect(keys.v1.posts.detail({ id: "456" })).toEqual([
+                "api",
+                "v1",
+                "posts",
+                "detail",
+                "456",
+            ]);
+            expect(keys.v1.posts()).toEqual(["api", "v1", "posts"]);
+            expect(keys.v1()).toEqual(["api", "v1"]);
+        });
+    });
+    describe("array shorthand", () => {
+        it("should handle array shorthand syntax", () => {
+            const keys = (0, index_1.createKeyFactory)("base", {
+                items: ["list"],
+            });
+            expect(keys.items()).toEqual(["base", "items", "list"]);
+        });
+        it("should handle multiple items in array", () => {
+            const keys = (0, index_1.createKeyFactory)("base", {
+                items: ["list", "all"],
+            });
+            expect(keys.items()).toEqual(["base", "items", "list", "all"]);
+        });
+        it("should handle empty arrays", () => {
+            const keys = (0, index_1.createKeyFactory)("base", {
+                items: [],
+            });
+            expect(keys.items()).toEqual(["base", "items"]);
+        });
+        it("should handle array shorthand in nested structures", () => {
+            const keys = (0, index_1.createKeyFactory)("app", {
+                users: {
+                    list: ["all"],
+                },
+            });
+            expect(keys.users.list()).toEqual(["app", "users", "list", "all"]);
+        });
+        it("should handle array shorthand with numeric string values", () => {
+            const keys = (0, index_1.createKeyFactory)("base", {
+                items: ["1", "2", "3"],
+            });
+            expect(keys.items()).toEqual(["base", "items", "1", "2", "3"]);
+        });
+        it("should handle array shorthand in deeply nested structures", () => {
+            const keys = (0, index_1.createKeyFactory)("api", {
+                v1: {
+                    users: {
+                        posts: {
+                            comments: ["all"],
+                        },
+                    },
+                },
+            });
+            expect(keys.v1.users.posts.comments()).toEqual([
+                "api",
+                "v1",
+                "users",
+                "posts",
+                "comments",
+                "all",
+            ]);
+            expect(keys.v1.users.posts()).toEqual(["api", "v1", "users", "posts"]);
+            expect(keys.v1.users()).toEqual(["api", "v1", "users"]);
+            expect(keys.v1()).toEqual(["api", "v1"]);
+        });
+        it("should handle array shorthand with special characters in array values", () => {
+            const keys = (0, index_1.createKeyFactory)("base", {
+                items: ["key-1", "key_2", "key.3"],
+            });
+            expect(keys.items()).toEqual(["base", "items", "key-1", "key_2", "key.3"]);
+        });
+        it("should handle multiple array shorthand keys at the same level", () => {
+            const keys = (0, index_1.createKeyFactory)("base", {
+                a: ["1"],
+                b: ["2"],
+                c: ["3"],
+            });
+            expect(keys.a()).toEqual(["base", "a", "1"]);
+            expect(keys.b()).toEqual(["base", "b", "2"]);
+            expect(keys.c()).toEqual(["base", "c", "3"]);
+        });
+        it("should handle array shorthand with bracket notation access", () => {
+            const keys = (0, index_1.createKeyFactory)("base", {
+                "key-1": ["value1"],
+                "key_2": ["value2"],
+            });
+            expect(keys["key-1"]()).toEqual(["base", "key-1", "value1"]);
+            expect(keys["key_2"]()).toEqual(["base", "key_2", "value2"]);
+        });
+        it("should handle array shorthand with long arrays", () => {
+            const keys = (0, index_1.createKeyFactory)("base", {
+                items: ["a", "b", "c", "d", "e", "f", "g"],
+            });
+            expect(keys.items()).toEqual([
+                "base",
+                "items",
+                "a",
+                "b",
+                "c",
+                "d",
+                "e",
+                "f",
+                "g",
+            ]);
+        });
+        it("should handle array shorthand with single character values", () => {
+            const keys = (0, index_1.createKeyFactory)("base", {
+                items: ["x", "y", "z"],
+            });
+            expect(keys.items()).toEqual(["base", "items", "x", "y", "z"]);
+        });
+        it("should handle array shorthand with empty string values", () => {
+            const keys = (0, index_1.createKeyFactory)("base", {
+                items: ["", "value"],
+            });
+            expect(keys.items()).toEqual(["base", "items", "", "value"]);
+        });
+        it("should handle array shorthand at root level with nested objects", () => {
+            const keys = (0, index_1.createKeyFactory)("app", {
+                root: ["level"],
+                nested: {
+                    deep: ["value"],
+                },
+            });
+            expect(keys.root()).toEqual(["app", "root", "level"]);
+            expect(keys.nested.deep()).toEqual(["app", "nested", "deep", "value"]);
+            expect(keys.nested()).toEqual(["app", "nested"]);
+        });
+        it("should handle array shorthand with params parameter (should be optional)", () => {
+            const keys = (0, index_1.createKeyFactory)("base", {
+                items: ["list"],
+            });
+            // Array shorthand should accept optional params
+            expect(keys.items()).toEqual(["base", "items", "list"]);
+            expect(keys.items({})).toEqual(["base", "items", "list"]);
+        });
+        it("should handle array shorthand in multiple nested levels", () => {
+            const keys = (0, index_1.createKeyFactory)("shop", {
+                products: {
+                    list: ["all"],
+                    featured: ["featured"],
+                    categories: {
+                        electronics: ["items"],
+                    },
+                },
+                cart: ["items"],
+            });
+            expect(keys.products.list()).toEqual(["shop", "products", "list", "all"]);
+            expect(keys.products.featured()).toEqual([
+                "shop",
+                "products",
+                "featured",
+                "featured",
+            ]);
+            expect(keys.products.categories.electronics()).toEqual([
+                "shop",
+                "products",
+                "categories",
+                "electronics",
+                "items",
+            ]);
+            expect(keys.cart()).toEqual(["shop", "cart", "items"]);
+            expect(keys.products.categories()).toEqual([
+                "shop",
+                "products",
+                "categories",
+            ]);
+            expect(keys.products()).toEqual(["shop", "products"]);
+        });
+    });
+    describe("complex real-world scenarios", () => {
+        it("should work with a typical react-query setup", () => {
+            const queryKeys = (0, index_1.createKeyFactory)("app", {
+                users: {
+                    all: () => [],
+                    lists: () => ["list"],
+                    detail: (params) => [params.id],
+                    posts: (params) => [params.userId, "posts"],
+                },
+                posts: {
+                    all: () => [],
+                    detail: (params) => [params.id],
+                    comments: (params) => [params.postId, "comments"],
+                },
+            });
+            expect(queryKeys.users.all({})).toEqual(["app", "users", "all"]);
+            expect(queryKeys.users.lists({})).toEqual([
+                "app",
+                "users",
+                "lists",
+                "list",
+            ]);
+            expect(queryKeys.users.detail({ id: "123" })).toEqual([
+                "app",
+                "users",
+                "detail",
+                "123",
+            ]);
+            expect(queryKeys.users.posts({ userId: "456" })).toEqual([
+                "app",
+                "users",
+                "posts",
+                "456",
+                "posts",
+            ]);
+            expect(queryKeys.users()).toEqual(["app", "users"]);
+            expect(queryKeys.posts.all({})).toEqual(["app", "posts", "all"]);
+            expect(queryKeys.posts.detail({ id: "789" })).toEqual([
+                "app",
+                "posts",
+                "detail",
+                "789",
+            ]);
+            expect(queryKeys.posts.comments({ postId: "101" })).toEqual([
+                "app",
+                "posts",
+                "comments",
+                "101",
+                "comments",
+            ]);
+            expect(queryKeys.posts()).toEqual(["app", "posts"]);
+        });
+        it("should handle mixed function and array syntax", () => {
+            const keys = (0, index_1.createKeyFactory)("shop", {
+                products: {
+                    list: ["all"],
+                    byCategory: (params) => [params.category],
+                    byId: (params) => [params.id],
+                },
+                cart: ["items"],
+            });
+            expect(keys.products.list()).toEqual(["shop", "products", "list", "all"]);
+            expect(keys.products.byCategory({ category: "electronics" })).toEqual([
+                "shop",
+                "products",
+                "byCategory",
+                "electronics",
+            ]);
+            expect(keys.products.byId({ id: "123" })).toEqual([
+                "shop",
+                "products",
+                "byId",
+                "123",
+            ]);
+            expect(keys.products()).toEqual(["shop", "products"]);
+            expect(keys.cart()).toEqual(["shop", "cart", "items"]);
+        });
+    });
+    describe("edge cases", () => {
+        it("should handle single level with no nesting", () => {
+            const keys = (0, index_1.createKeyFactory)("simple", {
+                item: () => ["single"],
+            });
+            expect(keys.item({})).toEqual(["simple", "item", "single"]);
+        });
+        it("should handle multiple keys at the same level", () => {
+            const keys = (0, index_1.createKeyFactory)("base", {
+                a: () => ["1"],
+                b: () => ["2"],
+                c: () => ["3"],
+            });
+            expect(keys.a({})).toEqual(["base", "a", "1"]);
+            expect(keys.b({})).toEqual(["base", "b", "2"]);
+            expect(keys.c({})).toEqual(["base", "c", "3"]);
+        });
+        it("should handle numeric and special characters in keys", () => {
+            const keys = (0, index_1.createKeyFactory)("base", {
+                "key-1": () => ["value"],
+                key_2: () => ["value2"],
+            });
+            expect(keys["key-1"]({})).toEqual(["base", "key-1", "value"]);
+            expect(keys["key_2"]({})).toEqual(["base", "key_2", "value2"]);
+        });
+        it("should support bracket notation with proper types for function parameters", () => {
+            const keys = (0, index_1.createKeyFactory)("base", {
+                "key-with-params": (params) => [params.id, params.type],
+                "another-key": () => ["static"],
+            });
+            // Bracket notation should work with proper types
+            const keyWithParams = keys["key-with-params"];
+            const anotherKey = keys["another-key"];
+            // TypeScript should know the parameter types
+            expect(keyWithParams({ id: "123", type: "admin" })).toEqual([
+                "base",
+                "key-with-params",
+                "123",
+                "admin",
+            ]);
+            expect(anotherKey({})).toEqual(["base", "another-key", "static"]);
+        });
+    });
+});

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "awesome-key-factory",
+  "version": "1.0.0",
+  "description": "A type-safe key factory for managing react-query keys",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "test": "jest",
+    "prepublishOnly": "yarn build && yarn test",
+    "prepack": "yarn build",
+    "publish": "npm publish",
+    "publish:dry-run": "npm publish --dry-run",
+    "publish:public": "npm publish --access public",
+    "publish:beta": "npm publish --tag beta",
+    "publish:next": "npm publish --tag next",
+    "version:patch": "yarn version --patch --no-git-tag-version",
+    "version:minor": "yarn version --minor --no-git-tag-version",
+    "version:major": "yarn version --major --no-git-tag-version",
+    "release:patch": "yarn version:patch && yarn publish:public && git push && git push --tags",
+    "release:minor": "yarn version:minor && yarn publish:public && git push && git push --tags",
+    "release:major": "yarn version:major && yarn publish:public && git push && git push --tags",
+    "lint": "eslint . --ext .ts",
+    "lint:fix": "eslint . --ext .ts --fix",
+    "type-check": "tsc --noEmit",
+    "check": "yarn type-check && yarn lint",
+    "docs:dev": "cd vitepress-docs && yarn dev",
+    "docs:build": "cd vitepress-docs && yarn build",
+    "docs:preview": "cd vitepress-docs && yarn preview"
+  },
+  "keywords": [
+    "react-query",
+    "query-keys",
+    "typescript",
+    "type-safe"
+  ],
+  "author": "",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/bhaskar20/awesome-key-factory.git"
+  },
+  "homepage": "https://bhaskar20.github.io/awesome-key-factory/",
+  "bugs": {
+    "url": "https://github.com/bhaskar20/awesome-key-factory/issues"
+  },
+  "devDependencies": {
+    "@astrojs/starlight": "^0.37.3",
+    "@types/jest": "^29.5.0",
+    "@types/node": "^20.0.0",
+    "@typescript-eslint/eslint-plugin": "^8.53.0",
+    "@typescript-eslint/parser": "^8.53.0",
+    "astro": "^5.16.10",
+    "eslint": "^9.39.2",
+    "eslint-config-prettier": "^10.1.8",
+    "jest": "^29.5.0",
+    "ts-jest": "^29.1.0",
+    "typescript": "^5.0.0",
+    "typescript-eslint": "^8.53.0"
+  },
+  "peerDependencies": {
+    "typescript": "^4.0.0 || ^5.0.0"
+  },
+  "files": [
+    "dist"
+  ],
+  "packageManager": "yarn@4.12.0+sha512.f45ab632439a67f8bc759bf32ead036a1f413287b9042726b7cc4818b7b49e14e9423ba49b18f9e06ea4941c1ad062385b1d8760a8d5091a1a31e5f6219afca8"
+}