@query-key-gen/used-generator 0.0.0

package/lib/index.cjs

@@ -0,0 +1,374 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  default: () => QueryKeyUsedPlugin
+});
+module.exports = __toCommonJS(index_exports);
+var import_path4 = __toESM(require("path"), 1);
+
+// ../common/src/core/Programmer.ts
+var import_fast_glob = __toESM(require("fast-glob"), 1);
+var import_path = __toESM(require("path"), 1);
+var import_typescript = __toESM(require("typescript"), 1);
+var Programmer = class {
+  constructor(config) {
+    // getCompilerOptions = () => {
+    //     const { options: compilerOptions } = ts.parseJsonConfigFileContent(
+    //         ts.readConfigFile('tsconfig.node.json', ts.sys.readFile).config,
+    //         {
+    //             fileExists: ts.sys.fileExists,
+    //             readFile: ts.sys.readFile,
+    //             readDirectory: ts.sys.readDirectory,
+    //             useCaseSensitiveFileNames: ts.sys.useCaseSensitiveFileNames
+    //         },
+    //         path.dirname('.')
+    //     );
+    //     return compilerOptions;
+    // };
+    this.findFiles = (program) => __async(this, null, function* () {
+      const config = this.config;
+      const sourceFiles = program.getSourceFiles().filter((item) => {
+        return !item.isDeclarationFile;
+      });
+      const outputFile = import_typescript.default.createSourceFile(config.output, "", this.compilerOptions.target);
+      const projectFiles = sourceFiles.filter((item) => {
+        const relativePath = import_path.default.relative(process.cwd(), item.fileName);
+        const outputPath = import_path.default.relative(process.cwd(), config.output);
+        return !relativePath.includes(outputPath);
+      });
+      return {
+        outputFile,
+        projectFiles
+      };
+    });
+    this.config = config;
+    this.compilerOptions = {
+      target: import_typescript.default.ScriptTarget.ES2015
+    };
+  }
+  // Getter로 createProgram 정의
+  get create() {
+    return () => __async(this, null, function* () {
+      const files = yield (0, import_fast_glob.default)(this.config.path, {
+        onlyFiles: true
+      });
+      const program = import_typescript.default.createProgram({
+        rootNames: files,
+        options: this.compilerOptions
+      });
+      return {
+        program,
+        checker: program.getTypeChecker()
+      };
+    });
+  }
+};
+
+// ../common/src/core/GenericRunner.ts
+var GenericRunner = class {
+  constructor(programmer, config) {
+    this.programmer = programmer;
+    this.config = config;
+  }
+  process() {
+    return __async(this, null, function* () {
+      console.log("\u{1F527} Base process logic");
+    });
+  }
+  execute() {
+    this.process();
+  }
+};
+
+// src/core/QueryKeyUsedInfoGenerator.ts
+var import_fs2 = __toESM(require("fs"), 1);
+var import_typescript3 = __toESM(require("typescript"), 1);
+
+// src/queryFinder/QueryKeyUsedFinder.ts
+var import_typescript2 = __toESM(require("typescript"), 1);
+var QueryKeyUsedFinder;
+((QueryKeyUsedFinder2) => {
+  QueryKeyUsedFinder2.find = (sourceFiles, globalQueryKeyName) => {
+    const globalQueryKeys = sourceFiles.map((sourceFile) => {
+      return findGlobalQueryKeys(sourceFile, globalQueryKeyName);
+    });
+    const queryKeyByDeclaration = globalQueryKeys.flatMap((keys) => {
+      const usedDeclarations = keys.findNode.map((key) => {
+        const declaration = findUsedDeclaration(key.node);
+        return __spreadProps(__spreadValues({}, key), {
+          declaration,
+          sourceFile: keys.sourceFile
+        });
+      });
+      return usedDeclarations;
+    });
+    return queryKeyByDeclaration;
+  };
+  const findGlobalQueryKeys = (node, globalQueryKeyName) => {
+    const findNode = [];
+    const findText = [globalQueryKeyName];
+    const visitor = (node2) => {
+      if (import_typescript2.default.isImportDeclaration(node2)) {
+        return;
+      }
+      if (import_typescript2.default.isCallExpression(node2) || import_typescript2.default.isIdentifier(node2)) {
+        if (import_typescript2.default.isIdentifier(node2) && findText.includes(node2.getText())) {
+          const grandParent = node2.parent.parent;
+          if (import_typescript2.default.isPropertyAccessExpression(node2.parent)) {
+            const isGlobalQueryKey = findText.some(
+              (text) => grandParent.getText().includes(text)
+            );
+            findNode.push({
+              node: node2,
+              parent: isGlobalQueryKey ? grandParent : null
+            });
+          }
+        }
+      }
+      import_typescript2.default.forEachChild(node2, visitor);
+    };
+    visitor(node);
+    return { findNode, sourceFile: node };
+  };
+  const findUsedDeclaration = (node) => {
+    let parentNode = node.parent;
+    let declaration = null;
+    while (parentNode) {
+      if (import_typescript2.default.isFunctionDeclaration(parentNode)) {
+        declaration = parentNode;
+        break;
+      }
+      if (import_typescript2.default.isVariableDeclaration(parentNode) && parentNode.initializer && import_typescript2.default.isArrowFunction(parentNode.initializer)) {
+        declaration = parentNode;
+        break;
+      }
+      parentNode = parentNode.parent;
+    }
+    return declaration;
+  };
+})(QueryKeyUsedFinder || (QueryKeyUsedFinder = {}));
+
+// src/utils/index.ts
+var import_child_process = require("child_process");
+var import_fs = __toESM(require("fs"), 1);
+var import_path2 = __toESM(require("path"), 1);
+var prettify = (output) => {
+  const prettier = import_path2.default.resolve("./node_modules/.bin/prettier");
+  if (import_fs.default.existsSync(prettier)) (0, import_child_process.execSync)(`${prettier} --write --cache ${output}`);
+};
+var logger = (() => {
+  const prefix = "[QUERY-KEY-USED-GENERATOR]: ";
+  const log = () => {
+    return {
+      warn: (msg) => {
+        console.warn(`[WARN]${prefix}${msg}`);
+      },
+      error: (msg) => {
+        console.error(`[ERROR]${prefix}${msg}`);
+      },
+      info: (msg) => {
+        console.log(`[INFO]${prefix}${msg}`);
+      }
+    };
+  };
+  return log();
+})();
+
+// src/core/QueryKeyUsedInfoGenerator.ts
+var import_path3 = __toESM(require("path"), 1);
+var QueryKeyUsedInfoGenerator = class extends GenericRunner {
+  constructor() {
+    super(...arguments);
+    this.process = () => __async(this, null, function* () {
+      const { program } = yield this.programmer.create();
+      const { projectFiles } = yield this.programmer.findFiles(program);
+      const queryKeyUsedInfo = QueryKeyUsedFinder.find(
+        projectFiles,
+        this.config.globalQueryKeyName
+      );
+      const result = this.makeQueryKeyUsedInfo(queryKeyUsedInfo);
+      this.writeInfo(result);
+      prettify(this.config.output);
+    });
+    this.makeQueryKeyUsedInfo = (queryKeyUsedInfo) => {
+      const result = queryKeyUsedInfo.map((item) => {
+        var _a, _b;
+        const { declaration, sourceFile, parent } = item;
+        const declarationName = function() {
+          var _a2;
+          if (!declaration) {
+            return;
+          }
+          if (import_typescript3.default.isVariableDeclaration(declaration)) {
+            return declaration.name.getText();
+          }
+          if (import_typescript3.default.isFunctionDeclaration(declaration)) {
+            return (_a2 = declaration.name) == null ? void 0 : _a2.getText();
+          }
+          return;
+        }();
+        const fileName = import_path3.default.relative(process.cwd(), sourceFile.fileName).replace("src/", "");
+        return {
+          sourceFile: {
+            name: fileName
+          },
+          ["query-key"]: {
+            name: parent == null ? void 0 : parent.getText(),
+            pos: parent == null ? void 0 : parent.pos,
+            end: parent == null ? void 0 : parent.end
+          },
+          func: {
+            name: declarationName,
+            pos: (_a = declaration == null ? void 0 : declaration.pos) != null ? _a : 0,
+            end: (_b = declaration == null ? void 0 : declaration.end) != null ? _b : 0
+          }
+        };
+      });
+      return result;
+    };
+    this.writeType = () => {
+      return `
+          interface QueryKeyUsedInfo {
+                sourceFile: {
+                    name: string;
+                    
+                };
+                ["query-key"]: {
+                    name: string;
+                    pos: number;
+                    end: number;
+                };
+                func: {
+                    name: string;
+                    pos: number;
+                    end: number;
+                };
+            }
+        `;
+    };
+    this.writeInfo = (result) => {
+      const content = `
+            ${this.writeType()}
+            export const queryKeyUsedInfo : QueryKeyUsedInfo[] = ${JSON.stringify(result)};
+            `;
+      import_fs2.default.writeFileSync(this.config.output, content);
+    };
+  }
+};
+
+// src/types/config.ts
+var import_zod = require("zod");
+var configSchema = import_zod.z.object({
+  output: import_zod.z.string().default("src/query-key-used-info.ts"),
+  path: import_zod.z.string().default("./src/**/*.{jsx,tsx,ts}"),
+  globalQueryKeyName: import_zod.z.string().default("globalQueryKeys"),
+  ignoreFiles: import_zod.z.array(import_zod.z.string()).default([])
+});
+var defaultConfig = {
+  output: "./src/query-key-used-info.ts",
+  path: "./src/**/*.{jsx,tsx,ts}",
+  ignoreFiles: [".d.ts", "queryKeys.ts"],
+  globalQueryKeyName: "globalQueryKeys"
+};
+
+// src/index.ts
+function QueryKeyUsedPlugin(_config) {
+  var _a;
+  const config = configSchema.parse(__spreadProps(__spreadValues({}, defaultConfig), {
+    ignoreFiles: [...defaultConfig.ignoreFiles, ...(_a = _config == null ? void 0 : _config.ignoreFiles) != null ? _a : []]
+  }));
+  const rootDir = process.cwd();
+  const ignoreFiles = config.ignoreFiles;
+  const program = new Programmer(config);
+  const generator = new QueryKeyUsedInfoGenerator(program, config);
+  return {
+    name: "query-key-used-generator",
+    enforce: "pre",
+    configureServer(server) {
+      const listener = (absolutePath = "") => {
+        const filePath = import_path4.default.relative(rootDir, absolutePath);
+        const outputPath = import_path4.default.relative(rootDir, config.output);
+        if (!filePath.startsWith("src") || filePath.startsWith(outputPath)) return;
+        if (ignoreFiles.some((item) => {
+          const ignorePath = import_path4.default.relative(process.cwd(), item);
+          return filePath.includes(ignorePath);
+        })) {
+          return;
+        }
+        generator.execute();
+      };
+      server.watcher.on("add", listener);
+      server.watcher.on("change", listener);
+      server.watcher.on("unlink", listener);
+    },
+    buildStart() {
+      generator.execute();
+    }
+  };
+}

