npm package discovery and stats viewer.

Discover Tips

  • General search

    [free text search, go nuts!]

  • Package details

    pkg:[package-name]

  • User packages

    @[username]

Sponsor

Optimize Toolset

I’ve always been into building performant and accessible sites, but lately I’ve been taking it extremely seriously. So much so that I’ve been building a tool to help me optimize and monitor the sites that I build to make sure that I’m making an attempt to offer the best experience to those who visit them. If you’re into performant, accessible and SEO friendly sites, you might like it too! You can check it out at Optimize Toolset.

About

Hi, 👋, I’m Ryan Hefner  and I built this site for me, and you! The goal of this site was to provide an easy way for me to check the stats on my npm packages, both for prioritizing issues and updates, and to give me a little kick in the pants to keep up on stuff.

As I was building it, I realized that I was actually using the tool to build the tool, and figured I might as well put this out there and hopefully others will find it to be a fast and useful way to search and browse npm packages as I have.

If you’re interested in other things I’m working on, follow me on Twitter or check out the open source projects I’ve been publishing on GitHub.

I am also working on a Twitter bot for this site to tweet the most popular, newest, random packages from npm. Please follow that account now and it will start sending out packages soon–ish.

Open Software & Tools

This site wouldn’t be possible without the immense generosity and tireless efforts from the people who make contributions to the world and share their work via open source initiatives. Thank you 🙏

© 2024 – Pkg Stats / Ryan Hefner

graphql-middleware-typed-arguments

v1.2.5

Published

Validating and filtering query argument types has been hard, but no more.

Downloads

7

Readme

graphql-middleware-typed-arguments

GraphQL Middleware Typed Arguments lets you define a processor function to massage, validate, authorize, or whatever your query, mutation, or field arguments of a certain type. The middleware was originally developed as GraphQL Middleware Apollo Upload Server, which wonderfully separated streaming uploaded media to its ultimate destination from other concerns.

Install

npm install graphql-middleware-typed-arguments

Overview

graphql-middleware-typed-arguments lets you wrap a function around field arguments of any type. The classic example is GraphQLUpload type in conjunction with Apollo Upload Server. Now, also, you can attach an inspection function to any type of query argument, such as complicated validation of telephone numbers or delivery addresses where fields of the input object type depend upon each other in complex ways. And there's more: you can also produce middleware to visit all field arguments regardless of type.

Features

  • 👌 Easy to use.
  • 🛴 Half automatic.
  • 🏆 Works with every GraphQL server.

Notes

If you would appreciate an integration of the Yup validation framework to validate your scalar and object-type arguments, look at this package.

Demo

The example is taken directly from graphql-middleware-apollo-upload-server which was basis for this generalization. There are two changes from the original: the GraphQLUpload type object is imported, but the type name "Upload" could be used as well. (In fact, type names are simpler way to get at a type defined in SDL.) The second change is providing the type (object or string) to the middleware factory function provided by this package: processTypeArgs. (The previous version's upload method has been preseved and implemented as a special case.)

import { GraphQLServer } from 'graphql-yoga'
import { GraphQLUpload } from 'apollo-upload-server'
import { S3 } from 'aws-sdk'
import { processTypeArgs } from 'graphql-middleware-typed-arguments'

const client = new S3({
  accessKeyId: __S3_KEY__,
  secretAccessKey: __S3_SECRET__,
  params: { Bucket: __S3_BUCKET__ },
})

const uploadToS3 = file => {
  const { stream, filename, mimetype, encoding } = file

  const response = client
    .upload({
      Key: filename,
      ACL: 'public-read',
      Body: file.stream,
    })
    .promise()
    .then( response => ({
      name: filename,
      url: response.Location
    }))
  }
}

const typeDefs = `
  scalar Upload

  type Query {
    me: User
  }

  type Mutation {
    signup(name: String!, password: String!, picture: Upload!): User
  }

  type User {
    id: ID!
    name: String!
    password: String!
    picture: File!
  }

  type File {
    id: ID!
    name: String!
    url: String!
  }
`

const resolvers = {
  Query: {
    me: getMyself
  },
  Mutation: {
    signup: async (parent, { name, password, picture }, ctx, info) => {
      // "picture" has already been uploaded!
      return ctx.db.createUser({
        data: {
          name,
          password,
          picture: picture.url
        }
      })
    }
  }
}

const server = new GraphQLServer({
  typeDefs,
  resolvers,
  middlewares: [processTypeArgs({ type: GraphQLUpload, transform: uploadToS3 })],
  context: req => ({
    ...req,
    db: new Prisma({
      endpoint: __PRISMA_ENDPOINT__,
    })
  })
})

server.listen(() => {
  console.log(`Server running on https://localhost:4000`)
})

API

interface ITypeConfig<V, T> {
  type: GraphQLType | string
  transform: (value: V, root: any, args: {}, context: any, info: GraphQLResolveInfo) => Promise<T>
}

export const processTypeArgs<V, T> = (
  config: ITypeConfig<V, T>
): IMiddleware

interface IConfig {
  // behave yourself here:  the visitor should change type very carefully, such as dereferencing to validate an ID
  visitor: (value: any, root: any, args: {}, context: any, info: GraphQLResolveInfo) => Promise<any>
}

export const visitAllArgs = (
  config: IConfig
): IMiddleware

// Note that the visitor and transform functions receive all four resolver args (parent, args, context, & info),
// For these functions, info.argument has been set to refer to the relevant argument definition.

// input and output types are up to you, just provide the transform function
interface IFile {
  stream: string
  filename: string
  mimetype: string
  encoding: string
}

interface IRefS3 {
  name: string
  url: string
}

const middlewareFunction = processTypeArgs({
  type: 'Upload',
  transform: uploadToS3
})

License

MIT @ Homeroom