@cedarjs/api-server-watch 6.0.0-canary.2828

package/README.md

@@ -0,0 +1,20 @@
+# @cedarjs/api-server-watch
+
+The `cedar dev` file watcher for the api side: rebuilds and restarts the api
+server when its source changes.
+
+Split out of `@cedarjs/api-server` so that package can stay free of
+`@cedarjs/internal` (the build/codegen toolchain) in production installs. This
+package only ever runs under `cedar dev`, where that toolchain is already
+present as part of the CLI, so it declares `@cedarjs/internal` as a regular
+dependency.
+
+## Command
+
+```shell
+cedar-api-server-watch
+```
+
+Also installed as `cedarjs-api-server-watch`. Both names are what
+`yarn cedar dev` shells out to; you shouldn't normally need to run this
+directly.

package/dist/bin.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=bin.d.ts.map

package/dist/bin.d.ts.map

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

package/dist/bin.js

@@ -0,0 +1,379 @@
+#!/usr/bin/env node
+
+// src/watch.ts
+import path3 from "node:path";
+import ansis2 from "ansis";
+import chokidar from "chokidar";
+import { config } from "dotenv-defaults";
+import {
+  buildApi,
+  cleanApiBuild,
+  rebuildApi
+} from "@cedarjs/internal/dist/build/api";
+import { loadAndValidateSdls } from "@cedarjs/internal/dist/validateSchema";
+import { getPaths as getPaths3 } from "@cedarjs/project-config";
+
+// src/utils.ts
+function debounce(func, wait) {
+  let timeoutId = null;
+  const debounced = ((...args) => {
+    if (timeoutId !== null) {
+      clearTimeout(timeoutId);
+    }
+    timeoutId = setTimeout(() => {
+      timeoutId = null;
+      func(...args);
+    }, wait);
+  });
+  debounced.cancel = () => {
+    if (timeoutId !== null) {
+      clearTimeout(timeoutId);
+      timeoutId = null;
+    }
+  };
+  return debounced;
+}
+
+// src/buildManager.ts
+var BuildManager = class {
+  shouldRebuild;
+  shouldClean;
+  debouncedBuild;
+  buildFn;
+  constructor(buildFn) {
+    this.shouldRebuild = true;
+    this.shouldClean = false;
+    this.buildFn = buildFn;
+    if (process.env.RWJS_DELAY_RESTART) {
+      console.warn(
+        "[DEPRECATED] RWJS_DELAY_RESTART is deprecated and will be removed in the next major release. Please rename it to CEDAR_DELAY_API_RESTART in your .env file."
+      );
+    }
+    const delay = process.env.CEDAR_DELAY_API_RESTART || process.env.RWJS_DELAY_RESTART;
+    this.debouncedBuild = debounce(
+      async (options) => {
+        try {
+          await this.buildFn({
+            ...options,
+            rebuild: this.shouldRebuild,
+            clean: this.shouldClean
+          });
+        } finally {
+          this.shouldRebuild = true;
+          this.shouldClean = false;
+        }
+      },
+      // We want to delay execution when multiple files are modified on the
+      // filesystem. This usually happens when running Cedar generator commands.
+      // Local writes are very fast, but writes in e2e environments are not, so
+      // allow the default to be adjusted with an env-var.
+      delay ? parseInt(delay, 10) : 500
+    );
+  }
+  // Wrapper method to handle options and set precedence flags.
+  // If we ever see a `rebuild: false` option while debouncing, we never want to rebuild.
+  // If we ever see a `clean: true` option, we always want to clean.
+  async run(options) {
+    if (options.rebuild === false) {
+      this.shouldRebuild = false;
+    }
+    if (options.clean) {
+      this.shouldClean = true;
+    }
+    await this.debouncedBuild(options);
+  }
+  cancelScheduledBuild() {
+    this.debouncedBuild.cancel();
+  }
+};
+
+// src/serverManager.ts
+import { fork } from "child_process";
+import fs from "node:fs";
+import { createRequire } from "node:module";
+import path from "path";
+import ansis from "ansis";
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import { getConfig, getPaths, resolveFile } from "@cedarjs/project-config";
+var require2 = createRequire(import.meta.url);
+var argv = yargs(hideBin(process.argv)).option("debugPort", {
+  description: "Port on which to expose API server debugger",
+  type: "number",
+  alias: ["debug-port", "dp"]
+}).option("port", {
+  description: "The port to listen at",
+  type: "number",
+  alias: "p"
+}).parseSync();
+var rwjsPaths = getPaths();
+var ServerManager = class {
+  httpServerProcess = null;
+  async startApiServer() {
+    const forkOpts = {
+      execArgv: process.execArgv
+    };
+    if (getConfig().experimental.opentelemetry.enabled) {
+      const opentelemetrySDKScriptPath = path.join(
+        rwjsPaths.api.dist,
+        "opentelemetry.js"
+      );
+      const opentelemetrySDKScriptPathRelative = path.relative(
+        rwjsPaths.base,
+        opentelemetrySDKScriptPath
+      );
+      console.log(
+        `Setting up OpenTelemetry using the setup file: ${opentelemetrySDKScriptPathRelative}`
+      );
+      if (fs.existsSync(opentelemetrySDKScriptPath)) {
+        forkOpts.execArgv = forkOpts.execArgv.concat([
+          `--require=${opentelemetrySDKScriptPath}`
+        ]);
+      } else {
+        console.error(
+          `OpenTelemetry setup file does not exist at ${opentelemetrySDKScriptPathRelative}`
+        );
+      }
+    }
+    const debugPort = argv["debug-port"];
+    if (debugPort) {
+      forkOpts.execArgv = forkOpts.execArgv.concat([`--inspect=${debugPort}`]);
+    }
+    const port = argv.port ?? getConfig().api.port;
+    const serverFile = resolveFile(`${rwjsPaths.api.dist}/server`);
+    if (serverFile) {
+      this.httpServerProcess = fork(
+        serverFile,
+        ["--apiPort", port.toString()],
+        forkOpts
+      );
+    } else {
+      const apiServerPkgPath = require2.resolve("@cedarjs/api-server/package.json");
+      const apiServerDir = path.dirname(apiServerPkgPath);
+      const apiServerPkg = require2(apiServerPkgPath);
+      const binPath = path.join(
+        apiServerDir,
+        apiServerPkg.bin["cedarjs-server"]
+      );
+      const args = ["api", "--port", port.toString()];
+      this.httpServerProcess = fork(binPath, args, forkOpts);
+    }
+  }
+  async restartApiServer() {
+    await this.killApiServer();
+    await this.startApiServer();
+  }
+  async killApiServer() {
+    if (!this.httpServerProcess) {
+      return;
+    }
+    await new Promise((resolve) => {
+      console.log(ansis.yellow("Shutting down API server."));
+      const cleanup = () => {
+        this.httpServerProcess?.removeAllListeners("exit");
+        clearTimeout(forceKillTimeout);
+      };
+      this.httpServerProcess?.on("exit", () => {
+        console.log(ansis.yellow("API server exited."));
+        cleanup();
+        resolve();
+      });
+      const forceKillTimeout = setTimeout(() => {
+        console.log(
+          ansis.yellow(
+            "API server did not exit within 2 seconds, forcefully closing it."
+          )
+        );
+        cleanup();
+        this.httpServerProcess?.kill("SIGKILL");
+        resolve();
+      }, 2e3);
+      this.httpServerProcess?.kill();
+    });
+  }
+};
+var serverManager = new ServerManager();
+
+// src/watchPaths.ts
+import fs2 from "node:fs";
+import path2 from "node:path";
+import {
+  getDbDir,
+  getPaths as getPaths2,
+  importStatementPath
+} from "@cedarjs/project-config";
+async function workspacePackagesPaths() {
+  const cedarPaths2 = getPaths2();
+  const packagesDir = path2.join(cedarPaths2.packages);
+  const packages = [];
+  try {
+    const rootPackageJsonPath = path2.join(cedarPaths2.base, "package.json");
+    const rootPackageJson = JSON.parse(
+      fs2.readFileSync(rootPackageJsonPath, "utf8")
+    );
+    const hasPackageJsonWorkspaces = Array.isArray(rootPackageJson.workspaces) && rootPackageJson.workspaces.some((w) => w.startsWith("packages/"));
+    if (!hasPackageJsonWorkspaces || !fs2.existsSync(packagesDir)) {
+      return [];
+    }
+    const globPattern = path2.join(packagesDir, "*").replaceAll("\\", "/");
+    const packageDirs = await Array.fromAsync(fs2.promises.glob(globPattern));
+    const apiPackageJsonPath = path2.join(cedarPaths2.api.base, "package.json");
+    const apiPackageJson = JSON.parse(
+      fs2.readFileSync(apiPackageJsonPath, "utf8")
+    );
+    const deps = {
+      ...apiPackageJson.dependencies ?? {},
+      ...apiPackageJson.devDependencies ?? {},
+      ...apiPackageJson.peerDependencies ?? {}
+    };
+    const workspaceDepNames = /* @__PURE__ */ new Set();
+    for (const [name, version] of Object.entries(deps)) {
+      if (String(version).startsWith("workspace:")) {
+        workspaceDepNames.add(name);
+      }
+    }
+    for (const packageDir of packageDirs) {
+      const packageJsonPath = path2.join(packageDir, "package.json");
+      if (!fs2.existsSync(packageJsonPath)) {
+        continue;
+      }
+      const pkgJson = JSON.parse(fs2.readFileSync(packageJsonPath, "utf8"));
+      if (workspaceDepNames.has(pkgJson.name)) {
+        packages.push(path2.join(packageDir, "dist"));
+      }
+    }
+  } catch {
+  }
+  return packages;
+}
+async function apiIgnorePaths() {
+  const cedarPaths2 = getPaths2();
+  const dbDir = await getDbDir(cedarPaths2.api.prismaConfig);
+  if (dbDir === cedarPaths2.api.base) {
+    throw new Error(
+      "Database directory cannot be the same as the API directory"
+    );
+  }
+  const ignoredApiPaths = [
+    // TODO: Is this still true?
+    // use this, because using cedarPaths.api.dist seems to not ignore on first
+    // build
+    "api/dist",
+    cedarPaths2.api.types,
+    dbDir
+  ];
+  return ignoredApiPaths;
+}
+async function getIgnoreFunction() {
+  const cedarPaths2 = getPaths2();
+  const ignoredApiPaths = await apiIgnorePaths();
+  const ignoredExtensions = [
+    ".DS_Store",
+    ".db",
+    ".sqlite",
+    "-journal",
+    ".test.js",
+    ".test.ts",
+    ".scenarios.ts",
+    ".scenarios.js",
+    ".d.ts",
+    ".log"
+  ];
+  return (file) => {
+    if (file.includes("node_modules")) {
+      return true;
+    }
+    if (ignoredExtensions.some((ext) => file.endsWith(ext))) {
+      return true;
+    }
+    if (file.includes(importStatementPath(cedarPaths2.packages)) && file.includes("/src/")) {
+      return true;
+    }
+    if (ignoredApiPaths.some((ignoredPath) => file.includes(ignoredPath))) {
+      return true;
+    }
+    return false;
+  };
+}
+async function pathsToWatch() {
+  const cedarPaths2 = getPaths2();
+  const watchPaths = [cedarPaths2.api.src, ...await workspacePackagesPaths()];
+  return watchPaths.map((p) => importStatementPath(p));
+}
+
+// src/watch.ts
+var cedarPaths = getPaths3();
+if (!process.env.CEDAR_ENV_FILES_LOADED) {
+  config({
+    path: path3.join(cedarPaths.base, ".env"),
+    defaults: path3.join(cedarPaths.base, ".env.defaults"),
+    multiline: true
+  });
+  process.env.CEDAR_ENV_FILES_LOADED = "true";
+}
+async function buildAndServe(options) {
+  const buildTs = Date.now();
+  console.log(ansis2.dim.italic("Building..."));
+  if (options.clean) {
+    await cleanApiBuild();
+  }
+  if (options.rebuild) {
+    await rebuildApi();
+  } else {
+    await buildApi();
+  }
+  await serverManager.restartApiServer();
+  console.log(ansis2.dim.italic("Took " + (Date.now() - buildTs) + " ms"));
+}
+var buildManager = new BuildManager(buildAndServe);
+async function validateSdls() {
+  try {
+    await loadAndValidateSdls();
+    return true;
+  } catch (e) {
+    serverManager.killApiServer();
+    console.error(
+      ansis2.redBright(`[GQL Server Error] - Schema validation failed`)
+    );
+    console.error(ansis2.red(e?.message));
+    console.error(ansis2.redBright("-".repeat(40)));
+    buildManager.cancelScheduledBuild();
+    return false;
+  }
+}
+async function startWatch() {
+  const patterns = await pathsToWatch();
+  const watcher = chokidar.watch(patterns, {
+    persistent: true,
+    ignoreInitial: true,
+    ignored: await getIgnoreFunction()
+  });
+  watcher.on("ready", async () => {
+    await buildManager.run({ clean: true, rebuild: false });
+    await validateSdls();
+  });
+  watcher.on("all", async (eventName, filePath) => {
+    if (eventName === "addDir" && filePath === cedarPaths.api.base) {
+      return;
+    }
+    if (eventName) {
+      if (filePath.includes(".sdl")) {
+        const isValid = await validateSdls();
+        if (!isValid) {
+          return;
+        }
+      }
+    }
+    const displayPath = path3.relative(cedarPaths.base, filePath);
+    console.log(ansis2.dim(`[${eventName}] ${displayPath}`));
+    buildManager.cancelScheduledBuild();
+    if (eventName === "add" || eventName === "unlink") {
+      await buildManager.run({ rebuild: false });
+    } else {
+      await buildManager.run({ rebuild: true });
+    }
+  });
+}
+
+// src/bin.ts
+await startWatch();

