@flink-app/flink 0.14.3 → 2.0.0-alpha.100

package/dist/cli/dev.js

@@ -0,0 +1,279 @@
+#!/usr/bin/env node
+"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());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var chokidar_1 = __importDefault(require("chokidar"));
+var child_process_1 = require("child_process");
+var path_1 = require("path");
+var fs_1 = require("fs");
+var cli_utils_1 = require("./cli-utils");
+var FlinkLogFactory_1 = require("../src/FlinkLogFactory");
+var loadFlinkConfig_1 = require("../src/utils/loadFlinkConfig");
+var loadEnvFiles_1 = require("./loadEnvFiles");
+// Load config BEFORE creating logger
+var flinkConfig = (0, loadFlinkConfig_1.loadFlinkConfig)();
+FlinkLogFactory_1.FlinkLogFactory.configure(flinkConfig === null || flinkConfig === void 0 ? void 0 : flinkConfig.logging);
+var logger = FlinkLogFactory_1.FlinkLogFactory.createLogger("flink.dev");
+module.exports = function dev(args) {
+    return __awaiter(this, void 0, void 0, function () {
+        var parsed, initLogger, _a, loaded, injected, dir, entry, typecheck, noTypecheck, serverProcess, tscProcess, isRebuilding, pendingRebuild, watcher;
+        var _this = this;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    parsed = (0, cli_utils_1.parseArgs)(args);
+                    // Load .env files before anything else so all env vars are available at startup.
+                    // NODE_ENV defaults to "development" when not explicitly set.
+                    if (!process.env.NODE_ENV) {
+                        process.env.NODE_ENV = "development";
+                    }
+                    initLogger = FlinkLogFactory_1.FlinkLogFactory.createLogger("flink.init");
+                    _a = (0, loadEnvFiles_1.loadEnvFiles)(parsed.dir, "development"), loaded = _a.loaded, injected = _a.injected;
+                    if (loaded.length > 0) {
+                        initLogger.info("Loaded env files: ".concat(loaded.join(", "), " (").concat(injected, " vars injected)"));
+                    }
+                    if ((0, cli_utils_1.hasFlag)(parsed, "help")) {
+                        (0, cli_utils_1.printHelp)({
+                            description: "Starts development mode with watch and auto-reload.\n      Fast rebuilds with swc (skips type checking by default).\n      Runs background tsc --watch for async type error reporting.",
+                            usage: "$ flink dev <dir>",
+                            options: [
+                                { name: "typecheck", description: "Run type checking on every rebuild (slower, disables background tsc)" },
+                                { name: "no-typecheck", description: "Disable background type checking entirely" },
+                                { name: "entry", description: 'Entry script for app, default "/src/index.ts"' },
+                                { name: "help", description: "Displays this message" },
+                            ],
+                        });
+                        return [2 /*return*/];
+                    }
+                    dir = parsed.dir;
+                    entry = (0, cli_utils_1.normalizeEntry)((0, cli_utils_1.getOption)(parsed, "entry", "/src/index.ts"));
+                    typecheck = (0, cli_utils_1.hasFlag)(parsed, "typecheck");
+                    noTypecheck = (0, cli_utils_1.hasFlag)(parsed, "no-typecheck");
+                    console.log("🚀 Flink dev mode starting...\n");
+                    // Initial build (skip type checking for speed unless --typecheck flag)
+                    console.log("\uD83D\uDCE6 Initial build ".concat(typecheck ? "(with type checking)" : "(fast mode, skipping type check)", "..."));
+                    return [4 /*yield*/, (0, cli_utils_1.compile)({ dir: dir, entry: entry, typeCheck: typecheck })];
+                case 1:
+                    _b.sent();
+                    serverProcess = null;
+                    tscProcess = null;
+                    isRebuilding = false;
+                    pendingRebuild = false;
+                    // Start server
+                    serverProcess = startServer(dir);
+                    // Start background tsc --watch for async type checking (unless --typecheck or --no-typecheck)
+                    if (!typecheck && !noTypecheck) {
+                        tscProcess = startTscWatch(dir);
+                    }
+                    watcher = chokidar_1.default.watch(["".concat(dir, "/src/**/*.ts"), "".concat(dir, "/src/**/*.json")], {
+                        ignored: ["**/.flink/**", "**/dist/**", "**/node_modules/**", "**/*.spec.ts", "**/*.test.ts"],
+                        persistent: true,
+                        ignoreInitial: true,
+                    });
+                    watcher.on("change", function (path) { return __awaiter(_this, void 0, void 0, function () {
+                        var rebuildStart, rebuildTime, error_1;
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0:
+                                    if (isRebuilding) {
+                                        pendingRebuild = true;
+                                        return [2 /*return*/];
+                                    }
+                                    isRebuilding = true;
+                                    logger.info("\n\uD83D\uDCDD File changed: ".concat(path));
+                                    logger.info("🔄 Rebuilding...");
+                                    rebuildStart = Date.now();
+                                    _a.label = 1;
+                                case 1:
+                                    _a.trys.push([1, 5, , 6]);
+                                    return [4 /*yield*/, (0, cli_utils_1.compile)({ dir: dir, entry: entry, typeCheck: typecheck })];
+                                case 2:
+                                    _a.sent();
+                                    if (!serverProcess) return [3 /*break*/, 4];
+                                    return [4 /*yield*/, killAndWait(serverProcess)];
+                                case 3:
+                                    _a.sent();
+                                    serverProcess = null;
+                                    _a.label = 4;
+                                case 4:
+                                    serverProcess = startServer(dir);
+                                    rebuildTime = Date.now() - rebuildStart;
+                                    logger.info("\u2705 Rebuild complete in ".concat(rebuildTime, "ms\n"));
+                                    return [3 /*break*/, 6];
+                                case 5:
+                                    error_1 = _a.sent();
+                                    logger.error("\u274C Rebuild failed: ".concat(error_1.message));
+                                    return [3 /*break*/, 6];
+                                case 6:
+                                    isRebuilding = false;
+                                    // If another change happened during rebuild, trigger again
+                                    if (pendingRebuild) {
+                                        pendingRebuild = false;
+                                        watcher.emit("change", path);
+                                    }
+                                    return [2 /*return*/];
+                            }
+                        });
+                    }); });
+                    watcher.on("ready", function () {
+                        console.log("\n👀 Watching for changes...");
+                        if (tscProcess) {
+                            console.log("   TypeScript type checking running in background");
+                        }
+                        console.log("   Press Ctrl+C to stop\n");
+                    });
+                    // Cleanup on exit
+                    process.on("SIGINT", function () {
+                        console.log("\n\n🛑 Stopping dev mode...");
+                        if (serverProcess) {
+                            serverProcess.kill();
+                        }
+                        if (tscProcess) {
+                            tscProcess.kill();
+                        }
+                        watcher.close();
+                        process.exit(0);
+                    });
+                    return [2 /*return*/];
+            }
+        });
+    });
+};
+function killAndWait(proc) {
+    return new Promise(function (resolve) {
+        if (proc.exitCode !== null) {
+            // Already exited
+            resolve();
+            return;
+        }
+        proc.once("exit", function () { return resolve(); });
+        proc.kill();
+        // Safety timeout: if the process doesn't exit within 5s, force-kill it
+        var timeout = setTimeout(function () {
+            proc.kill("SIGKILL");
+        }, 5000);
+        proc.once("exit", function () { return clearTimeout(timeout); });
+    });
+}
+function startServer(dir) {
+    console.log("🚀 Starting server...");
+    var fork = require("child_process").fork;
+    var serverProcess = fork("".concat(dir, "/dist/.flink/start.js"), [], {
+        stdio: "inherit",
+    });
+    serverProcess.on("exit", function (code) {
+        if (code !== null && code !== 0) {
+            logger.error("\u274C Server exited with code ".concat(code));
+        }
+    });
+    return serverProcess;
+}
+function findTsc(startDir) {
+    var current = startDir;
+    while (true) {
+        var candidate = (0, path_1.join)(current, "node_modules", ".bin", "tsc");
+        if ((0, fs_1.existsSync)(candidate)) {
+            return candidate;
+        }
+        var parent = (0, path_1.dirname)(current);
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    return null;
+}
+function startTscWatch(dir) {
+    var _a, _b;
+    var absoluteDir = (0, path_1.resolve)(dir);
+    var tscPath = findTsc(absoluteDir);
+    if (!tscPath) {
+        logger.warn("Background type checking unavailable: typescript not found in node_modules");
+        var noop = (0, child_process_1.spawn)("node", ["-e", ""], { stdio: "ignore" });
+        return noop;
+    }
+    var tsBuildInfoPath = (0, path_1.join)(absoluteDir, ".flink", "tsconfig.tsbuildinfo");
+    var tsc = (0, child_process_1.spawn)(tscPath, ["--noEmit", "--watch", "--preserveWatchOutput", "--pretty", "--incremental", "--tsBuildInfoFile", tsBuildInfoPath], {
+        cwd: absoluteDir,
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    var buffer = "";
+    var processOutput = function (data) {
+        buffer += data.toString();
+        var lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        for (var _i = 0, lines_1 = lines; _i < lines_1.length; _i++) {
+            var line = lines_1[_i];
+            var trimmed = line.replace(/\x1Bc/g, "").trim();
+            if (!trimmed)
+                continue;
+            // Filter out noisy watch-mode status lines
+            if (trimmed.includes("Starting compilation") ||
+                trimmed.includes("File change detected") ||
+                trimmed.match(/^\[\d+:\d+:\d+\s+[AP]M\] Watching for file changes/)) {
+                continue;
+            }
+            if (trimmed.includes("Found 0 errors")) {
+                console.log("[tsc] \u2713 No type errors");
+            }
+            else if (trimmed.match(/Found \d+ errors?/)) {
+                // Pretty-print the error count summary
+                var match = trimmed.match(/Found (\d+) errors?/);
+                var count = match === null || match === void 0 ? void 0 : match[1];
+                console.log("[tsc] \u274C Found ".concat(count, " type error").concat(count === "1" ? "" : "s", " \u2014 see details above"));
+            }
+            else {
+                // Show everything else: error details, file paths, code context, etc.
+                console.log("[tsc] ".concat(trimmed));
+            }
+        }
+    };
+    (_a = tsc.stdout) === null || _a === void 0 ? void 0 : _a.on("data", processOutput);
+    (_b = tsc.stderr) === null || _b === void 0 ? void 0 : _b.on("data", processOutput);
+    tsc.on("error", function (err) {
+        logger.warn("Background type checking unavailable: ".concat(err.message));
+    });
+    tsc.on("exit", function (code) {
+        if (code !== null && code !== 0) {
+            logger.debug("Background tsc exited with code ".concat(code));
+        }
+    });
+    return tsc;
+}

package/dist/cli/loadEnvFiles.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Parse the contents of a .env file into a key/value map.
+ *
+ * Rules:
+ * - Empty lines and lines starting with # are skipped
+ * - "export FOO=bar" is treated the same as "FOO=bar"
+ * - Quoted values (single or double) are unquoted, and their content is used as-is
+ * - Unquoted values have inline comments stripped: FOO=bar # comment → "bar"
+ */
+export declare function parseEnvContent(content: string): Record<string, string>;
+export interface LoadEnvFilesResult {
+    /** Relative filenames that were found and loaded, in load order */
+    loaded: string[];
+    /** Number of variables injected into process.env (excludes already-set vars) */
+    injected: number;
+}
+/**
+ * Load .env files in Next.js-compatible order.
+ *
+ * Priority (highest wins):
+ *   1. process.env (already-set variables are never overridden)
+ *   2. .env.[environment].local
+ *   3. .env.local               (skipped when environment === "test")
+ *   4. .env.[environment]
+ *   5. .env
+ *
+ * @param dir     Root directory of the Flink app (where .env files live)
+ * @param environment  "development" | "production" | "test"
+ */
+export declare function loadEnvFiles(dir: string, environment: "development" | "production" | "test"): LoadEnvFilesResult;

package/dist/cli/loadEnvFiles.js

@@ -0,0 +1,113 @@
+"use strict";
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseEnvContent = parseEnvContent;
+exports.loadEnvFiles = loadEnvFiles;
+var fs_1 = require("fs");
+var path_1 = require("path");
+/**
+ * Parse the contents of a .env file into a key/value map.
+ *
+ * Rules:
+ * - Empty lines and lines starting with # are skipped
+ * - "export FOO=bar" is treated the same as "FOO=bar"
+ * - Quoted values (single or double) are unquoted, and their content is used as-is
+ * - Unquoted values have inline comments stripped: FOO=bar # comment → "bar"
+ */
+function parseEnvContent(content) {
+    var result = {};
+    for (var _i = 0, _a = content.split("\n"); _i < _a.length; _i++) {
+        var rawLine = _a[_i];
+        var line = rawLine.trim();
+        // Skip empty lines and full-line comments
+        if (!line || line.startsWith("#"))
+            continue;
+        // Strip "export " prefix
+        if (line.startsWith("export ")) {
+            line = line.slice(7).trim();
+        }
+        var eqIdx = line.indexOf("=");
+        if (eqIdx === -1)
+            continue;
+        var key = line.slice(0, eqIdx).trim();
+        if (!key)
+            continue;
+        var value = line.slice(eqIdx + 1);
+        if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+            // Quoted value — strip quotes, preserve content as-is
+            value = value.slice(1, -1);
+        }
+        else {
+            // Unquoted — strip inline comments (" # ...") and trim
+            var commentIdx = value.search(/ #/);
+            if (commentIdx !== -1) {
+                value = value.slice(0, commentIdx);
+            }
+            value = value.trim();
+        }
+        result[key] = value;
+    }
+    return result;
+}
+function readEnvFile(filepath) {
+    if (!(0, fs_1.existsSync)(filepath))
+        return null;
+    try {
+        return parseEnvContent((0, fs_1.readFileSync)(filepath, "utf-8"));
+    }
+    catch (_a) {
+        return null;
+    }
+}
+/**
+ * Load .env files in Next.js-compatible order.
+ *
+ * Priority (highest wins):
+ *   1. process.env (already-set variables are never overridden)
+ *   2. .env.[environment].local
+ *   3. .env.local               (skipped when environment === "test")
+ *   4. .env.[environment]
+ *   5. .env
+ *
+ * @param dir     Root directory of the Flink app (where .env files live)
+ * @param environment  "development" | "production" | "test"
+ */
+function loadEnvFiles(dir, environment) {
+    var absoluteDir = (0, path_1.resolve)(dir);
+    // Files listed from lowest to highest priority so that Object.assign
+    // naturally lets later files override earlier ones.
+    var candidates = __spreadArray(__spreadArray([
+        ".env",
+        ".env.".concat(environment)
+    ], (environment !== "test" ? [".env.local"] : []), true), [
+        ".env.".concat(environment, ".local"),
+    ], false);
+    var loaded = [];
+    var merged = {};
+    for (var _i = 0, candidates_1 = candidates; _i < candidates_1.length; _i++) {
+        var filename = candidates_1[_i];
+        var parsed = readEnvFile((0, path_1.join)(absoluteDir, filename));
+        if (parsed !== null) {
+            loaded.push(filename);
+            Object.assign(merged, parsed);
+        }
+    }
+    // Inject into process.env — existing values always win
+    var injected = 0;
+    for (var _a = 0, _b = Object.entries(merged); _a < _b.length; _a++) {
+        var _c = _b[_a], key = _c[0], value = _c[1];
+        if (!(key in process.env)) {
+            process.env[key] = value;
+            injected++;
+        }
+    }
+    return { loaded: loaded, injected: injected };
+}

package/dist/cli/run.js

@@ -36,65 +36,66 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-var TypeScriptCompiler_1 = __importDefault(require("../src/TypeScriptCompiler"));
+var cli_utils_1 = require("./cli-utils");
+var FlinkLogFactory_1 = require("../src/FlinkLogFactory");
+var loadFlinkConfig_1 = require("../src/utils/loadFlinkConfig");
+var loadEnvFiles_1 = require("./loadEnvFiles");
+// Load config BEFORE creating logger
+var flinkConfig = (0, loadFlinkConfig_1.loadFlinkConfig)();
+FlinkLogFactory_1.FlinkLogFactory.configure(flinkConfig === null || flinkConfig === void 0 ? void 0 : flinkConfig.logging);
 module.exports = function run(args) {
     return __awaiter(this, void 0, void 0, function () {
-        var startTime, dir, entry, extraArgs_1, forkedProcess_1, compiler, extraArgs, forkedProcess;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
+        var parsed, initLogger, _a, loaded, injected, entry;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
                 case 0:
-                    startTime = Date.now();
-                    if (args.includes("--help")) {
-                        console.log("\n    Description\n      Compiles and starts the application.\n\n    Usage\n      $ flink run <dir>\n\n    <dir> represents the directory of the Flink application.\n    If no directory is provided, the current directory will be used.\n      \n    Options      \n      --entry         Entry script for app, default \"/src/index.ts\"\n      --help          Displays this message\n      --precompiled   Will run a precompiled app, default false\n      ");
-                        process.exit(0);
+                    parsed = (0, cli_utils_1.parseArgs)(args);
+                    // Load .env files before anything else so all env vars are available at startup.
+                    // NODE_ENV defaults to "production" when not explicitly set.
+                    if (!process.env.NODE_ENV) {
+                        process.env.NODE_ENV = "production";
                     }
-                    dir = "./";
-                    if (args[0] && !args[0].startsWith("--")) {
-                        dir = args[0];
+                    initLogger = FlinkLogFactory_1.FlinkLogFactory.createLogger("flink.init");
+                    _a = (0, loadEnvFiles_1.loadEnvFiles)(parsed.dir, "production"), loaded = _a.loaded, injected = _a.injected;
+                    if (loaded.length > 0) {
+                        initLogger.info("Loaded env files: ".concat(loaded.join(", "), " (").concat(injected, " vars injected)"));
                     }
-                    entry = "/src/index.ts";
-                    if (args.includes("--entry")) {
-                        entry = args[args.indexOf("--entry") + 1];
-                        entry = entry.startsWith("/") ? entry : "/" + entry;
+                    if ((0, cli_utils_1.hasFlag)(parsed, "help")) {
+                        (0, cli_utils_1.printHelp)({
+                            description: "Compiles and starts the application.",
+                            usage: "$ flink run <dir>",
+                            options: [
+                                { name: "entry", description: 'Entry script for app, default "/src/index.ts"' },
+                                { name: "help", description: "Displays this message" },
+                                { name: "precompiled", description: "Will run a precompiled app, default false" },
+                            ],
+                        });
+                        return [2 /*return*/];
                     }
-                    if (args.includes("--precompiled")) {
-                        if (args.includes("--entry")) {
+                    entry = (0, cli_utils_1.normalizeEntry)((0, cli_utils_1.getOption)(parsed, "entry", "/src/index.ts"));
+                    if ((0, cli_utils_1.hasFlag)(parsed, "precompiled")) {
+                        if (parsed.options.has("entry")) {
                             console.warn("WARNING: --entry is ignored when using --precompiled");
                         }
-                        extraArgs_1 = args.filter(function (arg) {
-                            return arg !== "--precompiled" &&
-                                !arg.startsWith("--entry") &&
-                                arg !== args[args.indexOf("--entry") + 1];
-                        }).filter(function (arg) { return arg !== args[0] || args[0].startsWith("--"); });
-                        forkedProcess_1 = require("child_process").fork(dir + "/dist/.flink/start.js", extraArgs_1);
-                        forkedProcess_1.on("exit", function (code) {
-                            process.exit(code);
+                        (0, cli_utils_1.forkApp)({
+                            dir: parsed.dir,
+                            args: args,
+                            cliFlags: ["precompiled", "entry"],
                         });
                         return [2 /*return*/];
                     }
-                    return [4 /*yield*/, TypeScriptCompiler_1.default.clean(dir)];
+                    return [4 /*yield*/, (0, cli_utils_1.compile)({
+                            dir: parsed.dir,
+                            entry: entry,
+                            typeCheck: true,
+                        })];
                 case 1:
-                    _a.sent();
-                    compiler = new TypeScriptCompiler_1.default(dir);
-                    if (!compiler.getPreEmitDiagnostics()) {
-                        process.exit(1);
-                    }
-                    return [4 /*yield*/, Promise.all([compiler.parseRepos(), compiler.parseHandlers(), compiler.parseJobs(), compiler.generateStartScript(entry)])];
-                case 2:
-                    _a.sent();
-                    console.log("Compilation done, took ".concat(Date.now() - startTime, "ms"));
-                    compiler.emit();
-                    extraArgs = args.filter(function (arg) {
-                        return !arg.startsWith("--entry") &&
-                            arg !== args[args.indexOf("--entry") + 1];
-                    }).filter(function (arg) { return arg !== args[0] || args[0].startsWith("--"); });
-                    forkedProcess = require("child_process").fork(dir + "/dist/.flink/start.js", extraArgs);
-                    forkedProcess.on("exit", function (code) {
-                        process.exit(code);
+                    _b.sent();
+                    (0, cli_utils_1.forkApp)({
+                        dir: parsed.dir,
+                        args: args,
+                        cliFlags: ["entry"],
                     });
                     return [2 /*return*/];
             }

package/dist/src/DependencyTracker.d.ts

@@ -0,0 +1,44 @@
+export interface CacheTrackingConfig {
+    excludeNodeModules?: boolean;
+    includePatterns?: string[];
+}
+/**
+ * Tracks dependencies and computes content hashes for schema files
+ */
+export declare class DependencyTracker {
+    private projectRoot;
+    private dependencyCache;
+    private config;
+    constructor(projectRoot: string, config?: CacheTrackingConfig);
+    /**
+     * Check if a file path should be tracked in the cache
+     */
+    private shouldTrackFile;
+    /**
+     * Build dependency graph for a schema file
+     * Returns map of absolute file paths to their content hashes
+     */
+    buildDependencyGraph(schemaFile: string, resolveImports: (filePath: string) => string[]): Promise<Map<string, string>>;
+    /**
+     * Recursively collect dependencies and compute hashes
+     */
+    private collectDependencies;
+    /**
+     * Batch compute hashes for multiple files
+     * Returns map of file paths to hashes
+     */
+    batchHashFiles(filePaths: string[]): Promise<Map<string, string>>;
+    /**
+     * Check if any dependencies changed
+     * Returns list of changed file paths
+     */
+    findChangedDependencies(dependencies: Map<string, string>, cachedHashes: Record<string, string>): Promise<string[]>;
+    /**
+     * Get relative path for display purposes
+     */
+    getRelativePath(filePath: string): string;
+    /**
+     * Clear dependency cache
+     */
+    clearCache(): void;
+}