Typescript and Javascript generators

Author: kbrandwijk

.circleci/config.yml

@@ -0,0 +1,5 @@
+node_modules
+dist
+package-lock.json
+yarn.lock
+.vscode

.gitignore

@@ -0,0 +1,2 @@
+src
+.circleci

.npmignore

@@ -0,0 +1,25 @@
+{
+  "name": "graphql-static-binding",
+  "version": "0.1.0",
+  "description": "Generate static binding files for a GraphQL schema",
+  "main": "dist/index.js",
+  "typings": "dist/index.d.ts",
+  "scripts": {
+    "prepublish": "npm run build",
+    "start": "ts-node --inspect src/index.ts",
+    "build": "tsc -d"
+  },
+  "keywords": [
+    "graphql"
+  ],
+  "author": "Kim Brandwijk <kim.brandwijk@gmail.com>",
+  "license": "MIT",
+  "dependencies": {
+    "graphql": "^0.12.3"
+  },
+  "devDependencies": {
+    "@types/node": "^8.5.1",
+    "ts-node": "^4.0.2",
+    "typescript": "^2.6.2"
+  }
+}

package.json

@@ -0,0 +1,48 @@
+import { 
+    GraphQLUnionType,
+    GraphQLWrappingType,
+    GraphQLObjectType,
+    GraphQLInputObjectType,
+    GraphQLInputField,
+    GraphQLField,
+    GraphQLInputType,
+    GraphQLOutputType,
+    GraphQLScalarType,
+    GraphQLNamedType,
+
+    isNonNullType,
+    isListType,
+    GraphQLFieldMap,
+    GraphQLEnumType,
+    GraphQLType,
+    GraphQLInterfaceType,
+} from 'graphql'
+
+import { Generator } from '../types'
+
+export const generator: Generator = {
+  Main: renderMainMethod,
+}
+
+function renderMainMethod(queryType: GraphQLObjectType, mutationType?: GraphQLObjectType | null, subscriptionType?: GraphQLObjectType | null) {
+  return `exports.binding = {
+  query: {
+${renderMainMethodFields(queryType.getFields())}
+  }${mutationType ? `,
+  mutation: {
+${renderMainMethodFields(mutationType.getFields())}
+  }`: ''}${subscriptionType ? `,
+  subscription: {
+${renderMainMethodFields(subscriptionType.getFields())}
+  }`: ''}
+}`
+}
+
+function renderMainMethodFields(fields: GraphQLFieldMap<any, any>): string {
+  return Object.keys(fields).map(f => {
+    const field = fields[f]
+    return `    ${field.name}(args, info) { 
+      return /* TODO: Get actual implementation here from graphql-binding */
+    }`
+  }).join(',\n')
+}

src/generators/javascript.ts

