agoo 2.5.4 → 2.5.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8768a1d0781d3dcdfb3bd2406a1fcfb1a4a72f1f207baa209bed917fc8870bfe
-  data.tar.gz: dd73f6588fa08dc85fbeb2e03f125d1697055eaf2bc533c9c5e175d68be50df7
+  metadata.gz: 409a4fe687d9ff75a67d4b25f559b5baa9df782d828bfeb1645daf696ba30035
+  data.tar.gz: a57f3d142cdee7c3ac6fc9d73fd05e2b1e5e4c90a1a2f276e4af0f69764f232b
 SHA512:
-  metadata.gz: 8838e52207c0ed3c234b12e0b7468447bb3bf2f8e6ae0da777db293e3a0b2c052719a2ac825ce6151cf2e197b0d4a39c3110bbbff9c289608f95cba8f0b6fed3
-  data.tar.gz: 850a9426c659955428c81cb516938d831e4a13e4e7c83d02923289d7b8d55635d0d2e8dcef778f53088baf6050baa634c1f3274e67469a0a42a7a23e1b958063
+  metadata.gz: e4f662d43b893105689f50df6a8942ec2e86e82bec8534cff159e5a5b634a5075c1a80283c474b855c41bdff208ed1f3d605ba5b98a0591bd385202a751ac884
+  data.tar.gz: 2fd33f0f3021820efc68a4b073526fa584ba4792d10cd25806a81b11131ffcd13d35863dc1c58a11a203f03e4d10e6943dedaf6b9f9adfbfacce97c46ea4e918

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 # CHANGELOG
 
+### 2.5.5 - 2018-11-12
+
+More optimizations and some cleanup.
+
+- New optional hint to the server that allows responses to `#call` to be cached.
+
+- Change C header file guards. No change in behavior. Just code cleanup.
+
+- Fixed change that slowed down the server.
+
 ### 2.5.4 - 2018-11-10
 
 Third times a charm.

data/bin/agoo

@@ -46,6 +46,7 @@ Example:
 @threads = 0
 @workers = 0
 @first = false
+@graphql = nil
 
 @opts = OptionParser.new(usage)
 @opts.on('-h', '--help', 'Show this display.')                                       { puts @opts.help; Process.exit!(0) }
@@ -54,6 +55,7 @@ Example:
 @opts.on('-f', '--root_first', 'Check the root directory before the handle paths.')  { @first = true }
 @opts.on('-p', '--port PORT', Integer, 'Port to listen on.')                         { |p| @port = p }
 @opts.on('-d', '--dir DIR', String, 'Directory to serve static assets from.')        { |d| @root = d }
+@opts.on('-g', '--graphql PATH', String, 'URL path for GraphQL requests.')           { |g| @graphql = g }
 @opts.on('-r', '--require FILE', String, 'Ruby require.')                            { |r| require r }
 @opts.on('-t', '--threads COUNT', Integer, 'Number of threads to use.')              { |t| @threads = t }
 @opts.on('-w', '--workers COUNT', Integer, 'Number of workers to use.')              { |w| @workers = w }
@@ -81,7 +83,7 @@ Agoo::Log.configure(dir: @log_dir,
 		      push: 2 <= @verbose,
 		    })
 
-Agoo::Server.init(@port, @root, thread_count: @threads, worker_count: @workers, root_first: @first)
+Agoo::Server.init(@port, @root, thread_count: @threads, worker_count: @workers, root_first: @first, graphql: @graphql)
 
 puts "Agoo #{Agoo::VERSION} is listening on port #{@port}. Path mappings are:" if 1 <= @verbose
 

data/ext/agoo/base64.h

@@ -1,7 +1,7 @@
 // Copyright 2011, 2016, 2018 by Peter Ohler, All Rights Reserved
 
-#ifndef __AGOO_BASE64_H__
-#define __AGOO_BASE64_H__
+#ifndef AGOO_BASE64_H
+#define AGOO_BASE64_H
 
 typedef unsigned char	uchar;
 
