@redmix/api-server 0.0.1

package/dist/watch.js

@@ -0,0 +1,274 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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
+));
+
+// src/watch.ts
+var import_path2 = __toESM(require("path"));
+var import_chalk2 = __toESM(require("chalk"));
+var import_chokidar = __toESM(require("chokidar"));
+var import_dotenv = __toESM(require("dotenv"));
+var import_api = require("@redmix/internal/dist/build/api");
+var import_validateSchema = require("@redmix/internal/dist/validateSchema");
+var import_project_config2 = require("@redmix/project-config");
+
+// src/buildManager.ts
+var import_lodash = require("lodash");
+var BuildManager = class {
+  shouldRebuild;
+  shouldClean;
+  debouncedBuild;
+  buildFn;
+  constructor(buildFn) {
+    this.shouldRebuild = true;
+    this.shouldClean = false;
+    this.buildFn = buildFn;
+    this.debouncedBuild = (0, import_lodash.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 RedwoodJS 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.
+      //
+      process.env.RWJS_DELAY_RESTART ? parseInt(process.env.RWJS_DELAY_RESTART, 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
+var import_child_process = require("child_process");
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_chalk = __toESM(require("chalk"));
+var import_yargs = __toESM(require("yargs"));
+var import_helpers = require("yargs/helpers");
+var import_project_config = require("@redmix/project-config");
+var argv = (0, import_yargs.default)((0, import_helpers.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 = (0, import_project_config.getPaths)();
+var ServerManager = class {
+  httpServerProcess = null;
+  async startApiServer() {
+    const forkOpts = {
+      execArgv: process.execArgv
+    };
+    if ((0, import_project_config.getConfig)().experimental.opentelemetry.enabled) {
+      const opentelemetrySDKScriptPath = import_path.default.join(
+        rwjsPaths.api.dist,
+        "opentelemetry.js"
+      );
+      const opentelemetrySDKScriptPathRelative = import_path.default.relative(
+        rwjsPaths.base,
+        opentelemetrySDKScriptPath
+      );
+      console.log(
+        `Setting up OpenTelemetry using the setup file: ${opentelemetrySDKScriptPathRelative}`
+      );
+      if (import_fs.default.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 ?? (0, import_project_config.getConfig)().api.port;
+    const serverFile = (0, import_project_config.resolveFile)(`${rwjsPaths.api.dist}/server`);
+    if (serverFile) {
+      this.httpServerProcess = (0, import_child_process.fork)(
+        serverFile,
+        ["--apiPort", port.toString()],
+        forkOpts
+      );
+    } else {
+      this.httpServerProcess = (0, import_child_process.fork)(
+        import_path.default.join(__dirname, "bin.js"),
+        ["api", "--port", port.toString()],
+        forkOpts
+      );
+    }
+  }
+  async restartApiServer() {
+    await this.killApiServer();
+    await this.startApiServer();
+  }
+  async killApiServer() {
+    if (!this.httpServerProcess) {
+      return;
+    }
+    await new Promise((resolve) => {
+      console.log(import_chalk.default.yellow("Shutting down API server."));
+      const cleanup = () => {
+        this.httpServerProcess?.removeAllListeners("exit");
+        clearTimeout(forceKillTimeout);
+      };
+      this.httpServerProcess?.on("exit", () => {
+        console.log(import_chalk.default.yellow("API server exited."));
+        cleanup();
+        resolve();
+      });
+      const forceKillTimeout = setTimeout(() => {
+        console.log(
+          import_chalk.default.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/watch.ts
+var rwjsPaths2 = (0, import_project_config2.getPaths)();
+if (!process.env.REDWOOD_ENV_FILES_LOADED) {
+  import_dotenv.default.config({
+    path: import_path2.default.join(rwjsPaths2.base, ".env"),
+    // @ts-expect-error The types for dotenv-defaults are using an outdated version of dotenv
+    defaults: import_path2.default.join(rwjsPaths2.base, ".env.defaults"),
+    multiline: true
+  });
+  process.env.REDWOOD_ENV_FILES_LOADED = "true";
+}
+async function buildAndServe(options) {
+  const buildTs = Date.now();
+  console.log(import_chalk2.default.dim.italic("Building..."));
+  if (options.clean) {
+    await (0, import_api.cleanApiBuild)();
+  }
+  if (options.rebuild) {
+    await (0, import_api.rebuildApi)();
+  } else {
+    await (0, import_api.buildApi)();
+  }
+  await serverManager.restartApiServer();
+  console.log(import_chalk2.default.dim.italic("Took " + (Date.now() - buildTs) + " ms"));
+}
+var buildManager = new BuildManager(buildAndServe);
+async function validateSdls() {
+  try {
+    await (0, import_validateSchema.loadAndValidateSdls)();
+    return true;
+  } catch (e) {
+    serverManager.killApiServer();
+    console.error(
+      import_chalk2.default.redBright(`[GQL Server Error] - Schema validation failed`)
+    );
+    console.error(import_chalk2.default.red(e?.message));
+    console.error(import_chalk2.default.redBright("-".repeat(40)));
+    buildManager.cancelScheduledBuild();
+    return false;
+  }
+}
+var IGNORED_API_PATHS = [
+  "api/dist",
+  // use this, because using rwjsPaths.api.dist seems to not ignore on first build
+  rwjsPaths2.api.types,
+  rwjsPaths2.api.db
+].map((path3) => (0, import_project_config2.ensurePosixPath)(path3));
+import_chokidar.default.watch([rwjsPaths2.api.src], {
+  persistent: true,
+  ignoreInitial: true,
+  ignored: (file) => {
+    const x = file.includes("node_modules") || IGNORED_API_PATHS.some((ignoredPath) => file.includes(ignoredPath)) || [
+      ".DS_Store",
+      ".db",
+      ".sqlite",
+      "-journal",
+      ".test.js",
+      ".test.ts",
+      ".scenarios.ts",
+      ".scenarios.js",
+      ".d.ts",
+      ".log"
+    ].some((ext) => file.endsWith(ext));
+    return x;
+  }
+}).on("ready", async () => {
+  await buildManager.run({ clean: true, rebuild: false });
+  await validateSdls();
+}).on("all", async (eventName, filePath) => {
+  if (eventName === "addDir" && filePath === rwjsPaths2.api.base) {
+    return;
+  }
+  if (eventName) {
+    if (filePath.includes(".sdl")) {
+      const isValid = await validateSdls();
+      if (!isValid) {
+        return;
+      }
+    }
+  }
+  console.log(
+    import_chalk2.default.dim(`[${eventName}] ${filePath.replace(rwjsPaths2.api.base, "")}`)
+  );
+  buildManager.cancelScheduledBuild();
+  if (eventName === "add" || eventName === "unlink") {
+    await buildManager.run({ rebuild: false });
+  } else {
+    await buildManager.run({ rebuild: true });
+  }
+});

package/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "@redmix/api-server",
+  "version": "0.0.1",
+  "description": "Redmix's HTTP server for Serverless Functions",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/redmix-run/redmix.git",
+    "directory": "packages/api-server"
+  },
+  "license": "MIT",
+  "main": "./dist/createServer.js",
+  "types": "./dist/createServer.d.ts",
+  "bin": {
+    "rw-api-server-watch": "./dist/watch.js",
+    "rw-log-formatter": "./dist/logFormatter/bin.js",
+    "rw-server": "./dist/bin.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsx ./build.mts && yarn build:types",
+    "build:pack": "yarn pack -o redmix-api-server.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/index.js; chmod +x dist/watch.js",
+    "prepublishOnly": "NODE_ENV=production yarn build",
+    "test": "vitest run",
+    "test:watch": "vitest watch"
+  },
+  "dependencies": {
+    "@fastify/multipart": "8.3.1",
+    "@fastify/url-data": "5.4.0",
+    "@redmix/context": "0.0.1",
+    "@redmix/fastify-web": "0.0.1",
+    "@redmix/internal": "0.0.1",
+    "@redmix/project-config": "0.0.1",
+    "@redmix/web-server": "0.0.1",
+    "chalk": "4.1.2",
+    "chokidar": "3.6.0",
+    "dotenv-defaults": "5.0.2",
+    "fast-glob": "3.3.2",
+    "fast-json-parse": "1.0.3",
+    "fastify": "4.28.1",
+    "fastify-raw-body": "4.3.0",
+    "lodash": "4.17.21",
+    "pretty-bytes": "5.6.0",
+    "pretty-ms": "7.0.1",
+    "qs": "6.13.0",
+    "split2": "4.2.0",
+    "yargs": "17.7.2"
+  },
+  "devDependencies": {
+    "@redmix/framework-tools": "0.0.1",
+    "@types/aws-lambda": "8.10.145",
+    "@types/lodash": "4.17.15",
+    "@types/qs": "6.9.16",
+    "@types/split2": "4.2.3",
+    "@types/yargs": "17.0.33",
+    "pino-abstract-transport": "1.2.0",
+    "tsx": "4.19.3",
+    "typescript": "5.6.2",
+    "vitest": "2.1.9"
+  },
+  "peerDependencies": {
+    "@redmix/graphql-server": "workspace:*"
+  },
+  "peerDependenciesMeta": {
+    "@redmix/graphql-server": {
+      "optional": true
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "688027c97502c500ebbede9cdc7cc51545a8dcf3"
+}