package/lib/index.d.cts

@@ -0,0 +1,24 @@
+import { Plugin } from 'vite';
+import { z } from 'zod';
+
+declare const configSchema: z.ZodObject<{
+    output: z.ZodDefault<z.ZodString>;
+    path: z.ZodDefault<z.ZodString>;
+    globalQueryKeyName: z.ZodDefault<z.ZodString>;
+    ignoreFiles: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    output: string;
+    path: string;
+    globalQueryKeyName: string;
+    ignoreFiles: string[];
+}, {
+    output?: string | undefined;
+    path?: string | undefined;
+    globalQueryKeyName?: string | undefined;
+    ignoreFiles?: string[] | undefined;
+}>;
+type ConfigOptions = z.infer<typeof configSchema>;
+
+declare function QueryKeyUsedPlugin(_config?: Omit<ConfigOptions, 'path'>): Plugin;
+
+export { QueryKeyUsedPlugin as default };

package/lib/index.d.ts

@@ -0,0 +1,24 @@
+import { Plugin } from 'vite';
+import { z } from 'zod';
+
+declare const configSchema: z.ZodObject<{
+    output: z.ZodDefault<z.ZodString>;
+    path: z.ZodDefault<z.ZodString>;
+    globalQueryKeyName: z.ZodDefault<z.ZodString>;
+    ignoreFiles: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    output: string;
+    path: string;
+    globalQueryKeyName: string;
+    ignoreFiles: string[];
+}, {
+    output?: string | undefined;
+    path?: string | undefined;
+    globalQueryKeyName?: string | undefined;
+    ignoreFiles?: string[] | undefined;
+}>;
+type ConfigOptions = z.infer<typeof configSchema>;
+
+declare function QueryKeyUsedPlugin(_config?: Omit<ConfigOptions, 'path'>): Plugin;
+
+export { QueryKeyUsedPlugin as default };