@@ -12,4 +12,4 @@ extern unsigned long    b64_orig_size(const char *text);
 extern int	        b64_to(const uchar *src, int len, char *b64);
 extern void             b64_from(const char *b64, uchar *str);
 
-#endif /* __AGOO_BASE64_H__ */
+#endif // AGOO_BASE64_H

data/ext/agoo/bind.c

@@ -193,7 +193,7 @@ bind_url(Err err, const char *url) {
 	char	scheme[8];
 
 	if (NULL != colon && colon - url < (int)sizeof(scheme)) {
-	    int	slen = colon - url;
+	    int	slen = (int)(colon - url);
 
 	    memcpy(scheme, url, slen);
 	    scheme[slen] = '\0';

data/ext/agoo/bind.h

@@ -1,7 +1,7 @@
 // Copyright (c) 2018, Peter Ohler, All rights reserved.
 
-#ifndef __AGOO_BIND_H__
-#define __AGOO_BIND_H__
+#ifndef AGOO_BIND_H
+#define AGOO_BIND_H
 
 #include <stdbool.h>
 #include <sys/socket.h>
@@ -41,4 +41,4 @@ extern void	bind_destroy(Bind b);
 extern int	bind_listen(Err err, Bind b);
 extern void	bind_close(Bind b);
 
-#endif // __AGOO_BIND_H__
+#endif // AGOO_BIND_H

data/ext/agoo/con.c

@@ -974,8 +974,10 @@ short
 con_http_events(Con c) {
     short	events = 0;
     
-    if ((NULL != c->res_head && NULL != res_message(c->res_head)) || !c->closing) {
+    if (NULL != c->res_head && NULL != res_message(c->res_head)) {
 	events = POLLIN | POLLOUT;
+    } else if (!c->closing) {
+	events = POLLIN;
     }
     return events;
 }
@@ -1142,7 +1144,7 @@ con_loop(void *x) {
 		    goto CON_CHECK;
 		}
 	    }
-	    if (0 != (pp->revents & POLLOUT) && NULL != c->res_head && NULL != res_message(c->res_head)) {
+	    if (0 != (pp->revents & POLLOUT)) {
 		if (con_write(c)) {
 		    c->dead = true;
 		    goto CON_CHECK;

data/ext/agoo/con.h

@@ -1,7 +1,7 @@
 // Copyright (c) 2018, Peter Ohler, All rights reserved.
 
-#ifndef __AGOO_CON_H__
-#define __AGOO_CON_H__
+#ifndef AGOO_CON_H
+#define AGOO_CON_H
 
 #include <poll.h>
 #include <pthread.h>
@@ -62,4 +62,4 @@ extern bool		con_http_read(Con c);
 extern bool		con_http_write(Con c);
 extern short		con_http_events(Con c);
 
-#endif /* __AGOO_CON_H__ */
+#endif /* AGOO_CON_H */

data/ext/agoo/debug.c

@@ -28,6 +28,13 @@ atomic_int	mem_cslot = 0;
 atomic_int	mem_err_stream = 0;
 atomic_int	mem_eval_threads = 0;
 atomic_int	mem_group = 0;
+atomic_int	mem_graphql_arg = 0;
+atomic_int	mem_graphql_directive = 0;
+atomic_int	mem_graphql_field = 0;
+atomic_int	mem_graphql_link = 0;
+atomic_int	mem_graphql_slot = 0;
+atomic_int	mem_graphql_type = 0;
+atomic_int	mem_graphql_value = 0;
 atomic_int	mem_group_path = 0;
 atomic_int	mem_header = 0;
 atomic_int	mem_hook = 0;

data/ext/agoo/debug.h

@@ -1,14 +1,14 @@
 // Copyright (c) 2018, Peter Ohler, All rights reserved.
 
-#ifndef __AGOO_DEBUG_H__
-#define __AGOO_DEBUG_H__
+#ifndef AGOO_DEBUG_H
+#define AGOO_DEBUG_H
 
 #include <stdatomic.h>
 
 #ifdef MEM_DEBUG
-#define DEBUG_ALLOC(var, ptr) { atomic_fetch_add(&var, 1); debug_add(ptr, #var, __FILE__, __LINE__); }
-#define DEBUG_REALLOC(var, orig, ptr) { debug_update(orig, ptr, #var, __FILE__, __LINE__); }
-#define DEBUG_FREE(var, ptr) { atomic_fetch_sub(&var, 1); debug_del(ptr, __FILE__, __LINE__); }
+#define DEBUG_ALLOC(var, ptr) { atomic_fetch_add(&var, 1); debug_add(ptr, #var, FILE, LINE); }
+#define DEBUG_REALLOC(var, orig, ptr) { debug_update(orig, ptr, #var, FILE, LINE); }
+#define DEBUG_FREE(var, ptr) { atomic_fetch_sub(&var, 1); debug_del(ptr, FILE, LINE); }
 #else
 #define DEBUG_ALLOC(var, ptr) { }
 #define DEBUG_REALLOC(var, orig, ptr) { }
@@ -21,6 +21,13 @@ extern atomic_int	mem_con;
 extern atomic_int	mem_cslot;
 extern atomic_int	mem_err_stream;
 extern atomic_int	mem_eval_threads;
+extern atomic_int	mem_graphql_arg;
+extern atomic_int	mem_graphql_directive;
+extern atomic_int	mem_graphql_field;
+extern atomic_int	mem_graphql_link;
+extern atomic_int	mem_graphql_slot;
+extern atomic_int	mem_graphql_type;
+extern atomic_int	mem_graphql_value;
 extern atomic_int	mem_group;
 extern atomic_int	mem_group_path;
 extern atomic_int	mem_header;
@@ -54,4 +61,4 @@ extern void	debug_del(void *ptr, const char *file, int line);
 extern void	debug_report();
 extern void	debug_rreport(); // when called from ruby
 
-#endif /* __AGOO_DEBUG_H__ */
+#endif /* AGOO_DEBUG_H */

data/ext/agoo/doc.c

@@ -0,0 +1,159 @@
+// Copyright (c) 2018, Peter Ohler, All rights reserved.
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "doc.h"
+#include "gqlvalue.h"
+
+static char	char_map[256] = "\
+.........ww..w..................\
+wpq.....pp..w.p.ttttttttttp..p..\
+pttttttttttttttttttttttttttp.p.t\
+.ttttttttttttttttttttttttttppp..\
+................................\
+................................\
+................................\
+................................";
+
+void
+doc_init(Doc doc, const char *str, int len) {
+    if (0 >= len) {
+	len = (int)strlen(str);
+    }
+    doc->str = str;
+    doc->cur = str;
+    doc->end = str + len;
+    // If there is a BOM, skip it.
+    if (0xEF == (uint8_t)*doc->str && 0xBB == (uint8_t)doc->str[1] && 0xBF == (uint8_t)doc->str[2]) {
+	doc->cur += 3;
+    }
+}
+
+int
+doc_skip_white(Doc doc) {
+    const char	*start = doc->cur;
+    
+    for (; 'w' == char_map[*(uint8_t*)doc->cur]; doc->cur++) {
+    }
+    return (int)(doc->cur - start);
+}
+
+void
+doc_skip_comment(Doc doc) {
+    for (; true; doc->cur++) {
+	switch (*doc->cur) {
+	case '\r':
+	case '\n':
+	    return;
+	default:
+	    break;
+	}
+    }
+}
+
+void
+doc_read_token(Doc doc) {
+    if ('t' == char_map[*(uint8_t*)doc->cur] && '9' < *doc->cur) {
+	doc->cur++;
+	for (; 't' == char_map[*(uint8_t*)doc->cur]; doc->cur++) {
+	}
+    }
+}
+
+void
+doc_next_token(Doc doc) {
+    while (true) {
+	doc_skip_white(doc);
+	if ('#' == *doc->cur) {
+	    doc_skip_comment(doc);
+	} else {
+	    break;
+	}
+    }
+}
+
+// Just find end.
+int
+doc_read_string(Err err, Doc doc) {
+    doc->cur++; // skip first "
+    if ('"' == *doc->cur) { // a """ string or an empty string
+	doc->cur++;
+	if ('"' != *doc->cur) {
+	    return ERR_OK; // empty string
+	}
+	doc->cur++;
+	for (; doc->cur < doc->end; doc->cur++) {
+	    if ('"' == *doc->cur && '"' == doc->cur[1] && '"' == doc->cur[2]) {
+		doc->cur += 3;
+		break;
+	    }
+	}
+    } else {
+	for (; doc->cur < doc->end; doc->cur++) {
+	    if ('"' == *doc->cur) {
+		if ('\\' != doc->cur[-1]) {
+		    doc->cur++;
+		    break;
+		}
+	    }
+	}
+    }
+    if (doc->end <= doc->cur) {
+	return doc_err(doc, err, "String not terminated");
+    }
+    return ERR_OK;
+}
+
+int
+doc_err(Doc doc, Err err, const char *fmt, ...) {
+    va_list	ap;
+    char	msg[248];
+    int		line = 0;
+    int		col = 0;
+
+    va_start(ap, fmt);
+    vsnprintf(msg, sizeof(msg), fmt, ap);
+    doc_location(doc, &line, &col);
+    va_end(ap);
+
+    return err_set(err, ERR_PARSE, "%s at %d:%d", msg, line, col);
+}
+
+void
+doc_location(Doc doc, int *linep, int *colp) {
+    const char	*s;
+    int		line = 1;
+    int		col = 1;
+
+    for (s = doc->str; s < doc->cur; s++) {
+	switch (*s) {
+	case '\n':
+	    line++;
+	    col = 1;
+	    break;
+	case '\r':
+	    if ('\n' == *(s + 1)) {
+		s++;
+	    }
+	    line++;
+	    col = 1;
+	    break;
+	default:
+	    col++;
+	    break;
+	}
+    }
+    *linep = line;
+    *colp = col;
+}
+
+gqlValue
+doc_read_value(Err err, Doc doc) {
+    // TBD handle list and object as well as scalars, object is typeless
+    // TBD put this in doc_read_value
+    return NULL;
+}
+

data/ext/agoo/doc.h

@@ -0,0 +1,34 @@
+// Copyright (c) 2018, Peter Ohler, All rights reserved.
+
+#ifndef AGOO_DOC_H
+#define AGOO_DOC_H
+
+#include <stdarg.h>
+
+#include "err.h"
+
+struct _gqlValue;
+
+typedef struct _Doc {
+    const char	*str;
+    const char	*cur;
+    const char	*end;
+} *Doc;
+
+extern void	doc_init(Doc doc, const char *str, int len);
+
+extern int	doc_skip_white(Doc doc);
+extern void	doc_skip_comment(Doc doc);
+extern int	doc_read_desc(Err err, Doc doc);
+
+extern void	doc_next_token(Doc doc);
+extern void	doc_read_token(Doc doc);
+
+extern int	doc_read_string(Err err, Doc doc);
+
+extern int	doc_err(Doc doc, Err err, const char *fmt, ...);
+extern void	doc_location(Doc doc, int *linep, int *colp);
+
+extern struct _gqlValue*	doc_read_value(Err err, Doc doc);
+
+#endif // AGOO_DOC_H

data/ext/agoo/dtime.h

@@ -1,10 +1,10 @@
 // Copyright 2009, 2015, 2018, 2016 by Peter Ohler, All Rights Reserved
 
-#ifndef __AGOO_DTIME_H__
-#define __AGOO_DTIME_H__
+#ifndef AGOO_DTIME_H
+#define AGOO_DTIME_H
 
 extern double	dtime(void);
 extern double	dsleep(double t);
 extern double	dwait(double t);
 
-#endif /* __AGOO_DTIME_H__ */
+#endif /* AGOO_DTIME_H */

data/ext/agoo/err.h

@@ -1,7 +1,7 @@
 // Copyright (c) 2018, Peter Ohler, All rights reserved.
 
-#ifndef __AGOO_ERR_H__
-#define __AGOO_ERR_H__
+#ifndef AGOO_ERR_H
+#define AGOO_ERR_H
 
 #include <errno.h>
 
@@ -42,4 +42,4 @@ extern int		err_no(Err err, const char *fmt, ...);
 extern const char*	err_str(ErrCode code);
 extern void		err_clear(Err err);
 
-#endif /* __AGOO_ERR_H__ */
+#endif /* AGOO_ERR_H */

data/ext/agoo/error_stream.h

@@ -1,7 +1,7 @@
 // Copyright (c) 2018, Peter Ohler, All rights reserved.
 
-#ifndef __AGOO_ERROR_STREAM_H__
-#define __AGOO_ERROR_STREAM_H__
+#ifndef AGOO_ERROR_STREAM_H
+#define AGOO_ERROR_STREAM_H
 
 #include <ruby.h>
 
@@ -10,4 +10,4 @@
 extern void	error_stream_init(VALUE mod);
 extern VALUE	error_stream_new();
 
-#endif // __AGOO_ERROR_STREAM_H__
+#endif // AGOO_ERROR_STREAM_H

data/ext/agoo/extconf.rb

@@ -4,7 +4,7 @@ require 'rbconfig'
 extension_name = 'agoo'
 dir_config(extension_name)
 
-$CPPFLAGS += " -DPLATFORM_LINUX" if 'x86_64-linux' == RUBY_PLATFORM
+$CFLAGS += " -DPLATFORM_LINUX" if 'x86_64-linux' == RUBY_PLATFORM
 
 # Adding the __attribute__ flag only works with gcc compilers and even then it
 # does not work to check args with varargs s just remove the check.

data/ext/agoo/gqlintro.c

@@ -0,0 +1,333 @@
+// Copyright (c) 2018, Peter Ohler, All rights reserved.
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "gqlintro.h"
+#include "gqlvalue.h"
+#include "graphql.h"
+
+static gqlType	schema_type;
+static gqlType	type_type;
+static gqlType	type_kind_type;
+static gqlType	field_type;
+static gqlType	input_value_type;
+static gqlType	enum_value_type;
+static gqlType	directive_type;
+static gqlType	directive_location_type;
+
+// type __Schema {
+//   types: [__Type!]!
+//   queryType: __Type!
+//   mutationType: __Type
+//   subscriptionType: __Type
+//   directives: [__Directive!]!
+// }
+static gqlRef
+schema_types_resolve(gqlRef target, const char *fieldName, gqlKeyVal *args) {
+    // TBD
+    return NULL;
+}
+
+static gqlRef
+schema_query_type_resolve(gqlRef target, const char *fieldName, gqlKeyVal *args) {
+    // TBD return schema_type.query.type
+    //  lookup "schema" type
+    //  get query field
+    //  get return type of field
+    return NULL;
+}
+
+static int
+create_schema_type(Err err) {
+    if (NULL == (schema_type = gql_type_create(err, "__Schema", NULL, -1, true, NULL)) ||
+	NULL == gql_type_field(err, schema_type, "types", type_type, NULL, true, true, true, schema_types_resolve) ||
+	NULL == gql_type_field(err, schema_type, "queryType", type_type, NULL, true, false, false, schema_query_type_resolve) ||
+	NULL == gql_type_field(err, schema_type, "mutationType", type_type, NULL, false, false, false, NULL) ||
+	NULL == gql_type_field(err, schema_type, "subscriptionType", type_type, NULL, false, false, false, NULL) ||
+	NULL == gql_type_field(err, schema_type, "directives", directive_type, NULL, true, true, true, NULL)) {
+
+	return err->code;
+    }
+    schema_type->core = true;
+    
+    return ERR_OK;
+}
+
+// type __Type {
+//   kind: __TypeKind!
+//   name: String
+//   description: String
+//   fields(includeDeprecated: Boolean = false): [__Field!]
+//   interfaces: [__Type!]
+//   possibleTypes: [__Type!]
+//   enumValues(includeDeprecated: Boolean = false): [__EnumValue!]
+//   inputFields: [__InputValue!]
+//   ofType: __Type
+// }
+static int
+create_type_type(Err err) {
+    gqlField	fields = NULL;
+    gqlField	enum_values = NULL;
+    gqlValue	dv;
+    
+    if (NULL == (type_type = gql_type_create(err, "__Type", NULL, -1, true, NULL)) ||
+	NULL == gql_type_field(err, type_type, "kind", type_kind_type, NULL, true, false, false, NULL) ||
+	NULL == gql_type_field(err, type_type, "name", &gql_string_type, NULL, false, false, false, NULL) ||
+	NULL == gql_type_field(err, type_type, "description", &gql_string_type, NULL, false, false, false, NULL) ||
+	NULL == (fields = gql_type_field(err, type_type, "fields", field_type, NULL, false, true, true, NULL)) ||
+	NULL == gql_type_field(err, type_type, "interfaces", type_type, NULL, false, true, true, NULL) ||
+	NULL == gql_type_field(err, type_type, "possibleTypes", type_type, NULL, false, true, true, NULL) ||
+	NULL == (enum_values = gql_type_field(err, type_type, "enumValues", enum_value_type, NULL, false, true, true, NULL)) ||
+	NULL == gql_type_field(err, type_type, "inputFields", input_value_type, NULL, false, true, true, NULL) ||
+	NULL == gql_type_field(err, type_type, "ofType", type_type, NULL, false, false, false, NULL)) {
+
+	return err->code;
+    }
+    type_type->core = true;
+
+    if (NULL == (dv = gql_bool_create(err, false)) ||
+	NULL == gql_field_arg(err, fields, "includeDeprecated", &gql_bool_type, NULL, dv, false) ||
+	NULL == (dv = gql_bool_create(err, false)) ||
+	NULL == gql_field_arg(err, enum_values, "includeDeprecated", &gql_bool_type, NULL, dv, false)) {
+
+	return err->code;
+    }
+    return ERR_OK;
+}
+
+static int
+create_type_kind_type(Err err) {
+    const char	*choices[] = {
+	"SCALAR",
+	"OBJECT",
+	"INTERFACE",
+	"UNION",
+	"ENUM",
+	"INPUT_OBJECT",
+	"LIST",
+	"NON_NULL",
+	NULL
+    };
+    const char	**cp;
+    
+    type_kind_type = gql_enum_create(err, "__TypeKind", NULL, -1, true);
+    type_kind_type->core = true;
+    for (cp = choices; NULL != *cp; cp++) {
+	if (ERR_OK != gql_enum_append(err, type_kind_type, *cp, -1)) {
+	    return err->code;
+	}
+    }
+    return err->code;
+}
+
+// type __Field {
+//   name: String!
+//   description: String
+//   args: [__InputValue!]!
+//   type: __Type!
+//   isDeprecated: Boolean!
+//   deprecationReason: String
+// }
+static int
+create_field_type(Err err) {
+    if (NULL == (field_type = gql_type_create(err, "__Field", NULL, -1, true, NULL)) ||
+	NULL == gql_type_field(err, field_type, "name", &gql_string_type, NULL, true, false, false, NULL) ||
+	NULL == gql_type_field(err, field_type, "description", &gql_string_type, NULL, false, false, false, NULL) ||
+	NULL == gql_type_field(err, field_type, "args", input_value_type, NULL, true, true, true, NULL) ||
+	NULL == gql_type_field(err, field_type, "type", type_type, NULL, true, false, false, NULL) ||
+	NULL == gql_type_field(err, field_type, "isDeprecated", &gql_bool_type, NULL, true, false, false, NULL) ||
+	NULL == gql_type_field(err, field_type, "reason", &gql_string_type, NULL, false, false, false, NULL)) {
+
+	return err->code;
+    }
+    field_type->core = true;
+    
+    return ERR_OK;
+}
+
+// type __InputValue {
+//   name: String!
+//   description: String
+//   type: __Type!
+//   defaultValue: String
+// }
+static int
+create_input_type(Err err) {
+    if (NULL == (input_value_type = gql_type_create(err, "__InputValue", NULL, -1, true, NULL)) ||
+	NULL == gql_type_field(err, input_value_type, "name", &gql_string_type, NULL, true, false, false, NULL) ||
+	NULL == gql_type_field(err, input_value_type, "description", &gql_string_type, NULL, false, false, false, NULL) ||
+	NULL == gql_type_field(err, input_value_type, "type", type_type, NULL, true, false, false, NULL) ||
+	NULL == gql_type_field(err, input_value_type, "defaultValue", &gql_string_type, NULL, false, false, false, NULL)) {
+
+	return err->code;
+    }
+    input_value_type->core = true;
+    
+    return ERR_OK;
+}
+
+// type __EnumValue {
+//   name: String!
+//   description: String
+//   isDeprecated: Boolean!
+//   deprecationReason: String
+// }
+static int
+create_enum_type(Err err) {
+    if (NULL == (enum_value_type = gql_type_create(err, "__EnumValue", NULL, -1, true, NULL)) ||
+	NULL == gql_type_field(err, enum_value_type, "name", &gql_string_type, NULL, true, false, false, NULL) ||
+	NULL == gql_type_field(err, enum_value_type, "description", &gql_string_type, NULL, false, false, false, NULL) ||
+	NULL == gql_type_field(err, enum_value_type, "isDeprecated", &gql_bool_type, NULL, true, false, false, NULL) ||
+	NULL == gql_type_field(err, enum_value_type, "deprecationReason", &gql_string_type, NULL, false, false, false, NULL)) {
+
+	return err->code;
+    }
+    enum_value_type->core = true;
+    
+    return ERR_OK;
+}
+
+// type __Directive {
+//   name: String!
+//   description: String
+//   locations: [__DirectiveLocation!]!
+//   args: [__InputValue!]!
+// }
+static int
+create_directive_type(Err err) {
+    if (NULL == (directive_type = gql_type_create(err, "__Directive", NULL, -1, true, NULL)) ||
+	NULL == gql_type_field(err, directive_type, "name", &gql_string_type, NULL, true, false, false, NULL) ||
+	NULL == gql_type_field(err, directive_type, "description", &gql_string_type, NULL, false, false, false, NULL) ||
+	NULL == gql_type_field(err, directive_type, "location", directive_location_type, NULL, true, true, true, NULL) ||
+	NULL == gql_type_field(err, directive_type, "args", input_value_type, NULL, true, true, true, NULL)) {
+
+	return err->code;
+    }
+    directive_type->core = true;
+    
+    return ERR_OK;
+}
+
+static int
+create_directive_location_type(Err err) {
+    const char	*choices[] = {
+	"QUERY",
+	"MUTATION",
+	"SUBSCRIPTION",
+	"FIELD",
+	"FRAGMENT_DEFINITION",
+	"FRAGMENT_SPREAD",
+	"INLINE_FRAGMENT",
+	"SCHEMA",
+	"SCALAR",
+	"OBJECT",
+	"FIELD_DEFINITION",
+	"ARGUMENT_DEFINITION",
+	"INTERFACE",
+	"UNION",
+	"ENUM",
+	"ENUM_VALUE",
+	"INPUT_OBJECT",
+	"INPUT_FIELD_DEFINITION",
+	NULL };
+    const char	**cp;
+
+    directive_location_type = gql_enum_create(err, "__DirectiveLocation", NULL, -1, true);
+    directive_location_type->core = true;
+    for (cp = choices; NULL != *cp; cp++) {
+	if (ERR_OK != gql_enum_append(err, directive_location_type, *cp, -1)) {
+	    return err->code;
+	}
+    }
+    return err->code;
+}
+
+static int
+create_dir_skip(Err err) {
+    gqlDir	dir = gql_directive_create(err, "skip", NULL, -1, true);
+
+    if (NULL == dir) {
+	return err->code;
+    }
+    if (ERR_OK != gql_directive_on(err, dir, "FIELD", -1) ||
+	ERR_OK != gql_directive_on(err, dir, "FRAGMENT_SPREAD", -1) ||
+	ERR_OK != gql_directive_on(err, dir, "INLINE_FRAGMENT", -1) ||
+	NULL == gql_dir_arg(err, dir, "if", "Boolean", NULL, -1, NULL, true)) {
+
+	return err->code;
+    }
+    return ERR_OK;
+}
+
+static int
+create_dir_include(Err err) {
+    gqlDir	dir = gql_directive_create(err, "include", NULL, -1, true);
+
+    if (NULL == dir) {
+	return err->code;
+    }
+    if (ERR_OK != gql_directive_on(err, dir, "FIELD", -1) ||
+	ERR_OK != gql_directive_on(err, dir, "FRAGMENT_SPREAD", -1) ||
+	ERR_OK != gql_directive_on(err, dir, "INLINE_FRAGMENT", -1) ||
+	NULL == gql_dir_arg(err, dir, "if", "Boolean", NULL, -1, NULL, true)) {
+
+	return err->code;
+    }
+    return ERR_OK;
+}
+
+static int
+create_dir_deprecated(Err err) {
+    gqlDir	dir = gql_directive_create(err, "deprecated", NULL, -1, true);
+    gqlValue	dv;
+
+    if (NULL == dir) {
+	return err->code;
+    }
+    if (ERR_OK != gql_directive_on(err, dir, "FIELD_DEFINITION", -1) ||
+	ERR_OK != gql_directive_on(err, dir, "ENUM_VALUE", -1) ||
+	NULL == (dv = gql_string_create(err, "No longer supported", -1)) ||
+	NULL == gql_dir_arg(err, dir, "reason", "String", NULL, -1, dv, false)) {
+
+	return err->code;
+    }
+    return ERR_OK;
+}
+
+int
+gql_intro_init(Err err) {
+    gqlField	f;
+    
+    if (ERR_OK != create_type_kind_type(err) ||
+	ERR_OK != create_input_type(err) ||
+	ERR_OK != create_type_type(err) ||
+	ERR_OK != create_enum_type(err) ||
+	ERR_OK != create_field_type(err) ||
+	ERR_OK != create_directive_location_type(err) ||
+	ERR_OK != create_directive_type(err) ||
+	ERR_OK != create_schema_type(err) ||
+	ERR_OK != create_dir_deprecated(err) ||
+	ERR_OK != create_dir_include(err) ||
+	ERR_OK != create_dir_skip(err)) {
+
+	return err->code;
+    }
+    // InputValue and Type as well Field and Type as have a depency loop so
+    // complete the loop.
+    for (f = input_value_type->fields; NULL != f; f = f->next) {
+	if (0 == strcmp("type", f->name)) {
+	    f->type = type_type;
+	    break;
+	}
+    }
+    for (f = type_type->fields; NULL != f; f = f->next) {
+	if (0 == strcmp("fields", f->name)) {
+	    f->type = field_type;
+	} else if (0 == strcmp("enumValues", f->name)) {
+	    f->type = enum_value_type;
+	    break;
+	}
+    }
+    return ERR_OK;
+}