@redmix/api-server 0.0.1

package/dist/logFormatter/formatters.js

@@ -0,0 +1,275 @@
+"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 __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 formatters_exports = {};
+__export(formatters_exports, {
+  NEWLINE: () => NEWLINE,
+  emojiLog: () => emojiLog,
+  formatBundleSize: () => formatBundleSize,
+  formatCustom: () => formatCustom,
+  formatData: () => formatData,
+  formatDate: () => formatDate,
+  formatErrorProp: () => formatErrorProp,
+  formatLevel: () => formatLevel,
+  formatLoadTime: () => formatLoadTime,
+  formatMessage: () => formatMessage,
+  formatMessageName: () => formatMessageName,
+  formatMethod: () => formatMethod,
+  formatName: () => formatName,
+  formatNs: () => formatNs,
+  formatOperationName: () => formatOperationName,
+  formatQuery: () => formatQuery,
+  formatRequestId: () => formatRequestId,
+  formatResponseCache: () => formatResponseCache,
+  formatStack: () => formatStack,
+  formatStatusCode: () => formatStatusCode,
+  formatTracing: () => formatTracing,
+  formatUrl: () => formatUrl,
+  formatUserAgent: () => formatUserAgent,
+  ignoredCustomData: () => ignoredCustomData,
+  isEmptyObject: () => isEmptyObject,
+  isObject: () => isObject,
+  isPinoLog: () => isPinoLog,
+  isWideEmoji: () => isWideEmoji,
+  noEmpty: () => noEmpty
+});
+module.exports = __toCommonJS(formatters_exports);
+var import_chalk = __toESM(require("chalk"));
+var import_pretty_bytes = __toESM(require("pretty-bytes"));
+var import_pretty_ms = __toESM(require("pretty-ms"));
+const NEWLINE = "\n";
+const emojiLog = {
+  warn: "\u{1F6A6}",
+  info: "\u{1F332}",
+  error: "\u{1F6A8}",
+  debug: "\u{1F41B}",
+  fatal: "\u{1F480}",
+  trace: "\u{1F9F5}"
+};
+const ignoredCustomData = [
+  "time",
+  "pid",
+  "hostname",
+  "msg",
+  "res",
+  "req",
+  "reqId",
+  "responseTime"
+];
+const isObject = (object) => {
+  return object && Object.prototype.toString.apply(object) === "[object Object]";
+};
+const isEmptyObject = (object) => {
+  return object && !Object.keys(object).length;
+};
+const isPinoLog = (log) => {
+  return log && Object.prototype.hasOwnProperty.call(log, "level");
+};
+const isWideEmoji = (character) => {
+  return character !== "\u{1F6A6}";
+};
+const formatBundleSize = (bundle) => {
+  const bytes = parseInt(bundle, 10);
+  const size = (0, import_pretty_bytes.default)(bytes).replace(/ /, "");
+  return import_chalk.default.gray(size);
+};
+const formatCustom = (query) => {
+  if (!query) {
+    return;
+  }
+  ignoredCustomData.forEach((key) => {
+    delete query[key];
+  });
+  if (!isEmptyObject(query)) {
+    return import_chalk.default.white(
+      NEWLINE + "\u{1F5D2} Custom" + NEWLINE + JSON.stringify(query, null, 2)
+    );
+  }
+  return;
+};
+const formatData = (data) => {
+  if (!isEmptyObject(data)) {
+    return import_chalk.default.white(
+      NEWLINE + "\u{1F4E6} Result Data" + NEWLINE + JSON.stringify(data, null, 2)
+    );
+  }
+  return;
+};
+const formatDate = (instant) => {
+  const date = new Date(instant);
+  const hours = date.getHours().toString().padStart(2, "0");
+  const minutes = date.getMinutes().toString().padStart(2, "0");
+  const seconds = date.getSeconds().toString().padStart(2, "0");
+  const prettyDate = hours + ":" + minutes + ":" + seconds;
+  return import_chalk.default.gray(prettyDate);
+};
+const formatErrorProp = (errorPropValue) => {
+  const errorType = errorPropValue["type"] || "Error";
+  delete errorPropValue["message"];
+  delete errorPropValue["stack"];
+  delete errorPropValue["type"];
+  return import_chalk.default.redBright(
+    NEWLINE + NEWLINE + `\u{1F6A8} ${errorType} Info` + NEWLINE + NEWLINE + JSON.stringify(errorPropValue, null, 2) + NEWLINE
+  );
+};
+const formatLevel = (level) => {
+  const emoji = emojiLog[level];
+  const padding = isWideEmoji(emoji) ? "" : " ";
+  return emoji + padding;
+};
+const formatLoadTime = (elapsedTime) => {
+  const elapsed = parseInt(elapsedTime, 10);
+  const time = (0, import_pretty_ms.default)(elapsed);
+  return import_chalk.default.gray(time);
+};
+const formatMessage = (logData) => {
+  const { level, message } = logData;
+  const msg = formatMessageName(message);
+  let pretty;
+  if (level === "error") {
+    pretty = import_chalk.default.red(msg);
+  }
+  if (level === "trace") {
+    pretty = import_chalk.default.white(msg);
+  }
+  if (level === "warn") {
+    const orange = "#ffa500";
+    pretty = import_chalk.default.hex(orange)(msg);
+  }
+  if (level === "debug") {
+    pretty = import_chalk.default.yellow(msg);
+  }
+  if (level === "info" || level === "customlevel") {
+    pretty = import_chalk.default.green(msg);
+  }
+  if (level === "fatal") {
+    pretty = import_chalk.default.white.bgRed(msg);
+  }
+  return pretty;
+};
+const formatMethod = (method) => {
+  return method && import_chalk.default.white(method);
+};
+const formatRequestId = (requestId) => {
+  return requestId && import_chalk.default.cyan(requestId);
+};
+const formatNs = (ns) => {
+  return ns && import_chalk.default.cyan(ns);
+};
+const formatName = (name) => {
+  return name && import_chalk.default.blue(name);
+};
+const formatMessageName = (message) => {
+  if (message === void 0) {
+    return "";
+  }
+  if (message === "request") {
+    return "<--";
+  }
+  if (message === "response") {
+    return "-->";
+  }
+  return message;
+};
+const formatOperationName = (operationName) => {
+  return import_chalk.default.white(NEWLINE + "\u{1F3F7}  " + operationName);
+};
+const formatQuery = (query) => {
+  if (!isEmptyObject(query)) {
+    return import_chalk.default.white(
+      NEWLINE + "\u{1F52D} Query" + NEWLINE + JSON.stringify(query, null, 2)
+    );
+  }
+  return;
+};
+const formatResponseCache = (responseCache) => {
+  if (!isEmptyObject(responseCache)) {
+    return import_chalk.default.white(
+      NEWLINE + "\u{1F4BE} Response Cache" + NEWLINE + JSON.stringify(responseCache, null, 2)
+    );
+  }
+  return;
+};
+const formatStatusCode = (statusCode) => {
+  statusCode = statusCode || "xxx";
+  return import_chalk.default.white(statusCode);
+};
+const formatStack = (stack) => {
+  return import_chalk.default.redBright(
+    stack ? NEWLINE + "\u{1F95E} Error Stack" + NEWLINE + NEWLINE + stack + NEWLINE : ""
+  );
+};
+const formatTracing = (data) => {
+  if (!isEmptyObject(data)) {
+    return import_chalk.default.white(
+      NEWLINE + "\u23F0 Timing" + NEWLINE + JSON.stringify(data, null, 2)
+    );
+  }
+  return;
+};
+const formatUrl = (url) => {
+  return import_chalk.default.white(url);
+};
+const formatUserAgent = (userAgent) => {
+  return import_chalk.default.grey(NEWLINE + "\u{1F575}\uFE0F\u200D\u2640\uFE0F " + userAgent);
+};
+const noEmpty = (value) => {
+  return !!value;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NEWLINE,
+  emojiLog,
+  formatBundleSize,
+  formatCustom,
+  formatData,
+  formatDate,
+  formatErrorProp,
+  formatLevel,
+  formatLoadTime,
+  formatMessage,
+  formatMessageName,
+  formatMethod,
+  formatName,
+  formatNs,
+  formatOperationName,
+  formatQuery,
+  formatRequestId,
+  formatResponseCache,
+  formatStack,
+  formatStatusCode,
+  formatTracing,
+  formatUrl,
+  formatUserAgent,
+  ignoredCustomData,
+  isEmptyObject,
+  isObject,
+  isPinoLog,
+  isWideEmoji,
+  noEmpty
+});