package/dist/buildManager.d.ts

@@ -0,0 +1,15 @@
+export type BuildAndRestartOptions = {
+    rebuild?: boolean;
+    clean?: boolean;
+};
+declare class BuildManager {
+    private shouldRebuild;
+    private shouldClean;
+    private debouncedBuild;
+    private buildFn;
+    constructor(buildFn: (options: BuildAndRestartOptions) => Promise<void>);
+    run(options: BuildAndRestartOptions): Promise<void>;
+    cancelScheduledBuild(): void;
+}
+export { BuildManager };
+//# sourceMappingURL=buildManager.d.ts.map

package/dist/buildManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildManager.d.ts","sourceRoot":"","sources":["../src/buildManager.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,sBAAsB,GAAG;IACnC,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,KAAK,CAAC,EAAE,OAAO,CAAA;CAChB,CAAA;AAED,cAAM,YAAY;IAChB,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,cAAc,CAA6B;IACnD,OAAO,CAAC,OAAO,CAAoD;gBAEvD,OAAO,EAAE,CAAC,OAAO,EAAE,sBAAsB,KAAK,OAAO,CAAC,IAAI,CAAC;IAsCjE,GAAG,CAAC,OAAO,EAAE,sBAAsB;IAWzC,oBAAoB;CAGrB;AAED,OAAO,EAAE,YAAY,EAAE,CAAA"}

