@cedarjs/graphql-server 0.6.1-next.0 → 0.6.1-next.51

package/dist/cjs/cors.d.ts

@@ -0,0 +1,10 @@
+import type { CorsConfig } from '@cedarjs/api';
+export declare const mapRwCorsOptionsToYoga: (rwCorsConfig?: CorsConfig, requestOrigin?: string | null) => false | {
+    origin?: string[] | string;
+    methods?: string[];
+    allowedHeaders?: string[];
+    exposedHeaders?: string[];
+    credentials?: boolean;
+    maxAge?: number;
+};
+//# sourceMappingURL=cors.d.ts.map

package/dist/cjs/cors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cors.d.ts","sourceRoot":"","sources":["../../src/cors.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAE9C,eAAO,MAAM,sBAAsB,kBAClB,UAAU,kBACT,MAAM,GAAG,IAAI;;;;;;;CAoD9B,CAAA"}

package/dist/cjs/cors.js

@@ -0,0 +1,70 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var cors_exports = {};
+__export(cors_exports, {
+  mapRwCorsOptionsToYoga: () => mapRwCorsOptionsToYoga
+});
+module.exports = __toCommonJS(cors_exports);
+const mapRwCorsOptionsToYoga = (rwCorsConfig, requestOrigin) => {
+  const yogaCORSOptions = {};
+  if (!rwCorsConfig) {
+    return false;
+  }
+  if (rwCorsConfig?.methods) {
+    if (typeof rwCorsConfig.methods === "string") {
+      yogaCORSOptions.methods = [rwCorsConfig.methods];
+    } else if (Array.isArray(rwCorsConfig.methods)) {
+      yogaCORSOptions.methods = rwCorsConfig.methods;
+    }
+  }
+  if (rwCorsConfig?.allowedHeaders) {
+    if (typeof rwCorsConfig.allowedHeaders === "string") {
+      yogaCORSOptions.allowedHeaders = [rwCorsConfig.allowedHeaders];
+    } else if (Array.isArray(rwCorsConfig.allowedHeaders)) {
+      yogaCORSOptions.allowedHeaders = rwCorsConfig.allowedHeaders;
+    }
+  }
+  if (rwCorsConfig?.exposedHeaders) {
+    if (typeof rwCorsConfig.exposedHeaders === "string") {
+      yogaCORSOptions.exposedHeaders = [rwCorsConfig.exposedHeaders];
+    } else if (Array.isArray(rwCorsConfig.exposedHeaders)) {
+      yogaCORSOptions.exposedHeaders = rwCorsConfig.exposedHeaders;
+    }
+  }
+  if (rwCorsConfig?.credentials) {
+    yogaCORSOptions.credentials = rwCorsConfig.credentials;
+  }
+  if (rwCorsConfig?.maxAge) {
+    yogaCORSOptions.maxAge = rwCorsConfig.maxAge;
+  }
+  if (rwCorsConfig?.origin) {
+    if (typeof rwCorsConfig.origin === "string") {
+      yogaCORSOptions.origin = [rwCorsConfig.origin];
+    } else if (rwCorsConfig.origin === true) {
+      yogaCORSOptions.origin = [requestOrigin || "*"];
+    } else {
+      yogaCORSOptions.origin = rwCorsConfig.origin;
+    }
+  }
+  return yogaCORSOptions;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  mapRwCorsOptionsToYoga
+});

package/dist/cjs/createGraphQLYoga.d.ts

@@ -0,0 +1,6 @@
+import type { GraphQLYogaOptions } from './types.js';
+export declare const createGraphQLYoga: ({ healthCheckId, loggerConfig, context, getCurrentUser, onException, generateGraphiQLHeader, extraPlugins, authDecoder, cors, services, sdls, directives, armorConfig, allowedOperations, allowIntrospection, allowGraphiQL, defaultError, graphiQLEndpoint, schemaOptions, realtime, trustedDocuments, openTelemetryOptions, includeScalars, }: GraphQLYogaOptions) => {
+    yoga: ServerAdapter<TServerContext, import("graphql-yoga").YogaServer<TServerContext, TUserContext>>;
+    logger: import("@cedarjs/api/logger").Logger;
+};
+//# sourceMappingURL=createGraphQLYoga.d.ts.map

package/dist/cjs/createGraphQLYoga.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createGraphQLYoga.d.ts","sourceRoot":"","sources":["../../src/createGraphQLYoga.ts"],"names":[],"mappings":"AA6BA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAA;AAEpD,eAAO,MAAM,iBAAiB,oVAwB3B,kBAAkB;;;CAmKpB,CAAA"}