package/lib/index.js

@@ -0,0 +1,346 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/index.ts
+import path4 from "path";
+
+// ../common/src/core/Programmer.ts
+import fg from "fast-glob";
+import path from "path";
+import ts from "typescript";
+var Programmer = class {
+  constructor(config) {
+    // getCompilerOptions = () => {
+    //     const { options: compilerOptions } = ts.parseJsonConfigFileContent(
+    //         ts.readConfigFile('tsconfig.node.json', ts.sys.readFile).config,
+    //         {
+    //             fileExists: ts.sys.fileExists,
+    //             readFile: ts.sys.readFile,
+    //             readDirectory: ts.sys.readDirectory,
+    //             useCaseSensitiveFileNames: ts.sys.useCaseSensitiveFileNames
+    //         },
+    //         path.dirname('.')
+    //     );
+    //     return compilerOptions;
+    // };
+    this.findFiles = (program) => __async(this, null, function* () {
+      const config = this.config;
+      const sourceFiles = program.getSourceFiles().filter((item) => {
+        return !item.isDeclarationFile;
+      });
+      const outputFile = ts.createSourceFile(config.output, "", this.compilerOptions.target);
+      const projectFiles = sourceFiles.filter((item) => {
+        const relativePath = path.relative(process.cwd(), item.fileName);
+        const outputPath = path.relative(process.cwd(), config.output);
+        return !relativePath.includes(outputPath);
+      });
+      return {
+        outputFile,
+        projectFiles
+      };
+    });
+    this.config = config;
+    this.compilerOptions = {
+      target: ts.ScriptTarget.ES2015
+    };
+  }
+  // Getter로 createProgram 정의
+  get create() {
+    return () => __async(this, null, function* () {
+      const files = yield fg(this.config.path, {
+        onlyFiles: true
+      });
+      const program = ts.createProgram({
+        rootNames: files,
+        options: this.compilerOptions
+      });
+      return {
+        program,
+        checker: program.getTypeChecker()
+      };
+    });
+  }
+};
+
+// ../common/src/core/GenericRunner.ts
+var GenericRunner = class {
+  constructor(programmer, config) {
+    this.programmer = programmer;
+    this.config = config;
+  }
+  process() {
+    return __async(this, null, function* () {
+      console.log("\u{1F527} Base process logic");
+    });
+  }
+  execute() {
+    this.process();
+  }
+};
+
+// src/core/QueryKeyUsedInfoGenerator.ts
+import fs2 from "fs";
+import ts3 from "typescript";
+
+// src/queryFinder/QueryKeyUsedFinder.ts
+import ts2 from "typescript";
+var QueryKeyUsedFinder;
+((QueryKeyUsedFinder2) => {
+  QueryKeyUsedFinder2.find = (sourceFiles, globalQueryKeyName) => {
+    const globalQueryKeys = sourceFiles.map((sourceFile) => {
+      return findGlobalQueryKeys(sourceFile, globalQueryKeyName);
+    });
+    const queryKeyByDeclaration = globalQueryKeys.flatMap((keys) => {
+      const usedDeclarations = keys.findNode.map((key) => {
+        const declaration = findUsedDeclaration(key.node);
+        return __spreadProps(__spreadValues({}, key), {
+          declaration,
+          sourceFile: keys.sourceFile
+        });
+      });
+      return usedDeclarations;
+    });
+    return queryKeyByDeclaration;
+  };
+  const findGlobalQueryKeys = (node, globalQueryKeyName) => {
+    const findNode = [];
+    const findText = [globalQueryKeyName];
+    const visitor = (node2) => {
+      if (ts2.isImportDeclaration(node2)) {
+        return;
+      }
+      if (ts2.isCallExpression(node2) || ts2.isIdentifier(node2)) {
+        if (ts2.isIdentifier(node2) && findText.includes(node2.getText())) {
+          const grandParent = node2.parent.parent;
+          if (ts2.isPropertyAccessExpression(node2.parent)) {
+            const isGlobalQueryKey = findText.some(
+              (text) => grandParent.getText().includes(text)
+            );
+            findNode.push({
+              node: node2,
+              parent: isGlobalQueryKey ? grandParent : null
+            });
+          }
+        }
+      }
+      ts2.forEachChild(node2, visitor);
+    };
+    visitor(node);
+    return { findNode, sourceFile: node };
+  };
+  const findUsedDeclaration = (node) => {
+    let parentNode = node.parent;
+    let declaration = null;
+    while (parentNode) {
+      if (ts2.isFunctionDeclaration(parentNode)) {
+        declaration = parentNode;
+        break;
+      }
+      if (ts2.isVariableDeclaration(parentNode) && parentNode.initializer && ts2.isArrowFunction(parentNode.initializer)) {
+        declaration = parentNode;
+        break;
+      }
+      parentNode = parentNode.parent;
+    }
+    return declaration;
+  };
+})(QueryKeyUsedFinder || (QueryKeyUsedFinder = {}));
+
+// src/utils/index.ts
+import { execSync } from "child_process";
+import fs from "fs";
+import path2 from "path";
+var prettify = (output) => {
+  const prettier = path2.resolve("./node_modules/.bin/prettier");
+  if (fs.existsSync(prettier)) execSync(`${prettier} --write --cache ${output}`);
+};
+var logger = (() => {
+  const prefix = "[QUERY-KEY-USED-GENERATOR]: ";
+  const log = () => {
+    return {
+      warn: (msg) => {
+        console.warn(`[WARN]${prefix}${msg}`);
+      },
+      error: (msg) => {
+        console.error(`[ERROR]${prefix}${msg}`);
+      },
+      info: (msg) => {
+        console.log(`[INFO]${prefix}${msg}`);
+      }
+    };
+  };
+  return log();
+})();
+
+// src/core/QueryKeyUsedInfoGenerator.ts
+import path3 from "path";
+var QueryKeyUsedInfoGenerator = class extends GenericRunner {
+  constructor() {
+    super(...arguments);
+    this.process = () => __async(this, null, function* () {
+      const { program } = yield this.programmer.create();
+      const { projectFiles } = yield this.programmer.findFiles(program);
+      const queryKeyUsedInfo = QueryKeyUsedFinder.find(
+        projectFiles,
+        this.config.globalQueryKeyName
+      );
+      const result = this.makeQueryKeyUsedInfo(queryKeyUsedInfo);
+      this.writeInfo(result);
+      prettify(this.config.output);
+    });
+    this.makeQueryKeyUsedInfo = (queryKeyUsedInfo) => {
+      const result = queryKeyUsedInfo.map((item) => {
+        var _a, _b;
+        const { declaration, sourceFile, parent } = item;
+        const declarationName = function() {
+          var _a2;
+          if (!declaration) {
+            return;
+          }
+          if (ts3.isVariableDeclaration(declaration)) {
+            return declaration.name.getText();
+          }
+          if (ts3.isFunctionDeclaration(declaration)) {
+            return (_a2 = declaration.name) == null ? void 0 : _a2.getText();
+          }
+          return;
+        }();
+        const fileName = path3.relative(process.cwd(), sourceFile.fileName).replace("src/", "");
+        return {
+          sourceFile: {
+            name: fileName
+          },
+          ["query-key"]: {
+            name: parent == null ? void 0 : parent.getText(),
+            pos: parent == null ? void 0 : parent.pos,
+            end: parent == null ? void 0 : parent.end
+          },
+          func: {
+            name: declarationName,
+            pos: (_a = declaration == null ? void 0 : declaration.pos) != null ? _a : 0,
+            end: (_b = declaration == null ? void 0 : declaration.end) != null ? _b : 0
+          }
+        };
+      });
+      return result;
+    };
+    this.writeType = () => {
+      return `
+          interface QueryKeyUsedInfo {
+                sourceFile: {
+                    name: string;
+                    
+                };
+                ["query-key"]: {
+                    name: string;
+                    pos: number;
+                    end: number;
+                };
+                func: {
+                    name: string;
+                    pos: number;
+                    end: number;
+                };
+            }
+        `;
+    };
+    this.writeInfo = (result) => {
+      const content = `
+            ${this.writeType()}
+            export const queryKeyUsedInfo : QueryKeyUsedInfo[] = ${JSON.stringify(result)};
+            `;
+      fs2.writeFileSync(this.config.output, content);
+    };
+  }
+};
+
+// src/types/config.ts
+import { z } from "zod";
+var configSchema = z.object({
+  output: z.string().default("src/query-key-used-info.ts"),
+  path: z.string().default("./src/**/*.{jsx,tsx,ts}"),
+  globalQueryKeyName: z.string().default("globalQueryKeys"),
+  ignoreFiles: z.array(z.string()).default([])
+});
+var defaultConfig = {
+  output: "./src/query-key-used-info.ts",
+  path: "./src/**/*.{jsx,tsx,ts}",
+  ignoreFiles: [".d.ts", "queryKeys.ts"],
+  globalQueryKeyName: "globalQueryKeys"
+};
+
+// src/index.ts
+function QueryKeyUsedPlugin(_config) {
+  var _a;
+  const config = configSchema.parse(__spreadProps(__spreadValues({}, defaultConfig), {
+    ignoreFiles: [...defaultConfig.ignoreFiles, ...(_a = _config == null ? void 0 : _config.ignoreFiles) != null ? _a : []]
+  }));
+  const rootDir = process.cwd();
+  const ignoreFiles = config.ignoreFiles;
+  const program = new Programmer(config);
+  const generator = new QueryKeyUsedInfoGenerator(program, config);
+  return {
+    name: "query-key-used-generator",
+    enforce: "pre",
+    configureServer(server) {
+      const listener = (absolutePath = "") => {
+        const filePath = path4.relative(rootDir, absolutePath);
+        const outputPath = path4.relative(rootDir, config.output);
+        if (!filePath.startsWith("src") || filePath.startsWith(outputPath)) return;
+        if (ignoreFiles.some((item) => {
+          const ignorePath = path4.relative(process.cwd(), item);
+          return filePath.includes(ignorePath);
+        })) {
+          return;
+        }
+        generator.execute();
+      };
+      server.watcher.on("add", listener);
+      server.watcher.on("change", listener);
+      server.watcher.on("unlink", listener);
+    },
+    buildStart() {
+      generator.execute();
+    }
+  };
+}
+export {
+  QueryKeyUsedPlugin as default
+};

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@query-key-gen/used-generator",
+  "version": "0.0.0",
+  "description": "",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "require": "./lib/index.mjs",
+      "import": "./lib/index.js"
+    }
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "fast-glob": "^3.3.3",
+    "tsup": "^8.3.6",
+    "typescript": "~5.7.2",
+    "vite": "^6.1.0",
+    "zod": "^3.24.2"
+  },
+  "devDependencies": {
+    "@types/node": "^22.13.14",
+    "@query-key-gen/generator-common": "0.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "dev": "tsup --watch",
+    "build": "tsup --clean",
+    "start": "node lib/index.js",
+    "watch:build": "nodemon --watch './src' --ext '*' --exec 'pnpm build' "
+  }
+}