package/dist/logFormatter/index.d.ts

@@ -0,0 +1,2 @@
+export declare const LogFormatter: () => (inputData: string | Record<string, unknown>) => string;
+//# sourceMappingURL=index.d.ts.map

package/dist/logFormatter/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/logFormatter/index.ts"],"names":[],"mappings":"AA8BA,eAAO,MAAM,YAAY,oBACG,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,WA0L3D,CAAA"}

package/dist/logFormatter/index.js

@@ -0,0 +1,184 @@
+"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 __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 logFormatter_exports = {};
+__export(logFormatter_exports, {
+  LogFormatter: () => LogFormatter
+});
+module.exports = __toCommonJS(logFormatter_exports);
+var import_fast_json_parse = __toESM(require("fast-json-parse"));
+var import_formatters = require("./formatters");
+const LogFormatter = () => {
+  const parse = (inputData) => {
+    let logData;
+    if (typeof inputData === "string") {
+      const parsedData = (0, import_fast_json_parse.default)(inputData);
+      if (!parsedData.value || parsedData.err || !(0, import_formatters.isPinoLog)(parsedData.value)) {
+        return inputData + import_formatters.NEWLINE;
+      }
+      logData = parsedData.value;
+    } else if ((0, import_formatters.isObject)(inputData) && (0, import_formatters.isPinoLog)(inputData)) {
+      logData = inputData;
+    } else {
+      return inputData + import_formatters.NEWLINE;
+    }
+    if (!logData.level) {
+      return inputData + import_formatters.NEWLINE;
+    }
+    if (!logData.message) {
+      logData.message = logData.msg;
+    }
+    if (typeof logData.level === "number") {
+      convertLogNumber(logData);
+    }
+    return output(logData) + import_formatters.NEWLINE;
+  };
+  const convertLogNumber = (logData) => {
+    if (logData.level === 10) {
+      logData.level = "trace";
+    }
+    if (logData.level === 20) {
+      logData.level = "debug";
+    }
+    if (logData.level === 30) {
+      logData.level = "info";
+    }
+    if (logData.level === 40) {
+      logData.level = "warn";
+    }
+    if (logData.level === 50) {
+      logData.level = "error";
+    }
+    if (logData.level === 60) {
+      logData.level = "fatal";
+    }
+  };
+  const output = (logData) => {
+    const output2 = [];
+    output2.push((0, import_formatters.formatDate)(logData.time || Date.now()));
+    output2.push((0, import_formatters.formatLevel)(logData.level));
+    output2.push((0, import_formatters.formatNs)(logData.ns));
+    output2.push((0, import_formatters.formatName)(logData.name));
+    output2.push((0, import_formatters.formatRequestId)(logData.requestId));
+    output2.push((0, import_formatters.formatMessage)(logData));
+    const req = logData.req;
+    const res = logData.res;
+    const { statusCode: responseStatusCode } = res || {};
+    const { method: requestMethod, url: requestUrl } = req || {};
+    const {
+      level,
+      message,
+      name,
+      ns,
+      err: logDataErr,
+      stack: logDataStack,
+      statusCode: logDataStatusCode,
+      elapsed,
+      responseTime: logDataResponseTime,
+      method: logDataMethod,
+      custom,
+      contentLength,
+      operationName,
+      query,
+      data: graphQLData,
+      responseCache,
+      tracing,
+      url: logDataUrl,
+      userAgent,
+      ...rest
+    } = logData;
+    const statusCode = responseStatusCode || logDataStatusCode;
+    const responseTime = logDataResponseTime || elapsed;
+    const method = requestMethod || logDataMethod;
+    const url = requestUrl || logDataUrl;
+    const logDataErrStack = logDataErr && logDataErr.stack;
+    const stack = level === "fatal" || level === "error" ? logDataStack || logDataErr && logDataErrStack : null;
+    const err = (level === "fatal" || level === "error") && logDataErr && Object.keys(logDataErr).find((key) => key !== "stack") ? logDataErr : null;
+    if (!message) {
+      logData.message = "";
+    }
+    if (!level) {
+      logData.level = "customlevel";
+    }
+    if (!name) {
+      logData.name = "";
+    }
+    if (!ns) {
+      logData.ns = "";
+    }
+    if (method != null) {
+      output2.push((0, import_formatters.formatMethod)(method));
+      output2.push((0, import_formatters.formatStatusCode)(statusCode));
+    }
+    if (url != null) {
+      output2.push((0, import_formatters.formatUrl)(url));
+    }
+    if (contentLength != null) {
+      output2.push((0, import_formatters.formatBundleSize)(contentLength));
+    }
+    if (custom) {
+      output2.push((0, import_formatters.formatCustom)(custom));
+    }
+    if (responseTime != null) {
+      output2.push((0, import_formatters.formatLoadTime)(responseTime));
+    }
+    if (userAgent != null) {
+      output2.push((0, import_formatters.formatUserAgent)(userAgent));
+    }
+    if (operationName != null) {
+      output2.push((0, import_formatters.formatOperationName)(operationName));
+    }
+    if (query != null) {
+      output2.push((0, import_formatters.formatQuery)(query));
+    }
+    if (graphQLData != null) {
+      output2.push((0, import_formatters.formatData)(graphQLData));
+    }
+    if (responseCache != null) {
+      output2.push((0, import_formatters.formatResponseCache)(responseCache));
+    }
+    if (tracing != null) {
+      output2.push((0, import_formatters.formatTracing)(tracing));
+    }
+    if (err != null) {
+      output2.push((0, import_formatters.formatErrorProp)(err));
+    }
+    if (stack != null) {
+      output2.push((0, import_formatters.formatStack)(stack));
+    }
+    if (rest) {
+      output2.push((0, import_formatters.formatCustom)(rest));
+    }
+    return output2.filter(import_formatters.noEmpty).join(" ");
+  };
+  return parse;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LogFormatter
+});