package/dist/cjs/createGraphQLYoga.js

@@ -0,0 +1,178 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var createGraphQLYoga_exports = {};
+__export(createGraphQLYoga_exports, {
+  createGraphQLYoga: () => createGraphQLYoga
+});
+module.exports = __toCommonJS(createGraphQLYoga_exports);
+var import_disable_introspection = require("@envelop/disable-introspection");
+var import_filter_operation_type = require("@envelop/filter-operation-type");
+var import_graphql = require("graphql");
+var import_graphql_yoga = require("graphql-yoga");
+var import_cors = require("./cors.js");
+var import_makeDirectives = require("./directives/makeDirectives.js");
+var import_graphiql = require("./graphiql.js");
+var import_introspection = require("./introspection.js");
+var import_makeMergedSchema = require("./makeMergedSchema.js");
+var import_plugins = require("./plugins/index.js");
+var import_makeSubscriptions = require("./subscriptions/makeSubscriptions.js");
+const createGraphQLYoga = ({
+  healthCheckId = "yoga",
+  loggerConfig,
+  context,
+  getCurrentUser,
+  onException,
+  generateGraphiQLHeader,
+  extraPlugins,
+  authDecoder,
+  cors,
+  services,
+  sdls,
+  directives = [],
+  armorConfig,
+  allowedOperations,
+  allowIntrospection,
+  allowGraphiQL,
+  defaultError = "Something went wrong.",
+  graphiQLEndpoint = "/graphql",
+  schemaOptions,
+  realtime,
+  trustedDocuments,
+  openTelemetryOptions,
+  includeScalars
+}) => {
+  let schema;
+  let redwoodDirectivePlugins = [];
+  const logger = loggerConfig.logger;
+  const isDevEnv = process.env.NODE_ENV === "development";
+  try {
+    const projectDirectives = (0, import_makeDirectives.makeDirectivesForPlugin)(directives);
+    if (projectDirectives.length > 0) {
+      ;
+      redwoodDirectivePlugins = projectDirectives.map(
+        (directive) => (0, import_plugins.useRedwoodDirective)(directive)
+      );
+    }
+    let projectSubscriptions = [];
+    if (realtime?.subscriptions?.subscriptions) {
+      projectSubscriptions = (0, import_makeSubscriptions.makeSubscriptions)(
+        realtime.subscriptions.subscriptions
+      );
+    }
+    schema = (0, import_makeMergedSchema.makeMergedSchema)({
+      sdls,
+      services,
+      directives: projectDirectives,
+      subscriptions: projectSubscriptions,
+      schemaOptions,
+      includeScalars
+    });
+  } catch (e) {
+    logger.fatal(e, "\n \u26A0\uFE0F GraphQL server crashed \n");
+    if (onException) {
+      onException();
+    }
+    process.exit(1);
+  }
+  try {
+    const plugins = [];
+    const { disableIntrospection } = (0, import_introspection.configureGraphQLIntrospection)({
+      allowIntrospection
+    });
+    if (disableIntrospection) {
+      plugins.push((0, import_disable_introspection.useDisableIntrospection)());
+    }
+    plugins.push((0, import_plugins.useRedwoodAuthContext)(getCurrentUser, authDecoder));
+    plugins.push((0, import_plugins.useRedwoodGlobalContextSetter)());
+    if (context) {
+      plugins.push((0, import_plugins.useRedwoodPopulateContext)(context));
+    }
+    plugins.push(...redwoodDirectivePlugins);
+    if (openTelemetryOptions !== void 0) {
+      plugins.push((0, import_plugins.useRedwoodOpenTelemetry)(openTelemetryOptions));
+    }
+    plugins.push((0, import_plugins.useArmor)(logger, armorConfig));
+    const defaultAllowedOperations = [
+      import_graphql.OperationTypeNode.QUERY,
+      import_graphql.OperationTypeNode.MUTATION
+    ];
+    if (realtime?.subscriptions?.subscriptions) {
+      defaultAllowedOperations.push(import_graphql.OperationTypeNode.SUBSCRIPTION);
+    }
+    plugins.push(
+      (0, import_filter_operation_type.useFilterAllowedOperations)(allowedOperations || defaultAllowedOperations)
+    );
+    if (trustedDocuments && !trustedDocuments.disabled) {
+      plugins.push((0, import_plugins.useRedwoodTrustedDocuments)(trustedDocuments));
+    }
+    if (extraPlugins && extraPlugins.length > 0) {
+      plugins.push(...extraPlugins);
+    }
+    plugins.push((0, import_plugins.useRedwoodError)(logger));
+    plugins.push(
+      (0, import_graphql_yoga.useReadinessCheck)({
+        endpoint: graphiQLEndpoint + "/readiness",
+        check: async ({ request }) => {
+          try {
+            const response = await yoga.fetch(
+              new URL(graphiQLEndpoint + "/health", request.url)
+            );
+            const status = response.headers.get("x-yoga-id") === healthCheckId && request.headers.get("x-yoga-id") === healthCheckId;
+            return status;
+          } catch (err) {
+            logger.error(err);
+            return false;
+          }
+        }
+      })
+    );
+    plugins.push((0, import_plugins.useRedwoodLogger)(loggerConfig));
+    const yoga = (0, import_graphql_yoga.createYoga)({
+      id: healthCheckId,
+      landingPage: isDevEnv,
+      schema,
+      plugins,
+      maskedErrors: {
+        errorMessage: defaultError,
+        isDev: isDevEnv
+      },
+      logging: logger,
+      healthCheckEndpoint: graphiQLEndpoint + "/health",
+      graphqlEndpoint: graphiQLEndpoint,
+      graphiql: (0, import_graphiql.configureGraphiQLPlayground)({
+        allowGraphiQL,
+        generateGraphiQLHeader
+      }),
+      cors: (request) => {
+        const requestOrigin = request.headers.get("origin");
+        return (0, import_cors.mapRwCorsOptionsToYoga)(cors, requestOrigin);
+      }
+    });
+    return { yoga, logger };
+  } catch (e) {
+    if (onException) {
+      onException();
+    }
+    throw e;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createGraphQLYoga
+});