package/src/core/QueryKeyUsedInfoGenerator.ts

@@ -0,0 +1,101 @@
+import fs from 'fs';
+import ts from 'typescript';
+
+import { QueryKeyUsedFinder } from '../queryFinder/QueryKeyUsedFinder';
+import { prettify } from '../utils';
+import { GenericRunner } from '@query-key-gen/generator-common';
+import path from 'path';
+import { ConfigOptions } from '../types/config';
+
+/**
+ * Function used in the query key generator to find file information
+ * and write it to the query-key-used-info.ts file
+ */
+class QueryKeyUsedInfoGenerator extends GenericRunner<ConfigOptions> {
+    protected override process = async () => {
+        const { program } = await this.programmer.create();
+        const { projectFiles } = await this.programmer.findFiles(program);
+        const queryKeyUsedInfo = QueryKeyUsedFinder.find(
+            projectFiles,
+            this.config.globalQueryKeyName
+        );
+        const result = this.makeQueryKeyUsedInfo(queryKeyUsedInfo);
+        this.writeInfo(result);
+        prettify(this.config.output);
+    };
+
+    makeQueryKeyUsedInfo = (queryKeyUsedInfo: QueryKeyUsedFinder.QueryKeyUsedFinderReturnType) => {
+        const result = queryKeyUsedInfo.map(item => {
+            const { declaration, sourceFile, parent } = item;
+
+            const declarationName = (function () {
+                if (!declaration) {
+                    return;
+                }
+
+                if (ts.isVariableDeclaration(declaration)) {
+                    return declaration.name.getText();
+                }
+
+                if (ts.isFunctionDeclaration(declaration)) {
+                    return declaration.name?.getText();
+                }
+
+                return;
+            })();
+
+            const fileName = path.relative(process.cwd(), sourceFile.fileName).replace('src/', '');
+
+            return {
+                sourceFile: {
+                    name: fileName
+                },
+
+                ['query-key']: {
+                    name: parent?.getText(),
+                    pos: parent?.pos,
+                    end: parent?.end
+                },
+                func: {
+                    name: declarationName,
+                    pos: declaration?.pos ?? 0,
+                    end: declaration?.end ?? 0
+                }
+            };
+        });
+
+        return result;
+    };
+
+    writeType = () => {
+        return `
+          interface QueryKeyUsedInfo {
+                sourceFile: {
+                    name: string;
+                    
+                };
+                ["query-key"]: {
+                    name: string;
+                    pos: number;
+                    end: number;
+                };
+                func: {
+                    name: string;
+                    pos: number;
+                    end: number;
+                };
+            }
+        `;
+    };
+
+    writeInfo = (result: object) => {
+        const content = `
+            ${this.writeType()}
+            export const queryKeyUsedInfo : QueryKeyUsedInfo[] = ${JSON.stringify(result)};
+            `;
+
+        fs.writeFileSync(this.config.output, content);
+    };
+}
+
+export { QueryKeyUsedInfoGenerator };

