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

package/dist/cjs/makeMergedSchema.js

@@ -0,0 +1,283 @@
+"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 makeMergedSchema_exports = {};
+__export(makeMergedSchema_exports, {
+  makeMergedSchema: () => makeMergedSchema
+});
+module.exports = __toCommonJS(makeMergedSchema_exports);
+var import_merge = require("@graphql-tools/merge");
+var import_schema = require("@graphql-tools/schema");
+var opentelemetry = __toESM(require("@opentelemetry/api"), 1);
+var import_lodash = __toESM(require("lodash"), 1);
+var rootGqlSchema = __toESM(require("./rootSchema.js"), 1);
+const { merge, omitBy } = import_lodash.default;
+const wrapWithOpenTelemetry = async (func, args, root, context, info, name) => {
+  const tracer = opentelemetry.trace.getTracer("redwoodjs");
+  const parentSpan = context !== null && context["OPEN_TELEMETRY_GRAPHQL"];
+  const parentContext = parentSpan ? opentelemetry.trace.setSpan(opentelemetry.context.active(), parentSpan) : opentelemetry.context.active();
+  return await tracer.startActiveSpan(
+    `redwoodjs:graphql:resolver:${name}`,
+    {},
+    parentContext,
+    async (span) => {
+      span.setAttribute(
+        "graphql.execute.operationName",
+        `${args.operationName || "Anonymous Operation"}`
+      );
+      try {
+        const result = await func(args, {
+          root,
+          context,
+          info
+        });
+        span.end();
+        return result;
+      } catch (ex) {
+        span.recordException(ex);
+        span.setStatus({ code: opentelemetry.SpanStatusCode.ERROR });
+        span.end();
+        throw ex;
+      }
+    }
+  );
+};
+const mapFieldsToService = ({
+  fields = {},
+  resolvers: unmappedResolvers,
+  services
+}) => Object.keys(fields).reduce((resolvers, name) => {
+  if (resolvers?.[name]) {
+    return resolvers;
+  }
+  if (services?.[name]) {
+    return {
+      ...resolvers,
+      // Map the arguments from GraphQL to an ordinary function a service would
+      // expect.
+      [name]: async (root, args, context, info) => {
+        const captureResolvers = (
+          // @ts-expect-error context is unknown
+          context && context["OPEN_TELEMETRY_GRAPHQL"] !== void 0
+        );
+        if (captureResolvers) {
+          return wrapWithOpenTelemetry(
+            services[name],
+            args,
+            root,
+            context,
+            info,
+            name
+          );
+        }
+        return services[name](args, { root, context, info });
+      }
+    };
+  }
+  return resolvers;
+}, unmappedResolvers);
+const resolveUnionType = (types) => ({
+  __resolveType(obj) {
+    if (Object.hasOwn(obj, "__typename")) {
+      for (const type of types) {
+        if (type.name === obj["__typename"]) {
+          return type.name;
+        }
+      }
+    }
+    const fieldIntersections = new Array(types.length).fill(0);
+    let maxIntersectionFields = 0;
+    let maxIntersectionType;
+    let maxIntersectionIdx = 0;
+    for (let i = 0; i < types.length; i++) {
+      const type = types[i];
+      const fieldIntersection = Object.keys(type.getFields()).filter(
+        (field) => field in obj
+      );
+      fieldIntersections[i] = fieldIntersection.length;
+      if (fieldIntersection.length > maxIntersectionFields) {
+        maxIntersectionFields = fieldIntersection.length;
+        maxIntersectionType = type;
+        maxIntersectionIdx = i;
+      }
+    }
+    if (fieldIntersections.includes(maxIntersectionFields, maxIntersectionIdx + 1)) {
+      throw Error(
+        "Unable to resolve correct type for union. Try adding unique fields to each type or __typename to each resolver"
+      );
+    }
+    return maxIntersectionType?.name ?? null;
+  }
+});
+const mergeResolversWithServices = ({
+  schema,
+  resolvers,
+  services
+}) => {
+  const mergedServices = merge(
+    {},
+    ...Object.keys(services).map((name) => services[name])
+  );
+  const typesWithFields = Object.keys(schema.getTypeMap()).filter((name) => !name.startsWith("_")).filter(
+    (name) => typeof schema.getType(name).getFields !== "undefined"
+  ).map((name) => {
+    return schema.getType(name);
+  }).filter(
+    (type) => type !== void 0 && type !== null
+  );
+  const unionTypes = Object.keys(schema.getTypeMap()).filter(
+    (name) => typeof schema.getType(name).getTypes !== "undefined"
+  ).map((name) => {
+    return schema.getType(name);
+  }).filter(
+    (type) => type !== void 0 && type !== null
+  );
+  const mappedResolvers = typesWithFields.reduce((acc, type) => {
+    let servicesForType = mergedServices;
+    if (!["Query", "Mutation", "Subscription"].includes(type.name)) {
+      servicesForType = mergedServices?.[type.name];
+    }
+    return {
+      ...acc,
+      [type.name]: mapFieldsToService({
+        fields: type.getFields(),
+        resolvers: resolvers?.[type.name],
+        services: servicesForType
+      })
+    };
+  }, {});
+  const mappedUnionResolvers = unionTypes.reduce((acc, type) => {
+    return {
+      ...acc,
+      [type.name]: resolveUnionType(type.getTypes())
+    };
+  }, {});
+  return omitBy(
+    {
+      ...resolvers,
+      ...mappedResolvers,
+      ...mappedUnionResolvers
+    },
+    (v) => typeof v === "undefined"
+  );
+};
+const mergeResolvers = (schemas) => omitBy(
+  merge(
+    {},
+    ...[
+      rootGqlSchema.resolvers,
+      ...Object.values(schemas).map(({ resolvers }) => resolvers)
+    ]
+  ),
+  (v) => typeof v === "undefined"
+);
+const mergeTypes = (types, options) => {
+  const schemaDefinition = options && typeof options.schemaDefinition === "boolean" ? options.schemaDefinition : true;
+  return (0, import_merge.mergeTypeDefs)(types, {
+    useSchemaDefinition: schemaDefinition,
+    forceSchemaDefinition: schemaDefinition,
+    throwOnConflict: true,
+    commentDescriptions: true,
+    reverseDirectives: true,
+    ...options
+  });
+};
+const mergeResolversWithSubscriptions = ({
+  schema,
+  subscriptions,
+  resolverValidationOptions,
+  inheritResolversFromInterfaces
+}) => {
+  if (subscriptions && subscriptions.length > 0) {
+    const subscriptionResolvers = { Subscription: {} };
+    subscriptions?.forEach((subscription) => {
+      subscriptionResolvers["Subscription"] = {
+        ...subscriptionResolvers["Subscription"],
+        ...subscription.resolvers
+      };
+    });
+    return (0, import_schema.addResolversToSchema)({
+      schema,
+      resolvers: subscriptionResolvers,
+      resolverValidationOptions,
+      inheritResolversFromInterfaces
+    });
+  }
+  return schema;
+};
+const makeMergedSchema = ({
+  sdls,
+  services,
+  schemaOptions = {},
+  directives,
+  subscriptions = [],
+  includeScalars
+}) => {
+  const sdlSchemas = Object.values(sdls).map(({ schema: schema2 }) => schema2);
+  const rootEntries = [rootGqlSchema.schema];
+  if (includeScalars?.File !== false) {
+    rootEntries.push(rootGqlSchema.scalarSchemas.File);
+  }
+  const typeDefs = mergeTypes(
+    [
+      ...rootEntries,
+      ...directives.map((directive) => directive.schema),
+      // pick out schemas from directives
+      ...subscriptions.map((subscription) => subscription.schema),
+      // pick out schemas from subscriptions
+      ...sdlSchemas
+      // pick out the schemas from sdls
+    ],
+    { all: true }
+  );
+  const { typeDefs: schemaOptionsTypeDefs = [], ...otherSchemaOptions } = schemaOptions;
+  const schema = (0, import_schema.makeExecutableSchema)({
+    typeDefs: [typeDefs, schemaOptionsTypeDefs],
+    ...otherSchemaOptions
+  });
+  const resolvers = mergeResolversWithServices({
+    schema,
+    resolvers: mergeResolvers(sdls),
+    services
+  });
+  const schemaWithSubscriptions = mergeResolversWithSubscriptions({
+    schema,
+    subscriptions
+  });
+  const { resolverValidationOptions, inheritResolversFromInterfaces } = schemaOptions || {};
+  return (0, import_schema.addResolversToSchema)({
+    schema: schemaWithSubscriptions,
+    resolvers,
+    resolverValidationOptions,
+    inheritResolversFromInterfaces
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  makeMergedSchema
+});

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/dist/cjs/plugins/index.d.ts

@@ -0,0 +1,10 @@
+export { useArmor } from './useArmor.js';
+export { useRedwoodAuthContext } from './useRedwoodAuthContext.js';
+export { useRedwoodDirective } from './useRedwoodDirective.js';
+export { useRedwoodError } from './useRedwoodError.js';
+export { useRedwoodGlobalContextSetter } from './useRedwoodGlobalContextSetter.js';
+export { useRedwoodLogger } from './useRedwoodLogger.js';
+export { useRedwoodTrustedDocuments } from './useRedwoodTrustedDocuments.js';
+export { useRedwoodPopulateContext } from './useRedwoodPopulateContext.js';
+export { useRedwoodOpenTelemetry } from './useRedwoodOpenTelemetry.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/plugins/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AACxC,OAAO,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAA;AAClE,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAA;AAC9D,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAA;AACtD,OAAO,EAAE,6BAA6B,EAAE,MAAM,oCAAoC,CAAA;AAClF,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAA;AACxD,OAAO,EAAE,0BAA0B,EAAE,MAAM,iCAAiC,CAAA;AAE5E,OAAO,EAAE,yBAAyB,EAAE,MAAM,gCAAgC,CAAA;AAC1E,OAAO,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAA"}

package/dist/cjs/plugins/index.js

@@ -0,0 +1,52 @@
+"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 plugins_exports = {};
+__export(plugins_exports, {
+  useArmor: () => import_useArmor.useArmor,
+  useRedwoodAuthContext: () => import_useRedwoodAuthContext.useRedwoodAuthContext,
+  useRedwoodDirective: () => import_useRedwoodDirective.useRedwoodDirective,
+  useRedwoodError: () => import_useRedwoodError.useRedwoodError,
+  useRedwoodGlobalContextSetter: () => import_useRedwoodGlobalContextSetter.useRedwoodGlobalContextSetter,
+  useRedwoodLogger: () => import_useRedwoodLogger.useRedwoodLogger,
+  useRedwoodOpenTelemetry: () => import_useRedwoodOpenTelemetry.useRedwoodOpenTelemetry,
+  useRedwoodPopulateContext: () => import_useRedwoodPopulateContext.useRedwoodPopulateContext,
+  useRedwoodTrustedDocuments: () => import_useRedwoodTrustedDocuments.useRedwoodTrustedDocuments
+});
+module.exports = __toCommonJS(plugins_exports);
+var import_useArmor = require("./useArmor.js");
+var import_useRedwoodAuthContext = require("./useRedwoodAuthContext.js");
+var import_useRedwoodDirective = require("./useRedwoodDirective.js");
+var import_useRedwoodError = require("./useRedwoodError.js");
+var import_useRedwoodGlobalContextSetter = require("./useRedwoodGlobalContextSetter.js");
+var import_useRedwoodLogger = require("./useRedwoodLogger.js");
+var import_useRedwoodTrustedDocuments = require("./useRedwoodTrustedDocuments.js");
+var import_useRedwoodPopulateContext = require("./useRedwoodPopulateContext.js");
+var import_useRedwoodOpenTelemetry = require("./useRedwoodOpenTelemetry.js");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useArmor,
+  useRedwoodAuthContext,
+  useRedwoodDirective,
+  useRedwoodError,
+  useRedwoodGlobalContextSetter,
+  useRedwoodLogger,
+  useRedwoodOpenTelemetry,
+  useRedwoodPopulateContext,
+  useRedwoodTrustedDocuments
+});