package/dist/cjs/directives/makeDirectives.d.ts

@@ -0,0 +1,8 @@
+import { type DocumentNode } from 'graphql';
+import type { RedwoodDirective, TransformerDirective, TransformerDirectiveFunc, ValidatorDirective, ValidatorDirectiveFunc } from '../plugins/useRedwoodDirective.js';
+export type DirectiveGlobImports = Record<string, any>;
+export declare const makeDirectivesForPlugin: (directiveGlobs: DirectiveGlobImports) => RedwoodDirective[];
+export declare const getDirectiveName: (schema: DocumentNode) => string | undefined;
+export declare const createValidatorDirective: (schema: DocumentNode, directiveFunc: ValidatorDirectiveFunc) => ValidatorDirective;
+export declare const createTransformerDirective: (schema: DocumentNode, directiveFunc: TransformerDirectiveFunc) => TransformerDirective;
+//# sourceMappingURL=makeDirectives.d.ts.map

package/dist/cjs/directives/makeDirectives.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"makeDirectives.d.ts","sourceRoot":"","sources":["../../../src/directives/makeDirectives.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,KAAK,YAAY,EAAE,MAAM,SAAS,CAAA;AAEjD,OAAO,KAAK,EACV,gBAAgB,EAChB,oBAAoB,EACpB,wBAAwB,EACxB,kBAAkB,EAClB,sBAAsB,EACvB,MAAM,mCAAmC,CAAA;AAW1C,MAAM,MAAM,oBAAoB,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;AAEtD,eAAO,MAAM,uBAAuB,mBAClB,oBAAoB,KACnC,gBAAgB,EAwBlB,CAAA;AAED,eAAO,MAAM,gBAAgB,WAAY,YAAY,uBAMpD,CAAA;AAED,eAAO,MAAM,wBAAwB,WAC3B,YAAY,iBACL,sBAAsB,KACpC,kBAmBF,CAAA;AAED,eAAO,MAAM,0BAA0B,WAC7B,YAAY,iBACL,wBAAwB,KACtC,oBAmBF,CAAA"}

package/dist/cjs/directives/makeDirectives.js