package/src/core/index.ts

@@ -0,0 +1 @@
+export * from './QueryKeyUsedInfoGenerator';

package/src/index.ts

@@ -0,0 +1,48 @@
+import { Plugin } from 'vite';
+
+import path from 'path';
+
+import { Programmer } from '../../common/src';
+import { QueryKeyUsedInfoGenerator } from './core';
+import { ConfigOptions, configSchema, defaultConfig } from './types/config';
+
+export default function QueryKeyUsedPlugin(_config?: Omit<ConfigOptions, 'path'>): Plugin {
+    const config = configSchema.parse({
+        ...defaultConfig,
+        ignoreFiles: [...defaultConfig.ignoreFiles, ...(_config?.ignoreFiles ?? [])]
+    });
+    const rootDir = process.cwd(); // 프로젝트 루트 경로
+    const ignoreFiles = config.ignoreFiles;
+    const program = new Programmer(config);
+
+    const generator = new QueryKeyUsedInfoGenerator(program, config);
+
+    return {
+        name: 'query-key-used-generator',
+        enforce: 'pre',
+        configureServer(server) {
+            const listener = (absolutePath = '') => {
+                const filePath = path.relative(rootDir, absolutePath);
+                const outputPath = path.relative(rootDir, config.output);
+
+                if (!filePath.startsWith('src') || filePath.startsWith(outputPath)) return;
+                if (
+                    ignoreFiles.some(item => {
+                        const ignorePath = path.relative(process.cwd(), item);
+                        return filePath.includes(ignorePath);
+                    })
+                ) {
+                    return;
+                }
+
+                generator.execute();
+            };
+            server.watcher.on('add', listener);
+            server.watcher.on('change', listener);
+            server.watcher.on('unlink', listener);
+        },
+        buildStart() {
+            generator.execute();
+        }
+    };
+}