package/dist/plugins/api.d.ts

@@ -0,0 +1,13 @@
+import type { Options as FastGlobOptions } from 'fast-glob';
+import type { FastifyInstance } from 'fastify';
+import type { Server } from '../createServerHelpers';
+export interface RedwoodFastifyAPIOptions {
+    redwood: {
+        apiRootPath?: string;
+        fastGlobOptions?: FastGlobOptions;
+        loadUserConfig?: boolean;
+        configureServer?: (server: Server) => void | Promise<void>;
+    };
+}
+export declare function redwoodFastifyAPI(fastify: FastifyInstance, opts: RedwoodFastifyAPIOptions): Promise<void>;
+//# sourceMappingURL=api.d.ts.map

package/dist/plugins/api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../../src/plugins/api.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,WAAW,CAAA;AAC3D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAO9C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AAKpD,MAAM,WAAW,wBAAwB;IACvC,OAAO,EAAE;QACP,WAAW,CAAC,EAAE,MAAM,CAAA;QACpB,eAAe,CAAC,EAAE,eAAe,CAAA;QACjC,cAAc,CAAC,EAAE,OAAO,CAAA;QACxB,eAAe,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;KAC3D,CAAA;CACF;AAED,wBAAsB,iBAAiB,CACrC,OAAO,EAAE,eAAe,EACxB,IAAI,EAAE,wBAAwB,iBA2C/B"}