@@ -0,0 +1,89 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var makeDirectives_exports = {};
+__export(makeDirectives_exports, {
+  createTransformerDirective: () => createTransformerDirective,
+  createValidatorDirective: () => createValidatorDirective,
+  getDirectiveName: () => getDirectiveName,
+  makeDirectivesForPlugin: () => makeDirectivesForPlugin
+});
+module.exports = __toCommonJS(makeDirectives_exports);
+var import_graphql = require("graphql");
+var import_useRedwoodDirective = require("../plugins/useRedwoodDirective.js");
+const makeDirectivesForPlugin = (directiveGlobs) => {
+  return Object.entries(directiveGlobs).flatMap(
+    ([importedGlobName, exports2]) => {
+      const [directiveNameFromFile] = importedGlobName.split("_").slice(-2);
+      const directive = exports2[directiveNameFromFile] || exports2.default;
+      if (!directive.type) {
+        throw new Error(
+          "Please use `createValidatorDirective` or `createTransformerDirective` functions to define your directive"
+        );
+      }
+      return [directive];
+    }
+  );
+};
+const getDirectiveName = (schema) => {
+  const definition = schema.definitions.find(
+    (definition2) => definition2.kind === import_graphql.Kind.DIRECTIVE_DEFINITION
+  );
+  return definition?.name?.value;
+};
+const createValidatorDirective = (schema, directiveFunc) => {
+  const directiveName = getDirectiveName(schema);
+  if (!directiveName) {
+    throw new Error("Could not parse directive schema");
+  }
+  if (typeof directiveFunc !== "function") {
+    throw new Error(
+      `Directive validation function not implemented for @${directiveName}`
+    );
+  }
+  return {
+    name: directiveName,
+    schema,
+    onResolvedValue: directiveFunc,
+    type: import_useRedwoodDirective.DirectiveType.VALIDATOR
+  };
+};
+const createTransformerDirective = (schema, directiveFunc) => {
+  const directiveName = getDirectiveName(schema);
+  if (!directiveName) {
+    throw new Error("Could not parse directive schema");
+  }
+  if (typeof directiveFunc !== "function") {
+    throw new Error(
+      `Directive transformer function not implemented for @${directiveName}`
+    );
+  }
+  return {
+    name: directiveName,
+    schema,
+    onResolvedValue: directiveFunc,
+    type: import_useRedwoodDirective.DirectiveType.TRANSFORMER
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createTransformerDirective,
+  createValidatorDirective,
+  getDirectiveName,
+  makeDirectivesForPlugin
+});

package/dist/cjs/errors.d.ts