package/src/queryFinder/QueryKeyUsedFinder.ts

@@ -0,0 +1,97 @@
+import ts from 'typescript';
+
+namespace QueryKeyUsedFinder {
+    export type QueryKeyUsedFinderReturnType = ReturnType<typeof find>;
+
+    export const find = (sourceFiles: ts.SourceFile[], globalQueryKeyName: string) => {
+        // find globalQueryKeys using place
+        const globalQueryKeys = sourceFiles.map(sourceFile => {
+            return findGlobalQueryKeys(sourceFile, globalQueryKeyName);
+        });
+
+        const queryKeyByDeclaration = globalQueryKeys.flatMap(keys => {
+            const usedDeclarations = keys.findNode.map(key => {
+                // 해당 key에서 사용중인 함수를 찾는다.
+                const declaration = findUsedDeclaration(key.node);
+
+                return {
+                    ...key,
+                    declaration,
+                    sourceFile: keys.sourceFile
+                };
+            });
+
+            return usedDeclarations;
+        });
+
+        return queryKeyByDeclaration;
+    };
+
+    const findGlobalQueryKeys = (node: ts.SourceFile, globalQueryKeyName: string) => {
+        const findNode: {
+            node: ts.Node;
+            parent: ts.Node | null;
+        }[] = [];
+
+        const findText = [globalQueryKeyName];
+
+        const visitor = (node: ts.Node) => {
+            // import 구문은 무시
+            if (ts.isImportDeclaration(node)) {
+                return;
+            }
+
+            if (ts.isCallExpression(node) || ts.isIdentifier(node)) {
+                if (ts.isIdentifier(node) && findText.includes(node.getText())) {
+                    const grandParent = node.parent.parent;
+
+                    if (ts.isPropertyAccessExpression(node.parent)) {
+                        const isGlobalQueryKey = findText.some(text =>
+                            grandParent.getText().includes(text)
+                        );
+
+                        findNode.push({
+                            node,
+                            parent: isGlobalQueryKey ? grandParent : null
+                        });
+                    }
+                }
+            }
+
+            ts.forEachChild(node, visitor);
+        };
+
+        visitor(node);
+
+        return { findNode, sourceFile: node };
+    };
+
+    const findUsedDeclaration = (node: ts.Node) => {
+        let parentNode = node.parent; // 부모 노드 탐색
+
+        let declaration: ts.FunctionDeclaration | ts.VariableDeclaration | null = null;
+
+        // 사용중인 함수를 찾을 때까지 부모를 계속 탐색
+        while (parentNode) {
+            if (ts.isFunctionDeclaration(parentNode)) {
+                declaration = parentNode;
+                break;
+            }
+
+            if (
+                ts.isVariableDeclaration(parentNode) &&
+                parentNode.initializer &&
+                ts.isArrowFunction(parentNode.initializer)
+            ) {
+                declaration = parentNode;
+                break;
+            }
+
+            parentNode = parentNode.parent;
+        }
+
+        return declaration;
+    };
+}
+
+export { QueryKeyUsedFinder };