package/dist/buildManager.js

@@ -0,0 +1,55 @@
+import { debounce } from "./utils.js";
+class BuildManager {
+  shouldRebuild;
+  shouldClean;
+  debouncedBuild;
+  buildFn;
+  constructor(buildFn) {
+    this.shouldRebuild = true;
+    this.shouldClean = false;
+    this.buildFn = buildFn;
+    if (process.env.RWJS_DELAY_RESTART) {
+      console.warn(
+        "[DEPRECATED] RWJS_DELAY_RESTART is deprecated and will be removed in the next major release. Please rename it to CEDAR_DELAY_API_RESTART in your .env file."
+      );
+    }
+    const delay = process.env.CEDAR_DELAY_API_RESTART || process.env.RWJS_DELAY_RESTART;
+    this.debouncedBuild = debounce(
+      async (options) => {
+        try {
+          await this.buildFn({
+            ...options,
+            rebuild: this.shouldRebuild,
+            clean: this.shouldClean
+          });
+        } finally {
+          this.shouldRebuild = true;
+          this.shouldClean = false;
+        }
+      },
+      // We want to delay execution when multiple files are modified on the
+      // filesystem. This usually happens when running Cedar generator commands.
+      // Local writes are very fast, but writes in e2e environments are not, so
+      // allow the default to be adjusted with an env-var.
+      delay ? parseInt(delay, 10) : 500
+    );
+  }
+  // Wrapper method to handle options and set precedence flags.
+  // If we ever see a `rebuild: false` option while debouncing, we never want to rebuild.
+  // If we ever see a `clean: true` option, we always want to clean.
+  async run(options) {
+    if (options.rebuild === false) {
+      this.shouldRebuild = false;
+    }
+    if (options.clean) {
+      this.shouldClean = true;
+    }
+    await this.debouncedBuild(options);
+  }
+  cancelScheduledBuild() {
+    this.debouncedBuild.cancel();
+  }
+}
+export {
+  BuildManager
+};