package/dist/cjs/plugins/useArmor.d.ts

@@ -0,0 +1,4 @@
+import type { Logger } from '@cedarjs/api/logger';
+import type { ArmorConfig } from '../types.js';
+export declare const useArmor: (logger: Logger, config?: ArmorConfig) => import("@envelop/types").Plugin<{}>;
+//# sourceMappingURL=useArmor.d.ts.map

package/dist/cjs/plugins/useArmor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useArmor.d.ts","sourceRoot":"","sources":["../../../src/plugins/useArmor.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAA;AAEjD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AAO9C,eAAO,MAAM,QAAQ,WAAY,MAAM,WAAW,WAAW,wCAsC5D,CAAA"}

package/dist/cjs/plugins/useArmor.js

@@ -0,0 +1,69 @@
+"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 useArmor_exports = {};
+__export(useArmor_exports, {
+  useArmor: () => useArmor
+});
+module.exports = __toCommonJS(useArmor_exports);
+var import_graphql_armor = require("@escape.tech/graphql-armor");
+const armorConfigDefaultOptions = {
+  logContext: false,
+  logErrors: true
+};
+const useArmor = (logger, config) => {
+  const logRejection = (ctx, error) => {
+    if (config?.logContext ?? armorConfigDefaultOptions.logContext) {
+      if (ctx) {
+        logger.debug({ custom: ctx }, `Armor rejection context`);
+      }
+    }
+    if (config?.logErrors ?? armorConfigDefaultOptions.logErrors) {
+      logger.error(error, `Armor rejected request: ${error.message}`);
+    }
+  };
+  return (0, import_graphql_armor.EnvelopArmorPlugin)({
+    ...config,
+    costLimit: {
+      ...config?.costLimit,
+      onReject: [logRejection]
+    },
+    maxAliases: {
+      allowList: [],
+      ...config?.maxAliases,
+      onReject: [logRejection]
+    },
+    maxDepth: {
+      ...config?.maxDepth,
+      flattenFragments: true,
+      onReject: [logRejection]
+    },
+    maxDirectives: {
+      ...config?.maxDirectives,
+      onReject: [logRejection]
+    },
+    maxTokens: {
+      ...config?.maxTokens,
+      onReject: [logRejection]
+    }
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useArmor
+});

package/dist/cjs/plugins/useRedwoodAuthContext.d.ts

@@ -0,0 +1,9 @@
+import type { Plugin } from 'graphql-yoga';
+import type { Decoder } from '@cedarjs/api';
+import type { RedwoodGraphQLContext, GraphQLHandlerOptions } from '../types.js';
+/**
+ * Envelop plugin for injecting the current user into the GraphQL Context,
+ * based on custom getCurrentUser function.
+ */
+export declare const useRedwoodAuthContext: (getCurrentUser: GraphQLHandlerOptions["getCurrentUser"], authDecoder?: Decoder | Decoder[]) => Plugin<RedwoodGraphQLContext>;
+//# sourceMappingURL=useRedwoodAuthContext.d.ts.map

package/dist/cjs/plugins/useRedwoodAuthContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRedwoodAuthContext.d.ts","sourceRoot":"","sources":["../../../src/plugins/useRedwoodAuthContext.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAA;AAE1C,OAAO,KAAK,EAAsB,OAAO,EAAE,MAAM,cAAc,CAAA;AAG/D,OAAO,KAAK,EAAE,qBAAqB,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAA;AAE/E;;;GAGG;AACH,eAAO,MAAM,qBAAqB,mBAChB,qBAAqB,CAAC,gBAAgB,CAAC,gBACzC,OAAO,GAAG,OAAO,EAAE,KAChC,MAAM,CAAC,qBAAqB,CAsC9B,CAAA"}

package/dist/cjs/plugins/useRedwoodAuthContext.js

@@ -0,0 +1,61 @@
+"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 useRedwoodAuthContext_exports = {};
+__export(useRedwoodAuthContext_exports, {
+  useRedwoodAuthContext: () => useRedwoodAuthContext
+});
+module.exports = __toCommonJS(useRedwoodAuthContext_exports);
+var import_api = require("@cedarjs/api");
+const useRedwoodAuthContext = (getCurrentUser, authDecoder) => {
+  return {
+    async onContextBuilding({ context, extendContext }) {
+      const { requestContext } = context;
+      let authContext = void 0;
+      try {
+        authContext = await (0, import_api.getAuthenticationContext)({
+          authDecoder,
+          event: context.event,
+          context: requestContext
+        });
+      } catch (error) {
+        throw new Error(
+          `Exception in getAuthenticationContext: ${error.message}`
+        );
+      }
+      try {
+        if (authContext) {
+          const currentUser = getCurrentUser ? await getCurrentUser(
+            authContext[0],
+            authContext[1],
+            authContext[2]
+          ) : null;
+          if (currentUser) {
+            extendContext({ currentUser });
+          }
+        }
+      } catch (error) {
+        throw new Error(`Exception in getCurrentUser: ${error.message}`);
+      }
+    }
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useRedwoodAuthContext
+});

package/dist/cjs/plugins/useRedwoodDirective.d.ts

@@ -0,0 +1,83 @@
+import type { DirectiveNode, DocumentNode, GraphQLFieldConfig, GraphQLResolveInfo } from 'graphql';
+import type { Plugin } from 'graphql-yoga';
+import type { GlobalContext } from '@cedarjs/context';
+export interface DirectiveParams<FieldType = any, DirectiveArgs = Record<string, any>> {
+    root: unknown;
+    args: Record<string, unknown>;
+    context: GlobalContext;
+    info: GraphQLResolveInfo;
+    directiveNode?: DirectiveNode;
+    directiveArgs: DirectiveArgs;
+    resolvedValue: FieldType;
+}
+/**
+ * Generic Type for the arguments/parameters passed to the validate function for validator directives
+ *
+ * You have to pass in the type of directiveArgs
+ * @example ValidateArgs<{ roles?: string[] }>
+ */
+export declare type ValidateArgs<DirectiveArgs = Record<string, any>> = Omit<DirectiveParams<never, DirectiveArgs>, // we remove resolvedValue anyway in this type
+'resolvedValue'>;
+/**
+ * Write your validation logic inside this function.
+ * Validator directives do not have access to the field value, i.e. they are called before resolving the value
+ *
+ * - Throw an error, if you want to stop executing e.g. not sufficient permissions
+ * - Validator directives can be async or sync
+ * - Returned value will be ignored
+ *
+ * You have to pass in the type of directiveArgs
+ * @example ValidatorDirectiveFunc<{ roles?: string[] }>
+ *
+ */
+export type ValidatorDirectiveFunc<TDirectiveArgs = Record<string, any>> = (args: ValidateArgs<TDirectiveArgs>) => Promise<void> | void;
+/**
+ * Generic Type for the arguments/parameters passed to the transform function for transformer directives
+ *
+ * You have to pass in the type of directiveArgs, and the resolverValue (i.e. the type of the field you are transforming)
+ * @example TransformArgs<Post, { allowedRoles: string[] }>
+ */
+export declare type TransformArgs<TField = any, TDirectiveArgs = Record<string, any>> = DirectiveParams<TField, TDirectiveArgs>;
+/**
+ * Write your transformation logic inside this function.
+ * Transformer directives run **after** resolving the value
+ *
+ * - You can also throw an error, if you want to stop executing, but note that the value has already been resolved
+ * - Transformer directives **must** be synchronous, and return a value
+ *
+ * You have to pass in the type of directiveArgs, and the resolverValue (i.e. the type of the field you are transforming)
+ * @example TransformerDirectiveFunc<Post, { allowedRoles: string[] }>
+ *
+ */
+export type TransformerDirectiveFunc<TField = any, TDirectiveArgs = Record<string, any>> = (args: TransformArgs<TField, TDirectiveArgs>) => TField;
+export declare enum DirectiveType {
+    VALIDATOR = "VALIDATOR_DIRECTIVE",
+    TRANSFORMER = "TRANSFORMER_DIRECTIVE"
+}
+export type RedwoodDirective = ValidatorDirective | TransformerDirective;
+export interface ValidatorDirective extends ValidatorDirectiveOptions {
+    schema: DocumentNode;
+}
+export interface TransformerDirective extends TransformerDirectiveOptions {
+    schema: DocumentNode;
+}
+interface ValidatorDirectiveOptions {
+    onResolvedValue: ValidatorDirectiveFunc;
+    type: DirectiveType.VALIDATOR;
+    name: string;
+}
+interface TransformerDirectiveOptions {
+    onResolvedValue: TransformerDirectiveFunc;
+    type: DirectiveType.TRANSFORMER;
+    name: string;
+}
+export type DirectivePluginOptions = ValidatorDirectiveOptions | TransformerDirectiveOptions;
+export declare function hasDirective(info: GraphQLResolveInfo): boolean;
+export declare function getDirectiveByName(fieldConfig: GraphQLFieldConfig<any, any, any>, directiveName: string): null | DirectiveNode;
+export declare function isPromise(value: any): value is Promise<unknown>;
+export type useRedwoodDirectiveReturn = Plugin<{
+    onResolvedValue: ValidatorDirectiveFunc | TransformerDirectiveFunc;
+}>;
+export declare const useRedwoodDirective: (options: DirectivePluginOptions) => useRedwoodDirectiveReturn;
+export {};
+//# sourceMappingURL=useRedwoodDirective.d.ts.map

package/dist/cjs/plugins/useRedwoodDirective.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRedwoodDirective.d.ts","sourceRoot":"","sources":["../../../src/plugins/useRedwoodDirective.ts"],"names":[],"mappings":"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"}