package/src/queryFinder/index.ts

@@ -0,0 +1 @@
+export * from './QueryKeyUsedFinder';

package/src/types/config.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+
+export const configSchema = z.object({
+    output: z.string().default('src/query-key-used-info.ts'),
+    path: z.string().default('./src/**/*.{jsx,tsx,ts}'),
+    globalQueryKeyName: z.string().default('globalQueryKeys'),
+    ignoreFiles: z.array(z.string()).default([])
+});
+
+export type ConfigOptions = z.infer<typeof configSchema>;
+
+export const defaultConfig: Required<ConfigOptions> = {
+    output: './src/query-key-used-info.ts',
+    path: './src/**/*.{jsx,tsx,ts}',
+    ignoreFiles: ['.d.ts', 'queryKeys.ts'],
+    globalQueryKeyName: 'globalQueryKeys'
+};

package/src/types/index.ts

@@ -0,0 +1 @@
+export * from './config';

package/src/utils/index.ts

@@ -0,0 +1,33 @@
+import { execSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+
+const toCamelCase = (str: string): string => {
+    return str.replace(/[^a-zA-Z0-9]+(.)/g, (_, letter) => letter.toUpperCase());
+};
+
+const prettify = (output: string) => {
+    const prettier = path.resolve('./node_modules/.bin/prettier');
+    if (fs.existsSync(prettier)) execSync(`${prettier} --write --cache ${output}`);
+};
+
+const logger = (() => {
+    const prefix = '[QUERY-KEY-USED-GENERATOR]: ';
+    const log = () => {
+        return {
+            warn: (msg: string) => {
+                console.warn(`[WARN]${prefix}${msg}`);
+            },
+            error: (msg: string) => {
+                console.error(`[ERROR]${prefix}${msg}`);
+            },
+            info: (msg: string) => {
+                console.log(`[INFO]${prefix}${msg}`);
+            }
+        };
+    };
+
+    return log();
+})();
+
+export { logger, prettify, toCamelCase };

package/tsconfig.json

@@ -0,0 +1,107 @@
+{
+    "compilerOptions": {
+        /* Visit https://aka.ms/tsconfig.json to read more about this file */
+
+        /* Projects */
+        // "incremental": true,                              /* Enable incremental compilation */
+        // "composite": true,                                /* Enable constraints that allow a TypeScript project to be used with project references. */
+        // "tsBuildInfoFile": "./",                          /* Specify the folder for .tsbuildinfo incremental compilation files. */
+        // "disableSourceOfProjectReferenceRedirect": true,  /* Disable preferring source files instead of declaration files when referencing composite projects */
+        // "disableSolutionSearching": true,                 /* Opt a project out of multi-project reference checking when editing. */
+        // "disableReferencedProjectLoad": true,             /* Reduce the number of projects loaded automatically by TypeScript. */
+
+        /* Language and Environment */
+        "target": "ES2015" /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */,
+        "lib": [
+            "DOM",
+            "ES2020"
+        ] /* Specify a set of bundled library declaration files that describe the target runtime environment. */,
+        // "jsx": "preserve",                                /* Specify what JSX code is generated. */
+        "experimentalDecorators": true /* Enable experimental support for TC39 stage 2 draft decorators. */,
+        "emitDecoratorMetadata": true /* Emit design-type metadata for decorated declarations in source files. */,
+
+        // "jsxFactory": "",                                 /* Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h' */
+        // "jsxFragmentFactory": "",                         /* Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'. */
+        // "jsxImportSource": "",                            /* Specify module specifier used to import the JSX factory functions when using `jsx: react-jsx*`.` */
+        // "reactNamespace": "",                             /* Specify the object invoked for `createElement`. This only applies when targeting `react` JSX emit. */
+        // "noLib": true,                                    /* Disable including any library files, including the default lib.d.ts. */
+        // "useDefineForClassFields": true,                  /* Emit ECMAScript-standard-compliant class fields. */
+
+        /* Modules */
+        "module": "commonjs" /* Specify what module code is generated. */,
+        // "rootDir": "./",                                  /* Specify the root folder within your source files. */
+        "moduleResolution": "node" /* Specify how TypeScript looks up a file from a given module specifier. */,
+        // "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
+        // "paths": {},                                      /* Specify a set of entries that re-map imports to additional lookup locations. */
+        // "rootDirs": [],                                   /* Allow multiple folders to be treated as one when resolving modules. */
+        // "typeRoots": [],                                  /* Specify multiple folders that act like `./node_modules/@types`. */
+        // "types": [],                                      /* Specify type package names to be included without being referenced in a source file. */
+        // "allowUmdGlobalAccess": true,                     /* Allow accessing UMD globals from modules. */
+        // "resolveJsonModule": true,                        /* Enable importing .json files */
+        // "noResolve": true,                                /* Disallow `import`s, `require`s or `<reference>`s from expanding the number of files TypeScript should add to a project. */
+
+        /* JavaScript Support */
+        // "allowJs": true,                                  /* Allow JavaScript files to be a part of your program. Use the `checkJS` option to get errors from these files. */
+        // "checkJs": true,                                  /* Enable error reporting in type-checked JavaScript files. */
+        // "maxNodeModuleJsDepth": 1,                        /* Specify the maximum folder depth used for checking JavaScript files from `node_modules`. Only applicable with `allowJs`. */
+
+        /* Emit */
+        "declaration": true /* Generate .d.ts files from TypeScript and JavaScript files in your project. */,
+        // "declarationMap": true,                           /* Create sourcemaps for d.ts files. */
+        // "emitDeclarationOnly": true,                      /* Only output d.ts files and not JavaScript files. */
+        "sourceMap": true /* Create source map files for emitted JavaScript files. */,
+        // "outFile": "./",                                  /* Specify a file that bundles all outputs into one JavaScript file. If `declaration` is true, also designates a file that bundles all .d.ts output. */
+        "outDir": "./lib" /* Specify an output folder for all emitted files. */,
+        // "removeComments": true,                           /* Disable emitting comments. */
+        // "noEmit": true,                                   /* Disable emitting files from a compilation. */
+        // "importHelpers": true,                            /* Allow importing helper functions from tslib once per project, instead of including them per-file. */
+        // "importsNotUsedAsValues": "remove",               /* Specify emit/checking behavior for imports that are only used for types */
+        "downlevelIteration": true /* Emit more compliant, but verbose and less performant JavaScript for iteration. */,
+        // "sourceRoot": "",                                 /* Specify the root path for debuggers to find the reference source code. */
+        // "mapRoot": "",                                    /* Specify the location where debugger should locate map files instead of generated locations. */
+        // "inlineSourceMap": true,                          /* Include sourcemap files inside the emitted JavaScript. */
+        // "inlineSources": true,                            /* Include source code in the sourcemaps inside the emitted JavaScript. */
+        // "emitBOM": true,                                  /* Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files. */
+        "newLine": "lf" /* Set the newline character for emitting files. */,
+        "stripInternal": true /* Disable emitting declarations that have `@internal` in their JSDoc comments. */,
+        // "noEmitHelpers": true,                            /* Disable generating custom helper functions like `__extends` in compiled output. */
+        // "noEmitOnError": true,                            /* Disable emitting files if any type checking errors are reported. */
+        // "preserveConstEnums": true,                       /* Disable erasing `const enum` declarations in generated code. */
+        // "declarationDir": "./",                           /* Specify the output directory for generated declaration files. */
+        // "preserveValueImports": true,                     /* Preserve unused imported values in the JavaScript output that would otherwise be removed. */
+
+        /* Interop Constraints */
+        // "isolatedModules": true,                          /* Ensure that each file can be safely transpiled without relying on other imports. */
+        // "allowSyntheticDefaultImports": true,             /* Allow 'import x from y' when a module doesn't have a default export. */
+        "esModuleInterop": true /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables `allowSyntheticDefaultImports` for type compatibility. */,
+        // "preserveSymlinks": true,                         /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */
+        "forceConsistentCasingInFileNames": true /* Ensure that casing is correct in imports. */,
+
+        /* Type Checking */
+        "strict": true /* Enable all strict type-checking options. */,
+        "noImplicitAny": true /* Enable error reporting for expressions and declarations with an implied `any` type.. */,
+        "strictNullChecks": true /* When type checking, take into account `null` and `undefined`. */,
+        "strictFunctionTypes": true /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */,
+        "strictBindCallApply": true /* Check that the arguments for `bind`, `call`, and `apply` methods match the original function. */,
+        "strictPropertyInitialization": true /* Check for class properties that are declared but not set in the constructor. */,
+        "noImplicitThis": true /* Enable error reporting when `this` is given the type `any`. */,
+        "useUnknownInCatchVariables": true /* Type catch clause variables as 'unknown' instead of 'any'. */,
+        "alwaysStrict": true /* Ensure 'use strict' is always emitted. */,
+        "noUnusedLocals": true /* Enable error reporting when a local variables aren't read. */,
+        "noUnusedParameters": true /* Raise an error when a function parameter isn't read */,
+        // "exactOptionalPropertyTypes": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */
+        "noImplicitReturns": true /* Enable error reporting for codepaths that do not explicitly return in a function. */,
+        "noFallthroughCasesInSwitch": true /* Enable error reporting for fallthrough cases in switch statements. */,
+        "noUncheckedIndexedAccess": true /* Include 'undefined' in index signature results */,
+        "noImplicitOverride": true /* Ensure overriding members in derived classes are marked with an override modifier. */,
+        // "noPropertyAccessFromIndexSignature": true,       /* Enforces using indexed accessors for keys declared using an indexed type */
+        // "allowUnusedLabels": true,                        /* Disable error reporting for unused labels. */
+        // "allowUnreachableCode": true,                     /* Disable error reporting for unreachable code. */
+
+        /* Completeness */
+        // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
+        "skipLibCheck": true /* Skip type checking all .d.ts files. */,
+        "types": ["node"]
+    },
+    "include": ["src"]
+}

package/tsup.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from 'tsup';
+
+export default defineConfig([
+    {
+        entry: ['src/index.ts'],
+        outDir: 'lib',
+        format: ['cjs', 'esm'],
+        dts: { entry: 'src/index.ts' }
+    }
+]);