package/dist/serverManager.d.ts

@@ -0,0 +1,8 @@
+export declare class ServerManager {
+    private httpServerProcess;
+    private startApiServer;
+    restartApiServer(): Promise<void>;
+    killApiServer(): Promise<void>;
+}
+export declare const serverManager: ServerManager;
+//# sourceMappingURL=serverManager.d.ts.map

package/dist/serverManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serverManager.d.ts","sourceRoot":"","sources":["../src/serverManager.ts"],"names":[],"mappings":"AA6BA,qBAAa,aAAa;IACxB,OAAO,CAAC,iBAAiB,CAA4B;YAEvC,cAAc;IAiEtB,gBAAgB;IAKhB,aAAa;CAmCpB;AAED,eAAO,MAAM,aAAa,eAAsB,CAAA"}

package/dist/serverManager.js

@@ -0,0 +1,109 @@
+import { fork } from "child_process";
+import fs from "node:fs";
+import { createRequire } from "node:module";
+import path from "path";
+import ansis from "ansis";
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import { getConfig, getPaths, resolveFile } from "@cedarjs/project-config";
+const require2 = createRequire(import.meta.url);
+const argv = yargs(hideBin(process.argv)).option("debugPort", {
+  description: "Port on which to expose API server debugger",
+  type: "number",
+  alias: ["debug-port", "dp"]
+}).option("port", {
+  description: "The port to listen at",
+  type: "number",
+  alias: "p"
+}).parseSync();
+const rwjsPaths = getPaths();
+class ServerManager {
+  httpServerProcess = null;
+  async startApiServer() {
+    const forkOpts = {
+      execArgv: process.execArgv
+    };
+    if (getConfig().experimental.opentelemetry.enabled) {
+      const opentelemetrySDKScriptPath = path.join(
+        rwjsPaths.api.dist,
+        "opentelemetry.js"
+      );
+      const opentelemetrySDKScriptPathRelative = path.relative(
+        rwjsPaths.base,
+        opentelemetrySDKScriptPath
+      );
+      console.log(
+        `Setting up OpenTelemetry using the setup file: ${opentelemetrySDKScriptPathRelative}`
+      );
+      if (fs.existsSync(opentelemetrySDKScriptPath)) {
+        forkOpts.execArgv = forkOpts.execArgv.concat([
+          `--require=${opentelemetrySDKScriptPath}`
+        ]);
+      } else {
+        console.error(
+          `OpenTelemetry setup file does not exist at ${opentelemetrySDKScriptPathRelative}`
+        );
+      }
+    }
+    const debugPort = argv["debug-port"];
+    if (debugPort) {
+      forkOpts.execArgv = forkOpts.execArgv.concat([`--inspect=${debugPort}`]);
+    }
+    const port = argv.port ?? getConfig().api.port;
+    const serverFile = resolveFile(`${rwjsPaths.api.dist}/server`);
+    if (serverFile) {
+      this.httpServerProcess = fork(
+        serverFile,
+        ["--apiPort", port.toString()],
+        forkOpts
+      );
+    } else {
+      const apiServerPkgPath = require2.resolve("@cedarjs/api-server/package.json");
+      const apiServerDir = path.dirname(apiServerPkgPath);
+      const apiServerPkg = require2(apiServerPkgPath);
+      const binPath = path.join(
+        apiServerDir,
+        apiServerPkg.bin["cedarjs-server"]
+      );
+      const args = ["api", "--port", port.toString()];
+      this.httpServerProcess = fork(binPath, args, forkOpts);
+    }
+  }
+  async restartApiServer() {
+    await this.killApiServer();
+    await this.startApiServer();
+  }
+  async killApiServer() {
+    if (!this.httpServerProcess) {
+      return;
+    }
+    await new Promise((resolve) => {
+      console.log(ansis.yellow("Shutting down API server."));
+      const cleanup = () => {
+        this.httpServerProcess?.removeAllListeners("exit");
+        clearTimeout(forceKillTimeout);
+      };
+      this.httpServerProcess?.on("exit", () => {
+        console.log(ansis.yellow("API server exited."));
+        cleanup();
+        resolve();
+      });
+      const forceKillTimeout = setTimeout(() => {
+        console.log(
+          ansis.yellow(
+            "API server did not exit within 2 seconds, forcefully closing it."
+          )
+        );
+        cleanup();
+        this.httpServerProcess?.kill("SIGKILL");
+        resolve();
+      }, 2e3);
+      this.httpServerProcess?.kill();
+    });
+  }
+}
+const serverManager = new ServerManager();
+export {
+  ServerManager,
+  serverManager
+};