package/dist/plugins/api.js

@@ -0,0 +1,77 @@
+"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 __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 api_exports = {};
+__export(api_exports, {
+  redwoodFastifyAPI: () => redwoodFastifyAPI
+});
+module.exports = __toCommonJS(api_exports);
+var import_url_data = __toESM(require("@fastify/url-data"));
+var import_fastify_raw_body = __toESM(require("fastify-raw-body"));
+var import_store = require("@redmix/context/dist/store");
+var import_helpers = require("@redmix/fastify-web/dist/helpers");
+var import_fastify = require("../fastify");
+var import_lambdaLoader = require("./lambdaLoader");
+async function redwoodFastifyAPI(fastify, opts) {
+  const redwoodOptions = opts.redwood ?? {};
+  redwoodOptions.apiRootPath ??= "/";
+  redwoodOptions.apiRootPath = (0, import_helpers.coerceRootPath)(redwoodOptions.apiRootPath);
+  redwoodOptions.fastGlobOptions ??= {};
+  redwoodOptions.loadUserConfig ??= false;
+  fastify.register(import_url_data.default);
+  await fastify.register(import_fastify_raw_body.default);
+  fastify.addHook("onRequest", (_req, _reply, done) => {
+    (0, import_store.getAsyncStoreInstance)().run(/* @__PURE__ */ new Map(), done);
+  });
+  fastify.addContentTypeParser(
+    ["application/x-www-form-urlencoded", "multipart/form-data"],
+    { parseAs: "string" },
+    fastify.defaultTextParser
+  );
+  if (redwoodOptions.loadUserConfig) {
+    const { configureFastify } = await (0, import_fastify.loadFastifyConfig)();
+    if (configureFastify) {
+      await configureFastify(fastify, {
+        side: "api",
+        apiRootPath: redwoodOptions.apiRootPath
+      });
+    }
+  }
+  if (redwoodOptions.configureServer) {
+    await redwoodOptions.configureServer(fastify);
+  }
+  fastify.all(`${redwoodOptions.apiRootPath}:routeName`, import_lambdaLoader.lambdaRequestHandler);
+  fastify.all(`${redwoodOptions.apiRootPath}:routeName/*`, import_lambdaLoader.lambdaRequestHandler);
+  await (0, import_lambdaLoader.loadFunctionsFromDist)({
+    fastGlobOptions: redwoodOptions.fastGlobOptions
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  redwoodFastifyAPI
+});

package/dist/plugins/graphql.d.ts

@@ -0,0 +1,10 @@
+import type { FastifyInstance } from 'fastify';
+import type { GraphQLYogaOptions } from '@redmix/graphql-server';
+export interface RedwoodFastifyGraphQLOptions {
+    redwood: {
+        apiRootPath?: string;
+        graphql?: GraphQLYogaOptions;
+    };
+}
+export declare function redwoodFastifyGraphQLServer(fastify: FastifyInstance, options: RedwoodFastifyGraphQLOptions): Promise<void>;
+//# sourceMappingURL=graphql.d.ts.map

package/dist/plugins/graphql.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphql.d.ts","sourceRoot":"","sources":["../../src/plugins/graphql.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,eAAe,EAIhB,MAAM,SAAS,CAAA;AAMhB,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAA;AAKhE,MAAM,WAAW,4BAA4B;IAC3C,OAAO,EAAE;QACP,WAAW,CAAC,EAAE,MAAM,CAAA;QACpB,OAAO,CAAC,EAAE,kBAAkB,CAAA;KAC7B,CAAA;CACF;AAED,wBAAsB,2BAA2B,CAC/C,OAAO,EAAE,eAAe,EACxB,OAAO,EAAE,4BAA4B,iBAoGtC"}

package/dist/plugins/graphql.js

@@ -0,0 +1,115 @@
+"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 __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 graphql_exports = {};
+__export(graphql_exports, {
+  redwoodFastifyGraphQLServer: () => redwoodFastifyGraphQLServer
+});
+module.exports = __toCommonJS(graphql_exports);
+var import_multipart = __toESM(require("@fastify/multipart"));
+var import_url_data = __toESM(require("@fastify/url-data"));
+var import_fast_glob = __toESM(require("fast-glob"));
+var import_store = require("@redmix/context/dist/store");
+var import_helpers = require("@redmix/fastify-web/dist/helpers");
+var import_graphql_server = require("@redmix/graphql-server");
+var import_project_config = require("@redmix/project-config");
+var import_awsLambdaFastify = require("../requestHandlers/awsLambdaFastify");
+async function redwoodFastifyGraphQLServer(fastify, options) {
+  const redwoodOptions = options.redwood ?? {};
+  redwoodOptions.apiRootPath ??= "/";
+  redwoodOptions.apiRootPath = (0, import_helpers.coerceRootPath)(redwoodOptions.apiRootPath);
+  fastify.register(import_url_data.default);
+  fastify.register(import_multipart.default);
+  const method = ["GET", "POST", "OPTIONS"];
+  fastify.addHook("onRequest", (_req, _reply, done) => {
+    (0, import_store.getAsyncStoreInstance)().run(/* @__PURE__ */ new Map(), done);
+  });
+  try {
+    if (!redwoodOptions.graphql) {
+      const [graphqlFunctionPath] = await (0, import_fast_glob.default)("dist/functions/graphql.{ts,js}", {
+        cwd: (0, import_project_config.getPaths)().api.base,
+        absolute: true
+      });
+      const { __rw_graphqlOptions } = await import(`file://${graphqlFunctionPath}`);
+      redwoodOptions.graphql = __rw_graphqlOptions;
+    }
+    const graphqlOptions = redwoodOptions.graphql;
+    if (graphqlOptions?.realtime) {
+      const { useRedwoodRealtime } = await import("@redmix/realtime");
+      const originalExtraPlugins = graphqlOptions.extraPlugins ?? [];
+      originalExtraPlugins.push(useRedwoodRealtime(graphqlOptions.realtime));
+      graphqlOptions.extraPlugins = originalExtraPlugins;
+      if (graphqlOptions.realtime.subscriptions) {
+        method.push("PUT");
+      }
+    }
+    const { yoga } = (0, import_graphql_server.createGraphQLYoga)(graphqlOptions);
+    const graphQLYogaHandler = async (req, reply) => {
+      const response = await yoga.handleNodeRequest(req, {
+        req,
+        reply,
+        event: (0, import_awsLambdaFastify.lambdaEventForFastifyRequest)(req),
+        requestContext: {}
+      });
+      for (const [name, value] of response.headers) {
+        reply.header(name, value);
+      }
+      reply.status(response.status);
+      reply.send(response.body);
+      return reply;
+    };
+    const graphqlEndpoint = trimSlashes(yoga.graphqlEndpoint);
+    const routePaths = ["", "/health", "/readiness", "/stream"];
+    for (const routePath of routePaths) {
+      fastify.route({
+        url: `${redwoodOptions.apiRootPath}${graphqlEndpoint}${routePath}`,
+        method,
+        handler: (req, reply) => graphQLYogaHandler(req, reply)
+      });
+    }
+    fastify.addHook("onReady", (done) => {
+      console.info(`GraphQL Yoga Server endpoint at ${graphqlEndpoint}`);
+      console.info(
+        `GraphQL Yoga Server Health Check endpoint at ${graphqlEndpoint}/health`
+      );
+      console.info(
+        `GraphQL Yoga Server Readiness endpoint at ${graphqlEndpoint}/readiness`
+      );
+      done();
+    });
+  } catch (e) {
+    console.log(e);
+  }
+}
+function trimSlashes(path) {
+  return path.replace(/^\/|\/$/g, "");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  redwoodFastifyGraphQLServer
+});