@@ -0,0 +1,139 @@
+import { 
+    GraphQLUnionType,
+    GraphQLWrappingType,
+    GraphQLObjectType,
+    GraphQLInputObjectType,
+    GraphQLInputField,
+    GraphQLField,
+    GraphQLInputType,
+    GraphQLOutputType,
+    GraphQLScalarType,
+    GraphQLNamedType,
+
+    isNonNullType,
+    isListType,
+    GraphQLFieldMap,
+    GraphQLEnumType,
+    GraphQLType,
+    GraphQLInterfaceType,
+} from 'graphql'
+
+import { Generator } from '../types'
+
+export const generator: Generator = {
+  GraphQLUnionType: renderUnionType,
+  GraphQLObjectType: renderObjectType,
+  GraphQLInputObjectType: renderObjectType,
+  GraphQLScalarType: renderScalarType,
+  GraphQLEnumType: renderEnumType,
+  GraphQLInterfaceType: renderObjectType,
+  RootType: renderRootType,
+  SchemaType: renderSchemaInterface,
+  Main: renderMainMethod,
+}
+
+const scalarMapping = {
+  Int: 'number',
+  String: 'string',
+  ID: 'string | number',
+  Float: 'number',
+  Boolean: 'boolean'
+}
+
+function renderMainMethod(queryType: GraphQLObjectType, mutationType?: GraphQLObjectType | null, subscriptionType?: GraphQLObjectType | null) {
+  return `export const binding: Schema = {
+  query: {
+${renderMainMethodFields(queryType.getFields())}
+  }${mutationType ? `,
+  mutation: {
+${renderMainMethodFields(mutationType.getFields())}
+  }`: ''}${subscriptionType ? `,
+  subscription: {
+${renderMainMethodFields(subscriptionType.getFields())}
+  }`: ''}
+}`
+}
+
+function renderMainMethodFields(fields: GraphQLFieldMap<any, any>): string {
+  return Object.keys(fields).map(f => {
+    const field = fields[f]
+    return `    ${field.name}: (args, info): ${renderFieldType(field.type)}${!isNonNullType(field.type) ? ' | null' : ''} => { return /* TODO: Get actual implementation here from graphql-binding */ }`
+  }).join(',\n')
+}
+
+function renderScalarType(type: GraphQLScalarType): string {
+  return `${type.description ? `/*
+${type.description}
+*/
+`: ''}export type ${type.name} = ${scalarMapping[type.name] || 'string'}`
+}
+
+function renderEnumType(type: GraphQLEnumType): string {
+  return `${renderDescription(type.description)}export enum ${type.name} {
+${type.getValues().map(e => `  ${e.name} = '${e.value}'`).join(',\n')}
+}`
+}
+  
+function renderRootType(type: GraphQLObjectType): string {
+  const fieldDefinition = Object.keys(type.getFields()).map(f => {
+    const field = type.getFields()[f]
+    return `  ${field.name}: (args: {${field.args.length > 0 ? ' ': ''}${field.args.map(f => `${renderFieldName(f)}: ${renderFieldType(f.type)}`).join(', ')}${field.args.length > 0 ? ' ': ''}}, info: any) => ${renderFieldType(field.type)}${!isNonNullType(field.type) ? ' | null' : ''}`
+  }).join('\n')
+
+  return renderInterfaceWrapper(type.name, type.description, type.getInterfaces(), fieldDefinition)
+}
+
+function renderUnionType(type: GraphQLUnionType): string {
+  return `${renderDescription(type.description)}export type ${type.name} = ${type.getTypes().map(t => t.name).join(' | ')}`
+}
+  
+function renderObjectType(type: GraphQLObjectType | GraphQLInputObjectType | GraphQLInterfaceType): string {
+  const fieldDefinition = Object.keys(type.getFields()).map(f => {
+    const field = type.getFields()[f]
+    return `  ${renderFieldName(field)}: ${renderFieldType(field.type)}`
+  }).join('\n')
+
+  let interfaces: GraphQLInterfaceType[] = []
+  if (type instanceof GraphQLObjectType) {
+    interfaces = type.getInterfaces()
+  }
+
+  return renderInterfaceWrapper(type.name, type.description, interfaces, fieldDefinition)
+}
+
+
+  
+function renderFieldName(field: GraphQLInputField | GraphQLField<any, any>) {
+  return `${field.name}${isNonNullType(field.type) ? '' : '?'}`
+}
+  
+function renderFieldType(type: GraphQLInputType | GraphQLOutputType) {
+  if (isNonNullType(type)) {
+    return renderFieldType((type as GraphQLWrappingType).ofType)
+  } 
+  if (isListType(type)) {
+    return `Array<${renderFieldType((type as GraphQLWrappingType).ofType)}>`
+  }
+  return (type as GraphQLNamedType).name
+}
+  
+function renderSchemaInterface(queryType: GraphQLObjectType, mutationType?: GraphQLObjectType | null, subscriptionType?: GraphQLObjectType | null) {
+  return `export interface Schema {
+  query: ${queryType.name}
+${mutationType ? `  mutation: ${mutationType.name}
+` : ''}${subscriptionType ? `  subscription: ${subscriptionType.name}
+` : ''}}`
+}
+  
+function renderInterfaceWrapper(typeName: string, typeDescription: string, interfaces: GraphQLInterfaceType[],fieldDefinition: string): string {
+  return `${renderDescription(typeDescription)}export interface ${typeName}${interfaces.length > 0 ? ` extends ${interfaces.map(i => i.name).join(', ')}`: ''} {
+${fieldDefinition}
+}`
+}
+
+function renderDescription(description?: string) {
+  return `${description ? `/*
+${description}
+*/
+`: ''}`
+}

src/generators/typescript.ts

@@ -0,0 +1,43 @@
+import { DocumentNode, Kind, ObjectTypeDefinitionNode, OperationTypeDefinitionNode, parse } from 'graphql';
+import { GraphQLSchema } from 'graphql/type/schema';
+import { buildASTSchema } from 'graphql/utilities/buildASTSchema';
+import { Generator } from './types'
+
+export { Generator } from './types'
+
+export function generateCode(schema: string, generator: Generator): string {
+    const document: DocumentNode = parse(schema, { noLocation: true })
+    const ast: GraphQLSchema = buildASTSchema(document)
+ 
+    // Create types
+    const typeNames = Object
+      .keys(ast.getTypeMap())
+      .filter(typeName => !typeName.startsWith('__'))
+      .filter(typeName => typeName !== ast.getQueryType().name)
+      .filter(typeName => ast.getMutationType() ? typeName !== ast.getMutationType()!.name : true)
+      .filter(typeName => ast.getSubscriptionType() ? typeName !== ast.getSubscriptionType()!.name : true)
+      .sort((a,b) => ast.getType(a).constructor.name < ast.getType(b).constructor.name ? -1 : 1)
+    
+    // Process all types
+    const generatedClass = typeNames.map(typeName => {
+      const type = ast.getTypeMap()[typeName]
+      return generator[type.constructor.name] ? generator[type.constructor.name](type) : null
+    })
+
+    // Special case 1: generate schema interface
+    if (generator.SchemaType) {
+      generatedClass.push(generator.SchemaType(ast.getQueryType(), ast.getMutationType(), ast.getSubscriptionType()))
+    }
+
+    // Special case 2: generate root field interfaces
+    if (generator.RootType) {
+      generatedClass.push(generator.RootType(ast.getQueryType()))
+      if (ast.getMutationType()) { generatedClass.push(generator.RootType(ast.getMutationType()!)) }
+      if (ast.getSubscriptionType()) { generatedClass.push(generator.RootType(ast.getSubscriptionType()!)) }
+    }
+
+    // Special case 3: the main method
+    generatedClass.push(generator.Main(ast.getQueryType(), ast.getMutationType(), ast.getSubscriptionType()))
+
+    return generatedClass.filter(r => r).join('\n\n')
+}