package/dist/utils.d.ts

@@ -0,0 +1,4 @@
+export declare function debounce<T extends (...args: any[]) => any>(func: T, wait: number): T & {
+    cancel: () => void;
+};
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,wBAAgB,QAAQ,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EACxD,IAAI,EAAE,CAAC,EACP,IAAI,EAAE,MAAM,GACX,CAAC,GAAG;IAAE,MAAM,EAAE,MAAM,IAAI,CAAA;CAAE,CAsB5B"}

package/dist/utils.js

@@ -0,0 +1,22 @@
+function debounce(func, wait) {
+  let timeoutId = null;
+  const debounced = ((...args) => {
+    if (timeoutId !== null) {
+      clearTimeout(timeoutId);
+    }
+    timeoutId = setTimeout(() => {
+      timeoutId = null;
+      func(...args);
+    }, wait);
+  });
+  debounced.cancel = () => {
+    if (timeoutId !== null) {
+      clearTimeout(timeoutId);
+      timeoutId = null;
+    }
+  };
+  return debounced;
+}
+export {
+  debounce
+};

package/dist/watch.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Initialize the file watcher for the API server
+ * Watches for changes in the API source directory and rebuilds/restarts as
+ * needed
+ *
+ * Also watches package sources so that changes to workspace packages used by
+ * the API trigger a rebuild/restart (HMR for API-side workspace packages).
+ */
+export declare function startWatch(): Promise<void>;
+//# sourceMappingURL=watch.d.ts.map