@@ -0,0 +1,28 @@
+import { GraphQLError } from 'graphql';
+export declare class RedwoodGraphQLError extends GraphQLError {
+    constructor(message: string, extensions?: Record<string, any>, originalError?: Error & {
+        readonly extensions?: unknown;
+    });
+}
+export declare class SyntaxError extends RedwoodGraphQLError {
+    constructor(message: string);
+}
+export declare class ValidationError extends RedwoodGraphQLError {
+    constructor(message: string);
+}
+export declare class AuthenticationError extends RedwoodGraphQLError {
+    constructor(message: string);
+}
+export declare class ForbiddenError extends RedwoodGraphQLError {
+    constructor(message: string);
+}
+export declare class PersistedQueryNotFoundError extends RedwoodGraphQLError {
+    constructor();
+}
+export declare class PersistedQueryNotSupportedError extends RedwoodGraphQLError {
+    constructor();
+}
+export declare class UserInputError extends RedwoodGraphQLError {
+    constructor(message: string, properties?: Record<string, any>);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/cjs/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/errors.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAEtC,qBAAa,mBAAoB,SAAQ,YAAY;gBAEjD,OAAO,EAAE,MAAM,EACf,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAChC,aAAa,CAAC,EAAE,KAAK,GAAG;QACtB,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAA;KAC9B;CAYJ;AAED,qBAAa,WAAY,SAAQ,mBAAmB;gBACtC,OAAO,EAAE,MAAM;CAK5B;AAED,qBAAa,eAAgB,SAAQ,mBAAmB;gBAC1C,OAAO,EAAE,MAAM;CAK5B;AAED,qBAAa,mBAAoB,SAAQ,mBAAmB;gBAC9C,OAAO,EAAE,MAAM;CAK5B;AAED,qBAAa,cAAe,SAAQ,mBAAmB;gBACzC,OAAO,EAAE,MAAM;CAK5B;AAED,qBAAa,2BAA4B,SAAQ,mBAAmB;;CAMnE;AAED,qBAAa,+BAAgC,SAAQ,mBAAmB;;CAQvE;AAED,qBAAa,cAAe,SAAQ,mBAAmB;gBACzC,OAAO,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;CAK9D"}

package/dist/cjs/errors.js

@@ -0,0 +1,98 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var errors_exports = {};
+__export(errors_exports, {
+  AuthenticationError: () => AuthenticationError,
+  ForbiddenError: () => ForbiddenError,
+  PersistedQueryNotFoundError: () => PersistedQueryNotFoundError,
+  PersistedQueryNotSupportedError: () => PersistedQueryNotSupportedError,
+  RedwoodGraphQLError: () => RedwoodGraphQLError,
+  SyntaxError: () => SyntaxError,
+  UserInputError: () => UserInputError,
+  ValidationError: () => ValidationError
+});
+module.exports = __toCommonJS(errors_exports);
+var import_graphql = require("graphql");
+class RedwoodGraphQLError extends import_graphql.GraphQLError {
+  constructor(message, extensions, originalError) {
+    super(message, {
+      extensions: {
+        ...extensions,
+        code: extensions?.code || "REDWOODJS_ERROR"
+      },
+      originalError
+    });
+    Object.setPrototypeOf(this, import_graphql.GraphQLError.prototype);
+  }
+}
+class SyntaxError extends RedwoodGraphQLError {
+  constructor(message) {
+    super(message, { code: "GRAPHQL_PARSE_FAILED" });
+    Object.setPrototypeOf(this, SyntaxError.prototype);
+  }
+}
+class ValidationError extends RedwoodGraphQLError {
+  constructor(message) {
+    super(message, { code: "GRAPHQL_VALIDATION_FAILED" });
+    Object.setPrototypeOf(this, ValidationError.prototype);
+  }
+}
+class AuthenticationError extends RedwoodGraphQLError {
+  constructor(message) {
+    super(message, { code: "UNAUTHENTICATED" });
+    Object.setPrototypeOf(this, AuthenticationError.prototype);
+  }
+}
+class ForbiddenError extends RedwoodGraphQLError {
+  constructor(message) {
+    super(message, { code: "FORBIDDEN" });
+    Object.setPrototypeOf(this, ForbiddenError.prototype);
+  }
+}
+class PersistedQueryNotFoundError extends RedwoodGraphQLError {
+  constructor() {
+    super("PersistedQueryNotFound", { code: "PERSISTED_QUERY_NOT_FOUND" });
+    Object.setPrototypeOf(this, PersistedQueryNotFoundError.prototype);
+  }
+}
+class PersistedQueryNotSupportedError extends RedwoodGraphQLError {
+  constructor() {
+    super("PersistedQueryNotSupported", {
+      code: "PERSISTED_QUERY_NOT_SUPPORTED"
+    });
+    Object.setPrototypeOf(this, PersistedQueryNotSupportedError.prototype);
+  }
+}
+class UserInputError extends RedwoodGraphQLError {
+  constructor(message, properties) {
+    super(message, { code: "BAD_USER_INPUT", properties });
+    Object.setPrototypeOf(this, UserInputError.prototype);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AuthenticationError,
+  ForbiddenError,
+  PersistedQueryNotFoundError,
+  PersistedQueryNotSupportedError,
+  RedwoodGraphQLError,
+  SyntaxError,
+  UserInputError,
+  ValidationError
+});

package/dist/cjs/functions/graphql.d.ts

@@ -0,0 +1,15 @@
+import type { APIGatewayProxyEvent, Context as LambdaContext } from 'aws-lambda';
+import type { GraphQLHandlerOptions } from '../types.js';
+/**
+ * Creates an Enveloped GraphQL Server, configured with default Redwood plugins
+ *
+ * You can add your own plugins by passing them to the extraPlugins object
+ *
+ * @see https://www.envelop.dev/ for information about envelop
+ * @see https://www.envelop.dev/plugins for available envelop plugins
+ * ```js
+ * export const handler = createGraphQLHandler({ schema, context, getCurrentUser })
+ * ```
+ */
+export declare const createGraphQLHandler: ({ healthCheckId, loggerConfig, context, getCurrentUser, onException, generateGraphiQLHeader, extraPlugins, authDecoder, cors, services, sdls, directives, armorConfig, allowedOperations, allowIntrospection, allowGraphiQL, defaultError, graphiQLEndpoint, schemaOptions, openTelemetryOptions, trustedDocuments, }: GraphQLHandlerOptions) => (event: APIGatewayProxyEvent, context: LambdaContext) => Promise<any>;
+//# sourceMappingURL=graphql.d.ts.map

package/dist/cjs/functions/graphql.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphql.d.ts","sourceRoot":"","sources":["../../../src/functions/graphql.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,oBAAoB,EAEpB,OAAO,IAAI,aAAa,EACzB,MAAM,YAAY,CAAA;AAMnB,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAA;AAExD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,oBAAoB,0TAsB9B,qBAAqB,aA+Gb,oBAAoB,WAClB,aAAa,KACrB,OAAO,CAAC,GAAG,CAcf,CAAA"}

package/dist/cjs/functions/graphql.js

@@ -0,0 +1,141 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var graphql_exports = {};
+__export(graphql_exports, {
+  createGraphQLHandler: () => createGraphQLHandler
+});
+module.exports = __toCommonJS(graphql_exports);
+var import_store = require("@cedarjs/context/dist/store");
+var import_createGraphQLYoga = require("../createGraphQLYoga.js");
+const createGraphQLHandler = ({
+  healthCheckId,
+  loggerConfig,
+  context,
+  getCurrentUser,
+  onException,
+  generateGraphiQLHeader,
+  extraPlugins,
+  authDecoder,
+  cors,
+  services,
+  sdls,
+  directives = [],
+  armorConfig,
+  allowedOperations,
+  allowIntrospection,
+  allowGraphiQL,
+  defaultError = "Something went wrong.",
+  graphiQLEndpoint = "/graphql",
+  schemaOptions,
+  openTelemetryOptions,
+  trustedDocuments
+}) => {
+  const { yoga, logger } = (0, import_createGraphQLYoga.createGraphQLYoga)({
+    healthCheckId,
+    loggerConfig,
+    context,
+    getCurrentUser,
+    onException,
+    generateGraphiQLHeader,
+    extraPlugins,
+    authDecoder,
+    cors,
+    services,
+    sdls,
+    directives,
+    armorConfig,
+    allowedOperations,
+    allowIntrospection,
+    allowGraphiQL,
+    defaultError,
+    graphiQLEndpoint,
+    schemaOptions,
+    openTelemetryOptions,
+    trustedDocuments
+  });
+  const handlerFn = async (event, requestContext) => {
+    requestContext.callbackWaitsForEmptyEventLoop = false;
+    let lambdaResponse;
+    try {
+      const [, rest = ""] = event.path.split(graphiQLEndpoint);
+      const url = new URL(graphiQLEndpoint + rest, "http://localhost");
+      if (event.queryStringParameters != null) {
+        for (const queryName in event.queryStringParameters) {
+          const queryValue = event.queryStringParameters[queryName];
+          if (queryValue != null) {
+            url.searchParams.set(queryName, queryValue);
+          }
+        }
+      }
+      const response = await yoga.fetch(
+        url,
+        {
+          method: event.httpMethod,
+          headers: event.headers,
+          body: event.body ? Buffer.from(event.body, event.isBase64Encoded ? "base64" : "utf8") : void 0
+        },
+        {
+          event,
+          requestContext
+        }
+      );
+      const responseHeaders = {};
+      response.headers.forEach((value, name) => {
+        responseHeaders[name] = value;
+      });
+      lambdaResponse = {
+        body: await response.text(),
+        statusCode: response.status,
+        headers: responseHeaders,
+        isBase64Encoded: false
+      };
+    } catch (e) {
+      logger.error(e);
+      if (onException) {
+        onException();
+      }
+      lambdaResponse = {
+        body: JSON.stringify({ error: "GraphQL execution failed" }),
+        statusCode: 200
+        // should be 500
+      };
+    }
+    if (!lambdaResponse.headers) {
+      lambdaResponse.headers = {};
+    }
+    return lambdaResponse;
+  };
+  return (event, context2) => {
+    const execFn = async () => {
+      try {
+        return await handlerFn(event, context2);
+      } catch (e) {
+        if (onException) {
+          onException();
+        }
+        throw e;
+      }
+    };
+    return (0, import_store.getAsyncStoreInstance)().run(/* @__PURE__ */ new Map(), execFn);
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createGraphQLHandler
+});

package/dist/cjs/functions/useRequireAuth.d.ts

@@ -0,0 +1,12 @@
+import type { APIGatewayEvent, Context as LambdaContext } from 'aws-lambda';
+import type { Decoder } from '@cedarjs/api';
+import type { GetCurrentUser } from '../types.js';
+interface Args {
+    authDecoder?: Decoder | Decoder[];
+    handlerFn: (event: APIGatewayEvent, context: LambdaContext, ...others: any) => any;
+    getCurrentUser?: GetCurrentUser;
+}
+export type UseRequireAuth = (args: Args) => (event: APIGatewayEvent, context: LambdaContext, ...rest: any) => Promise<ReturnType<Args['handlerFn']>>;
+export declare const useRequireAuth: UseRequireAuth;
+export {};
+//# sourceMappingURL=useRequireAuth.d.ts.map