package/dist/watch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"watch.d.ts","sourceRoot":"","sources":["../src/watch.ts"],"names":[],"mappings":"AAqEA;;;;;;;GAOG;AACH,wBAAsB,UAAU,kBAsD/B"}

package/dist/watch.js

@@ -0,0 +1,89 @@
+import path from "node:path";
+import ansis from "ansis";
+import chokidar from "chokidar";
+import { config } from "dotenv-defaults";
+import {
+  buildApi,
+  cleanApiBuild,
+  rebuildApi
+} from "@cedarjs/internal/dist/build/api";
+import { loadAndValidateSdls } from "@cedarjs/internal/dist/validateSchema";
+import { getPaths } from "@cedarjs/project-config";
+import { BuildManager } from "./buildManager.js";
+import { serverManager } from "./serverManager.js";
+import { getIgnoreFunction, pathsToWatch } from "./watchPaths.js";
+const cedarPaths = getPaths();
+if (!process.env.CEDAR_ENV_FILES_LOADED) {
+  config({
+    path: path.join(cedarPaths.base, ".env"),
+    defaults: path.join(cedarPaths.base, ".env.defaults"),
+    multiline: true
+  });
+  process.env.CEDAR_ENV_FILES_LOADED = "true";
+}
+async function buildAndServe(options) {
+  const buildTs = Date.now();
+  console.log(ansis.dim.italic("Building..."));
+  if (options.clean) {
+    await cleanApiBuild();
+  }
+  if (options.rebuild) {
+    await rebuildApi();
+  } else {
+    await buildApi();
+  }
+  await serverManager.restartApiServer();
+  console.log(ansis.dim.italic("Took " + (Date.now() - buildTs) + " ms"));
+}
+const buildManager = new BuildManager(buildAndServe);
+async function validateSdls() {
+  try {
+    await loadAndValidateSdls();
+    return true;
+  } catch (e) {
+    serverManager.killApiServer();
+    console.error(
+      ansis.redBright(`[GQL Server Error] - Schema validation failed`)
+    );
+    console.error(ansis.red(e?.message));
+    console.error(ansis.redBright("-".repeat(40)));
+    buildManager.cancelScheduledBuild();
+    return false;
+  }
+}
+async function startWatch() {
+  const patterns = await pathsToWatch();
+  const watcher = chokidar.watch(patterns, {
+    persistent: true,
+    ignoreInitial: true,
+    ignored: await getIgnoreFunction()
+  });
+  watcher.on("ready", async () => {
+    await buildManager.run({ clean: true, rebuild: false });
+    await validateSdls();
+  });
+  watcher.on("all", async (eventName, filePath) => {
+    if (eventName === "addDir" && filePath === cedarPaths.api.base) {
+      return;
+    }
+    if (eventName) {
+      if (filePath.includes(".sdl")) {
+        const isValid = await validateSdls();
+        if (!isValid) {
+          return;
+        }
+      }
+    }
+    const displayPath = path.relative(cedarPaths.base, filePath);
+    console.log(ansis.dim(`[${eventName}] ${displayPath}`));
+    buildManager.cancelScheduledBuild();
+    if (eventName === "add" || eventName === "unlink") {
+      await buildManager.run({ rebuild: false });
+    } else {
+      await buildManager.run({ rebuild: true });
+    }
+  });
+}
+export {
+  startWatch
+};

package/dist/watchPaths.d.ts

@@ -0,0 +1,3 @@
+export declare function getIgnoreFunction(): Promise<(file: string) => boolean>;
+export declare function pathsToWatch(): Promise<string[]>;
+//# sourceMappingURL=watchPaths.d.ts.map

package/dist/watchPaths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"watchPaths.d.ts","sourceRoot":"","sources":["../src/watchPaths.ts"],"names":[],"mappings":"AAmGA,wBAAsB,iBAAiB,mBAqBvB,MAAM,cAwBrB;AAED,wBAAsB,YAAY,sBAQjC"}

package/dist/watchPaths.js

@@ -0,0 +1,109 @@
+import fs from "node:fs";
+import path from "node:path";
+import {
+  getDbDir,
+  getPaths,
+  importStatementPath
+} from "@cedarjs/project-config";
+async function workspacePackagesPaths() {
+  const cedarPaths = getPaths();
+  const packagesDir = path.join(cedarPaths.packages);
+  const packages = [];
+  try {
+    const rootPackageJsonPath = path.join(cedarPaths.base, "package.json");
+    const rootPackageJson = JSON.parse(
+      fs.readFileSync(rootPackageJsonPath, "utf8")
+    );
+    const hasPackageJsonWorkspaces = Array.isArray(rootPackageJson.workspaces) && rootPackageJson.workspaces.some((w) => w.startsWith("packages/"));
+    if (!hasPackageJsonWorkspaces || !fs.existsSync(packagesDir)) {
+      return [];
+    }
+    const globPattern = path.join(packagesDir, "*").replaceAll("\\", "/");
+    const packageDirs = await Array.fromAsync(fs.promises.glob(globPattern));
+    const apiPackageJsonPath = path.join(cedarPaths.api.base, "package.json");
+    const apiPackageJson = JSON.parse(
+      fs.readFileSync(apiPackageJsonPath, "utf8")
+    );
+    const deps = {
+      ...apiPackageJson.dependencies ?? {},
+      ...apiPackageJson.devDependencies ?? {},
+      ...apiPackageJson.peerDependencies ?? {}
+    };
+    const workspaceDepNames = /* @__PURE__ */ new Set();
+    for (const [name, version] of Object.entries(deps)) {
+      if (String(version).startsWith("workspace:")) {
+        workspaceDepNames.add(name);
+      }
+    }
+    for (const packageDir of packageDirs) {
+      const packageJsonPath = path.join(packageDir, "package.json");
+      if (!fs.existsSync(packageJsonPath)) {
+        continue;
+      }
+      const pkgJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+      if (workspaceDepNames.has(pkgJson.name)) {
+        packages.push(path.join(packageDir, "dist"));
+      }
+    }
+  } catch {
+  }
+  return packages;
+}
+async function apiIgnorePaths() {
+  const cedarPaths = getPaths();
+  const dbDir = await getDbDir(cedarPaths.api.prismaConfig);
+  if (dbDir === cedarPaths.api.base) {
+    throw new Error(
+      "Database directory cannot be the same as the API directory"
+    );
+  }
+  const ignoredApiPaths = [
+    // TODO: Is this still true?
+    // use this, because using cedarPaths.api.dist seems to not ignore on first
+    // build
+    "api/dist",
+    cedarPaths.api.types,
+    dbDir
+  ];
+  return ignoredApiPaths;
+}
+async function getIgnoreFunction() {
+  const cedarPaths = getPaths();
+  const ignoredApiPaths = await apiIgnorePaths();
+  const ignoredExtensions = [
+    ".DS_Store",
+    ".db",
+    ".sqlite",
+    "-journal",
+    ".test.js",
+    ".test.ts",
+    ".scenarios.ts",
+    ".scenarios.js",
+    ".d.ts",
+    ".log"
+  ];
+  return (file) => {
+    if (file.includes("node_modules")) {
+      return true;
+    }
+    if (ignoredExtensions.some((ext) => file.endsWith(ext))) {
+      return true;
+    }
+    if (file.includes(importStatementPath(cedarPaths.packages)) && file.includes("/src/")) {
+      return true;
+    }
+    if (ignoredApiPaths.some((ignoredPath) => file.includes(ignoredPath))) {
+      return true;
+    }
+    return false;
+  };
+}
+async function pathsToWatch() {
+  const cedarPaths = getPaths();
+  const watchPaths = [cedarPaths.api.src, ...await workspacePackagesPaths()];
+  return watchPaths.map((p) => importStatementPath(p));
+}
+export {
+  getIgnoreFunction,
+  pathsToWatch
+};

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@cedarjs/api-server-watch",
+  "version": "6.0.0-canary.2828",
+  "description": "CedarJS's dev-time watcher that rebuilds and restarts the api server on change",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cedarjs/cedar.git",
+    "directory": "packages/api-server-watch"
+  },
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/watch.js",
+  "types": "./dist/watch.d.ts",
+  "bin": {
+    "cedar-api-server-watch": "./dist/bin.js",
+    "cedarjs-api-server-watch": "./dist/bin.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "node ./build.mts",
+    "build:pack": "yarn pack -o cedarjs-api-server-watch.tgz",
+    "build:types": "tsc --build --verbose ./tsconfig.build.json",
+    "build:watch": "nodemon --watch src --ext \"js,jsx,ts,tsx\" --ignore dist --exec \"yarn build && yarn fix:permissions\"",
+    "fix:permissions": "chmod +x dist/bin.js",
+    "prepublishOnly": "NODE_ENV=production yarn build",
+    "test": "vitest run",
+    "test:watch": "vitest watch"
+  },
+  "dependencies": {
+    "@cedarjs/api-server": "6.0.0-canary.2828",
+    "@cedarjs/internal": "6.0.0-canary.2828",
+    "@cedarjs/project-config": "6.0.0-canary.2828",
+    "ansis": "4.3.1",
+    "chokidar": "3.6.0",
+    "dotenv-defaults": "5.0.2",
+    "yargs": "17.7.3"
+  },
+  "devDependencies": {
+    "@cedarjs/framework-tools": "6.0.0-canary.2828",
+    "@types/dotenv-defaults": "^5.0.0",
+    "@types/yargs": "17.0.35",
+    "typescript": "5.9.3",
+    "vitest": "4.1.10"
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}