agoo 2.5.7 → 2.6.0

data/ext/agoo/rresponse.c

@@ -17,20 +17,17 @@ response_free(void *ptr) {
 
     while (NULL != (h = res->headers)) {
 	res->headers = h->next;
-	DEBUG_FREE(mem_header, h);
+	AGOO_FREE(h);
 	xfree(h);
     }
-    DEBUG_FREE(mem_res_body, res->body);
-    DEBUG_FREE(mem_response, ptr);
-    free(res->body); // allocated with strdup
-    xfree(ptr);
+    AGOO_FREE(res->body); // allocated with strdup
+    AGOO_FREE(ptr);
 }
 
 VALUE
-response_new( ) {
-    agooResponse	res = ALLOC(struct _agooResponse);
+response_new() {
+    agooResponse	res = (agooResponse)AGOO_MALLOC(sizeof(struct _agooResponse));
 
-    DEBUG_ALLOC(mem_response, res)
     memset(res, 0, sizeof(struct _agooResponse));
     res->code = 200;
     
@@ -47,9 +44,8 @@ static VALUE
 to_s(VALUE self) {
     agooResponse	res = (agooResponse)DATA_PTR(self);
     int			len = agoo_response_len(res);
-    char		*s = ALLOC_N(char, len + 1);
+    char		*s = (char*)AGOO_MALLOC(len + 1);
 
-    DEBUG_ALLOC(mem_to_s, s)
     agoo_response_fill(res, s);
     
     return rb_str_new(s, len);
@@ -96,10 +92,9 @@ body_set(VALUE self, VALUE val) {
     agooResponse	res = (agooResponse)DATA_PTR(self);
 
     if (T_STRING == rb_type(val)) {
-	if (NULL == (res->body = strdup(StringValuePtr(val)))) {
+	if (NULL == (res->body = AGOO_STRDUP(StringValuePtr(val)))) {
 	    rb_raise(rb_eArgError, "failed to copy body");
 	}
-	DEBUG_ALLOC(mem_res_body, res->body)
 	res->blen = (int)RSTRING_LEN(val);
     } else {
 	rb_raise(rb_eArgError, "Expected a string");
@@ -182,7 +177,7 @@ head_set(VALUE self, VALUE key, VALUE val) {
 	    } else {
 		prev->next = h->next;
 	    }
-	    DEBUG_FREE(mem_header, h);
+	    AGOO_FREED(h);
 	    xfree(h);
 	    break;
 	}
@@ -202,8 +197,7 @@ head_set(VALUE self, VALUE key, VALUE val) {
 	}
     }
     hlen = klen + vlen + 4;
-    h = (agooHeader)ALLOC_N(char, sizeof(struct _agooHeader) - 8 + hlen + 1);
-    DEBUG_ALLOC(mem_header, h)
+    h = (agooHeader)AGOO_MALLOC(sizeof(struct _agooHeader) - 8 + hlen + 1);
 
     h->next = NULL;
     h->len = hlen;

data/ext/agoo/rserver.c

@@ -175,7 +175,9 @@ configure(agooErr err, int port, const char *root, VALUE options) {
 	}
 	if (Qnil != (v = rb_hash_lookup(options, ID2SYM(rb_intern("graphql"))))) {
 	    const char	*path;
-	    agooHook	hook;
+	    agooHook	dump_hook;
+	    agooHook	get_hook;
+	    agooHook	post_hook;
 	    char	schema_path[256];
 	    long	plen;
 
@@ -191,13 +193,13 @@ configure(agooErr err, int port, const char *root, VALUE options) {
 	    memcpy(schema_path, path, plen);
 	    memcpy(schema_path + plen, "/schema", 8);
 
-	    hook = agoo_hook_func_create(AGOO_GET, schema_path, gql_dump_hook, &agoo_server.eval_queue);
-	    hook->next = agoo_server.hooks;
-	    agoo_server.hooks = hook;
-
-	    hook = agoo_hook_func_create(AGOO_GET, path, gql_eval_hook, &agoo_server.eval_queue);
-	    hook->next = agoo_server.hooks;
-	    agoo_server.hooks = hook;
+	    dump_hook = agoo_hook_func_create(AGOO_GET, schema_path, gql_dump_hook, &agoo_server.eval_queue);
+	    get_hook = agoo_hook_func_create(AGOO_GET, path, gql_eval_get_hook, &agoo_server.eval_queue);
+	    post_hook = agoo_hook_func_create(AGOO_POST, path, gql_eval_post_hook, &agoo_server.eval_queue);
+	    dump_hook->next = get_hook;
+	    get_hook->next = post_hook;
+	    post_hook->next = agoo_server.hooks;
+	    agoo_server.hooks = dump_hook;
 	}
 	if (Qnil != (v = rb_hash_lookup(options, ID2SYM(rb_intern("quiet"))))) {
 	    if (Qtrue == v) {
@@ -247,6 +249,8 @@ configure(agooErr err, int port, const char *root, VALUE options) {
  *   - *:worker_count* [_Integer_] number of workers to fork. Defaults to one which is not to fork.
  *
  *   - *:bind* [_String_|_Array_] a binding or array of binds. Examples are: "http ://127.0.0.1:6464", "unix:///tmp/agoo.socket", "http ://[::1]:6464, or to not restrict the address "http ://:6464".
+ *
+ *   - *:graphql* [_String_] path to GraphQL endpoint if support for GraphQL is desired.
  */
 static VALUE
 rserver_init(int argc, VALUE *argv, VALUE self) {
@@ -319,7 +323,7 @@ rescue_error(VALUE x) {
 
 static VALUE
 handle_base_inner(void *x) {
-    agooReq			req = (agooReq)x;
+    agooReq		req = (agooReq)x;
     volatile VALUE	rr = request_wrap(req);
     volatile VALUE	rres = response_new();
 
@@ -489,7 +493,6 @@ handle_rack_inner(void *x) {
 	    }
 	    req->hook = agoo_hook_create(AGOO_NONE, NULL, (void*)handler, PUSH_HOOK, &agoo_server.eval_queue);
 	    rupgraded_create(req->res->con, handler, request_env(req, Qnil));
-
 	    t->len = snprintf(t->text, 1024, "HTTP/1.1 101 %s\r\n", status_msg);
 	    t = agoo_ws_add_headers(req, t);
 	    break;
@@ -552,7 +555,7 @@ handle_rack(void *x) {
 
 static VALUE
 handle_wab_inner(void *x) {
-    agooReq			req = (agooReq)x;
+    agooReq		req = (agooReq)x;
     volatile VALUE	rr = request_wrap(req);
     volatile VALUE	rres = response_new();
 
@@ -756,10 +759,10 @@ rserver_start(VALUE self) {
 	rb_raise(rb_eStandardError, "%s", err.msg);
     }
     if (0 >= agoo_server.thread_cnt) {
-	agooReq		req;
+	agooReq	req;
 
 	while (agoo_server.active) {
-	    if (NULL != (req = (agooReq)agoo_queue_pop(&agoo_server.eval_queue, 0.1))) {
+	    if (NULL != (req = (agooReq)agoo_queue_pop(&agoo_server.eval_queue, 0.01))) { // TBD 0.1
 		handle_protected(req, false);
 		agoo_req_destroy(req);
 	    } else {
@@ -768,8 +771,7 @@ rserver_start(VALUE self) {
 
 	}
     } else {
-	the_rserver.eval_threads = (VALUE*)malloc(sizeof(VALUE) * (agoo_server.thread_cnt + 1));
-	DEBUG_ALLOC(mem_eval_threads, agoo_server.eval_threads);
+	the_rserver.eval_threads = (VALUE*)AGOO_MALLOC(sizeof(VALUE) * (agoo_server.thread_cnt + 1));
 
 	for (i = agoo_server.thread_cnt, vp = the_rserver.eval_threads; 0 < i; i--, vp++) {
 	    *vp = rb_thread_create(wrap_process_loop, NULL);
@@ -805,8 +807,7 @@ stop_runners() {
 	    }
 	    dsleep(0.02);
 	}
-	DEBUG_FREE(mem_eval_threads, the_rserver.eval_threads);
-	free(the_rserver.eval_threads);
+	AGOO_FREE(the_rserver.eval_threads);
 	the_rserver.eval_threads = NULL;
     }
 }

data/ext/agoo/sdl.c

@@ -3,35 +3,80 @@
 #include <stdio.h>
 #include <string.h>
 
+#include "debug.h"
 #include "doc.h"
 #include "gqlvalue.h"
 #include "graphql.h"
 #include "sdl.h"
 
+static const char	query_str[] = "query";
+static const char	union_str[] = "union";
+static const char	enum_str[] = "enum";
+static const char	mutation_str[] = "mutation";
+static const char	subscription_str[] = "subscription";
+static const char	interface_str[] = "interface";
+static const char	input_str[] = "input";
+static const char	type_str[] = "type";
+
+static int	make_sel(agooErr err, agooDoc doc, gqlDoc gdoc, gqlOp op, gqlSel *parentp);
+
 static int
-extract_name(agooErr err, agooDoc doc, const char *key, int klen, char *name, size_t max) {
-    const char	*start;
+extract_desc(agooErr err, agooDoc doc, const char **descp, size_t *lenp) {
+    agoo_doc_skip_white(doc);
+    *descp = NULL;
+    *lenp = 0;
+    if ('"' == *doc->cur) {
+	const char	*desc_end = NULL;
+	const char	*desc = doc->cur + 1;
+	
+    	if (AGOO_ERR_OK != agoo_doc_read_string(err, doc)) {
+	    return err->code;
+	}
+	if ('"' == *desc && '"' == desc[1]) { // must be a """
+	    desc += 2;
+	    desc_end = doc->cur - 3;
+	} else {
+	    desc_end = doc->cur - 1;
+	}
+	*descp = desc;
+	*lenp = desc_end - *descp;
+    }
+    return AGOO_ERR_OK;
+}
+
+static size_t
+read_name(agooErr err, agooDoc doc, char *name, size_t max) {
     size_t	nlen;
+    const char	*start = doc->cur;
 
-    if (0 != strncmp(doc->cur, key, klen)) {
-	return agoo_doc_err(doc, err, "Expected %s key word", key);
-    }
-    doc->cur += klen;
-    if (0 == agoo_doc_skip_white(doc)) {
-	return agoo_doc_err(doc, err, "Expected %s key word", key);
-    }
-    start = doc->cur;
     agoo_doc_read_token(doc);
     if (doc->cur == start) {
-	return agoo_doc_err(doc, err, "Name not provided");
+	agoo_doc_err(doc, err, "Name not provided");
+	return 0;
     }
     nlen = doc->cur - start;
     if (max <= nlen) {
-	return agoo_doc_err(doc, err, "Name too long");
+	agoo_doc_err(doc, err, "Name too long");
+	return 0;
     }
     strncpy(name, start, nlen);
     name[nlen] = '\0';
-    
+
+    return nlen;
+}
+
+static int
+extract_name(agooErr err, agooDoc doc, const char *key, int klen, char *name, size_t max) {
+    if (0 != strncmp(doc->cur, key, klen)) {
+	return agoo_doc_err(doc, err, "Expected %s key word", key);
+    }
+    doc->cur += klen;
+    if (0 == agoo_doc_skip_white(doc)) {
+	return agoo_doc_err(doc, err, "Expected %s key word", key);
+    }
+    if (0 == read_name(err, doc, name, max)) {
+	return err->code;
+    }
     return AGOO_ERR_OK;
 }
 
@@ -42,18 +87,126 @@ make_scalar(agooErr err, agooDoc doc, const char *desc, int len) {
     if (AGOO_ERR_OK != extract_name(err, doc, "scalar", 6, name, sizeof(name))) {
 	return err->code;
     }
-    gql_scalar_create(err, name, desc, len, false);
+    gql_scalar_create(err, name, desc, len);
     
     return AGOO_ERR_OK;
 }
 
 static int
-make_enum(agooErr err, agooDoc doc, const char *desc, int len) {
+read_type(agooErr err, agooDoc doc, gqlType *typep, bool *required) {
+    agoo_doc_skip_white(doc);
+    if ('[' == *doc->cur) {
+	gqlType	base;
+	bool	not_empty = false;
+
+	doc->cur++;
+	if (AGOO_ERR_OK != read_type(err, doc, &base, &not_empty)) {
+	    return err->code;
+	}
+	agoo_doc_skip_white(doc);
+	if (']' != *doc->cur) {
+	    return agoo_doc_err(doc, err, "List type not terminated with a ]");
+	}
+	doc->cur++;
+	if (NULL == (*typep = gql_assure_list(err, base, not_empty))) {
+	    return err->code;
+	}
+    } else {
+	char	name[256];
+
+	if (0 == read_name(err, doc, name, sizeof(name))) {
+	    return err->code;
+	}
+	if (NULL == (*typep = gql_assure_type(err, name))) {
+	    return err->code;
+	}
+    }
+    *required = false;
+    agoo_doc_skip_white(doc);
+    if ('!' == *doc->cur) {
+	*required = true;
+	doc->cur++;
+    }
+    return AGOO_ERR_OK;
+}
+
+static int
+make_use_arg(agooErr err, agooDoc doc, gqlDirUse use) {
+    char	name[256];
+    gqlValue	value = NULL;
+
+    if (0 == read_name(err, doc, name, sizeof(name))) {
+	return err->code;
+    }
+    agoo_doc_skip_white(doc);
+    if (':' != *doc->cur) {
+	return agoo_doc_err(doc, err, "Expected ':'");
+    }
+    doc->cur++;
+    if (NULL == (value = agoo_doc_read_value(err, doc, NULL))) {
+	return err->code;
+    }
+    if (AGOO_ERR_OK == gql_dir_use_arg(err, use, name, value)) {
+	return err->code;
+    }
+    return AGOO_ERR_OK;
+}
+
+static int
+extract_dir_use(agooErr err, agooDoc doc, gqlDirUse *uses) {
+    char	name[256];
+    gqlDirUse	use;
+
+    agoo_doc_skip_white(doc);
+    if ('@' != *doc->cur) {
+	return AGOO_ERR_OK;
+    }
+    doc->cur++;
+    if (0 == read_name(err, doc, name, sizeof(name))) {
+	return err->code;
+    }
+    if (NULL == (use = gql_dir_use_create(err, name))) {
+	return err->code;
+    }
+    agoo_doc_skip_white(doc);
+    if ('(' == *doc->cur) {
+	doc->cur++;
+	while (doc->cur < doc->end) {
+	    if (AGOO_ERR_OK != make_use_arg(err, doc, use)) {
+		return err->code;
+	    }
+	    agoo_doc_skip_white(doc);
+	    if (')' == *doc->cur) {
+		doc->cur++;
+		break;
+	    }
+	}
+    }
+    if (NULL == *uses) {
+	*uses = use;
+    } else {
+	gqlDirUse	u = *uses;
+
+	for (; NULL != u->next; u = u->next) {
+	}
+	u->next = use;
+    }
+    return AGOO_ERR_OK;
+}
+
+static int
+make_enum(agooErr err, agooDoc doc, const char *desc, size_t dlen) {
     char	name[256];
     const char	*start;
     gqlType	type;
+    gqlDirUse	uses = NULL;
+    gqlEnumVal	ev;
+    size_t	len;
     
-    if (AGOO_ERR_OK != extract_name(err, doc, "enum", 4, name, sizeof(name))) {
+    if (AGOO_ERR_OK != extract_name(err, doc, enum_str, sizeof(enum_str) - 1, name, sizeof(name))) {
+	return err->code;
+    }
+    if (AGOO_ERR_OK != extract_dir_use(err, doc, &uses)) {
 	return err->code;
     }
     agoo_doc_skip_white(doc);
@@ -62,13 +215,23 @@ make_enum(agooErr err, agooDoc doc, const char *desc, int len) {
     }
     doc->cur++;
 
-    if (NULL == (type = gql_enum_create(err, name, desc, len, false))) {
+    if (NULL == (type = gql_enum_create(err, name, desc, dlen))) {
 	return err->code;
     }
+    type->dir = uses;
     while (doc->cur < doc->end) {
-	agoo_doc_skip_white(doc);
+	desc = NULL;
+	uses = NULL;
+
+	if (AGOO_ERR_OK != extract_desc(err, doc, &desc, &dlen)) {
+	    return err->code;
+	}
 	start = doc->cur;
 	agoo_doc_read_token(doc);
+	len = doc->cur - start;
+	if (AGOO_ERR_OK != extract_dir_use(err, doc, &uses)) {
+	    return err->code;
+	}
 	if (doc->cur == start) {
 	    if ('}' == *doc->cur) {
 		doc->cur++;
@@ -76,9 +239,10 @@ make_enum(agooErr err, agooDoc doc, const char *desc, int len) {
 	    }
 	    return agoo_doc_err(doc, err, "Invalid Enum value");
 	}
-	if (AGOO_ERR_OK != gql_enum_add(err, type, start, (int)(doc->cur - start))) {
+	if (NULL == (ev = gql_enum_append(err, type, start, len, desc, dlen))) {
 	    return err->code;
 	}
+	ev->dir = uses;
     }
     return AGOO_ERR_OK;
 }
@@ -86,10 +250,15 @@ make_enum(agooErr err, agooDoc doc, const char *desc, int len) {
 static int
 make_union(agooErr err, agooDoc doc, const char *desc, int len) {
     char	name[256];
-    const char	*start;
     gqlType	type;
+    gqlDirUse	uses = NULL;
+    gqlType	member;
+    bool	required;
     
-    if (AGOO_ERR_OK != extract_name(err, doc, "union", 5, name, sizeof(name))) {
+    if (AGOO_ERR_OK != extract_name(err, doc, union_str, sizeof(union_str) - 1, name, sizeof(name))) {
+	return err->code;
+    }
+    if (AGOO_ERR_OK != extract_dir_use(err, doc, &uses)) {
 	return err->code;
     }
     agoo_doc_skip_white(doc);
@@ -99,14 +268,15 @@ make_union(agooErr err, agooDoc doc, const char *desc, int len) {
     doc->cur++;
     agoo_doc_skip_white(doc);
 
-    if (NULL == (type = gql_union_create(err, name, desc, len, false))) {
+    if (NULL == (type = gql_union_create(err, name, desc, len))) {
 	return err->code;
     }
+    type->dir = uses;
     while (doc->cur < doc->end) {
-	agoo_doc_skip_white(doc);
-	start = doc->cur;
-	agoo_doc_read_token(doc);
-	if (AGOO_ERR_OK != gql_union_add(err, type, start, (int)(doc->cur - start))) {
+	if (AGOO_ERR_OK != read_type(err, doc, &member, &required)) {
+	    return err->code;
+	}
+ 	if (AGOO_ERR_OK != gql_union_add(err, type, member)) {
 	    return err->code;
 	}
 	agoo_doc_skip_white(doc);
@@ -119,28 +289,19 @@ make_union(agooErr err, agooDoc doc, const char *desc, int len) {
 }
 
 static int
-make_arg(agooErr err, agooDoc doc, gqlDir dir) {
+make_dir_arg(agooErr err, agooDoc doc, gqlDir dir) {
     char	name[256];
     char	type_name[256];
+    gqlType	type;
     const char	*start;
     const char	*desc = NULL;
-    const char	*desc_end = NULL;
+    size_t	dlen;
     size_t	nlen;
     bool	required = false;
     gqlValue	dv = NULL;
-    
-    agoo_doc_skip_white(doc);
-    if ('"' == *doc->cur) {
-	desc = doc->cur + 1;
-	if (AGOO_ERR_OK != agoo_doc_read_string(err, doc)) {
-	    return err->code;
-	}
-	if ('"' == *desc) { // must be a """
-	    desc += 2;
-	    desc_end = doc->cur - 3;
-	} else {
-	    desc_end = doc->cur - 1;
-	}
+
+    if (AGOO_ERR_OK != extract_desc(err, doc, &desc, &dlen)) {
+	return err->code;
     }
     agoo_doc_skip_white(doc);
     start = doc->cur;
@@ -161,6 +322,7 @@ make_arg(agooErr err, agooDoc doc, gqlDir dir) {
 
     // read type
     agoo_doc_skip_white(doc);
+
     start = doc->cur;
     agoo_doc_read_token(doc);
     if (doc->cur == start) {
@@ -173,11 +335,15 @@ make_arg(agooErr err, agooDoc doc, gqlDir dir) {
     strncpy(type_name, start, nlen);
     type_name[nlen] = '\0';
 
+    if (NULL == (type = gql_assure_type(err, type_name))) {
+	return err->code;
+    }
     agoo_doc_skip_white(doc);
     if ('!' == *doc->cur) {
 	required = true;
+	doc->cur++;
     } else if ('=' == *doc->cur) {
-	if (NULL == (dv = agoo_doc_read_value(err, doc))) {
+	if (NULL == (dv = agoo_doc_read_value(err, doc, type))) {
 	    return err->code;
 	}
     }
@@ -185,7 +351,7 @@ make_arg(agooErr err, agooDoc doc, gqlDir dir) {
     if ('@' == *doc->cur) {
 	// TBD directive
     }
-    if (NULL == gql_dir_arg(err, dir, name, type_name, desc, (int)(desc_end - desc), dv, required)) {
+    if (NULL == gql_dir_arg(err, dir, name, type, desc, dlen, dv, required)) {
 	return err->code;
     }
     return AGOO_ERR_OK;
@@ -209,23 +375,16 @@ make_directive(agooErr err, agooDoc doc, const char *desc, int len) {
 	return agoo_doc_err(doc, err, "Expected '@'");
     }
     doc->cur++;
-    start = doc->cur;
-    agoo_doc_read_token(doc);
-    if (doc->cur == start) {
-	return agoo_doc_err(doc, err, "Name not provided");
-    }
-    nlen = doc->cur - start;
-    if (sizeof(name) <= nlen) {
-	return agoo_doc_err(doc, err, "Name too long");
+    if (0 == (nlen = read_name(err, doc, name, sizeof(name)))) {
+	return err->code;
     }
-    strncpy(name, start, nlen);
-    name[nlen] = '\0';
-    if (NULL == (dir = gql_directive_create(err, name, desc, len, false))) {
+    if (NULL == (dir = gql_directive_create(err, name, desc, len))) {
 	return err->code;
     }
     if ('(' == *doc->cur) {
+	doc->cur++;
 	while (doc->cur < doc->end) {
-	    if (AGOO_ERR_OK != make_arg(err, doc, dir)) {
+	    if (AGOO_ERR_OK != make_dir_arg(err, doc, dir)) {
 		return err->code;
 	    }
 	    agoo_doc_skip_white(doc);
@@ -258,77 +417,1062 @@ make_directive(agooErr err, agooDoc doc, const char *desc, int len) {
     return AGOO_ERR_OK;
 }
 
-int
-sdl_parse(agooErr err, const char *str, int len) {
-    struct _agooDoc	doc;
-    const char		*desc = NULL;
-    const char		*desc_end = NULL;
+static int
+make_field_arg(agooErr err, agooDoc doc, gqlField field) {
+    char	name[256];
+    gqlType	type;
+    const char	*desc = NULL;
+    size_t	dlen;
+    bool 	required = false;
+    gqlValue	dval = NULL;
     
-    agoo_doc_init(&doc, str, len);
+    if (AGOO_ERR_OK != extract_desc(err, doc, &desc, &dlen)) {
+	return err->code;
+    }
+    agoo_doc_skip_white(doc);
+    if (0 == read_name(err, doc, name, sizeof(name))) {
+	return err->code;
+    }
+    agoo_doc_skip_white(doc);
+    if (':' != *doc->cur) {
+	return agoo_doc_err(doc, err, "Expected :");
+    }
+    doc->cur++;
+    
+    if (AGOO_ERR_OK != read_type(err, doc, &type, &required)) {
+	return err->code;
+    }
+    agoo_doc_skip_white(doc);
 
-    while (doc.cur < doc.end) {
-	agoo_doc_next_token(&doc);
-	switch (*doc.cur) {
-	case '"':
-	    desc = doc.cur + 1;
-	    if (AGOO_ERR_OK != agoo_doc_read_string(err, &doc)) {
-		return err->code;
-	    }
-	    if ('"' == *desc) { // must be a """
-		desc += 2;
-		desc_end = doc.cur - 3;
-	    } else {
-		desc_end = doc.cur - 1;
-	    }
-	    break;
-	case 's': // scalar
-	    if (AGOO_ERR_OK != make_scalar(err, &doc, desc, (int)(desc_end - desc))) {
-		return err->code;
-	    }
-	    break;
-	case 'e': // enum, and extend interface or type
-	    if (4 < (doc.end - doc.cur)) {
-		if ('n' == doc.cur[1]) {
-		    if (AGOO_ERR_OK != make_enum(err, &doc, desc, (int)(desc_end - desc))) {
-			return err->code;
-		    }
-		    break;
-		} else {
-		    // TBD extend
-		    break;
-		}
-	    }
-	    return agoo_doc_err(&doc, err, "Unknown directive");
-	case 'u': // union
-	    if (AGOO_ERR_OK != make_union(err, &doc, desc, (int)(desc_end - desc))) {
-		return err->code;
-	    }
-	    break;
-	case 'd': // directive
-	    if (AGOO_ERR_OK != make_directive(err, &doc, desc, (int)(desc_end - desc))) {
+    switch (*doc->cur) {
+    case '=':
+	if (NULL == (dval = agoo_doc_read_value(err, doc, type))) {
+	    return err->code;
+	}
+	break;
+    case '@':
+	// TBD read directives
+	break;
+    default: // ) or next arg
+	break;
+    }
+    if (NULL == gql_field_arg(err, field, name, type, desc, dlen, dval, required)) {
+	return err->code;
+    }
+    return AGOO_ERR_OK;
+}
+
+static int
+make_field(agooErr err, agooDoc doc, gqlType type, bool allow_args) {
+    char	name[256];
+    gqlType	return_type;
+    const char	*arg_start = NULL;
+    gqlField	field;
+    gqlDirUse	uses = NULL;
+    gqlValue	dval = NULL;
+    const char	*desc = NULL;
+    size_t	dlen;
+    bool 	required = false;
+
+    if (AGOO_ERR_OK != extract_desc(err, doc, &desc, &dlen)) {
+	return err->code;
+    }
+    if (0 == read_name(err, doc, name, sizeof(name))) {
+	return err->code;
+    }
+    agoo_doc_skip_white(doc);
+    switch (*doc->cur) {
+    case '(':
+	if (!allow_args) {
+	    return agoo_doc_err(doc, err, "Input fields can not have arguments.");
+	}
+	doc->cur++;
+	arg_start = doc->cur;
+	if (!agoo_doc_skip_to(doc, ')')) {
+	    return agoo_doc_err(doc, err, "Argument list not terminated with a )");
+	}
+	doc->cur++;
+	agoo_doc_skip_white(doc);
+	if (':' != *doc->cur) {
+	    return agoo_doc_err(doc, err, "Expected :");
+	}
+	doc->cur++;
+	break;
+    case ':':
+	doc->cur++;
+	// okay
+	break;
+    default:
+	return agoo_doc_err(doc, err, "Expected : or (");
+    }
+    if (AGOO_ERR_OK != read_type(err, doc, &return_type, &required)) {
+	return err->code;
+    }
+    if ('=' == *doc->cur) {
+	doc->cur++;
+	if (NULL == (dval = agoo_doc_read_value(err, doc, return_type))) {
+	    return err->code;
+	}
+    }
+    if (AGOO_ERR_OK != extract_dir_use(err, doc, &uses)) {
+	return err->code;
+    }
+    if (NULL == (field = gql_type_field(err, type, name, return_type, dval, desc, dlen, required))) {
+	return err->code;
+    }
+    field->dir = uses;
+    if (NULL != arg_start) {
+	const char	*cur = doc->cur;
+
+	doc->cur = arg_start;
+	while (true) {
+	    if (AGOO_ERR_OK != make_field_arg(err, doc, field)) {
 		return err->code;
 	    }
-	    break;
-	case 't': // type
-	    break;
-	case 'i': // interface, input
-	    if (5 < (doc.end - doc.cur) && 'n' == doc.cur[1]) {
-		if ('p' == doc.cur[2]) {
-		    // input
-		    break;
-		} else {
-		    // TBD interface
-		    break;
-		}
+	    agoo_doc_skip_white(doc);
+	    if (')' == *doc->cur) {
+		break;
 	    }
-	    return agoo_doc_err(&doc, err, "Unknown directive");
-	case 'f': // fragment
-	    break;
-	case '\0':
-	    return AGOO_ERR_OK;
-	default:
-	    return agoo_doc_err(&doc, err, "Unknown directive");
 	}
+	doc->cur = cur;
     }
     return AGOO_ERR_OK;
 }
+
+static int
+make_interface(agooErr err, agooDoc doc, const char *desc, int len) {
+    char	name[256];
+    gqlType	type;
+    gqlDirUse	uses = NULL;
+    
+    if (AGOO_ERR_OK != extract_name(err, doc, interface_str, sizeof(interface_str) - 1, name, sizeof(name))) {
+	return err->code;
+    }
+    if (AGOO_ERR_OK != extract_dir_use(err, doc, &uses)) {
+	return err->code;
+    }
+    agoo_doc_skip_white(doc);
+    if ('{' != *doc->cur) {
+	return agoo_doc_err(doc, err, "Expected '{'");
+    }
+    doc->cur++;
+    agoo_doc_skip_white(doc);
+
+    if (NULL == (type = gql_interface_create(err, name, desc, len))) {
+	return err->code;
+    }
+    type->dir = uses;
+    while (doc->cur < doc->end) {
+	if ('}' == *doc->cur) {
+	    doc->cur++; // skip }
+	    break;
+	}
+	if (AGOO_ERR_OK != make_field(err, doc, type, true)) {
+	    return err->code;
+	}
+	agoo_doc_skip_white(doc);
+    }
+    return AGOO_ERR_OK;
+}
+
+static int
+make_input(agooErr err, agooDoc doc, const char *desc, int len) {
+    char	name[256];
+    gqlType	type;
+    gqlDirUse	uses = NULL;
+
+    if (AGOO_ERR_OK != extract_name(err, doc, input_str, sizeof(input_str) - 1, name, sizeof(name))) {
+	return err->code;
+    }
+    if (AGOO_ERR_OK != extract_dir_use(err, doc, &uses)) {
+	return err->code;
+    }
+    agoo_doc_skip_white(doc);
+    if ('{' != *doc->cur) {
+	return agoo_doc_err(doc, err, "Expected '{'");
+    }
+    doc->cur++;
+    agoo_doc_skip_white(doc);
+
+    if (NULL == (type = gql_input_create(err, name, desc, len))) {
+	return err->code;
+    }
+    type->dir = uses;
+
+    while (doc->cur < doc->end) {
+	if ('}' == *doc->cur) {
+	    doc->cur++; // skip }
+	    break;
+	}
+	if (AGOO_ERR_OK != make_field(err, doc, type, false)) {
+	    return err->code;
+	}
+	agoo_doc_skip_white(doc);
+    }
+    return AGOO_ERR_OK;
+}
+
+static int
+extract_interfaces(agooErr err, agooDoc doc, gqlTypeLink *interfacesp) {
+    gqlType	type;
+    gqlTypeLink	link;
+    bool	required;
+    bool	first = true;
+
+    agoo_doc_skip_white(doc);
+    if (0 != strncmp("implements", doc->cur, 10)) {
+	return AGOO_ERR_OK;
+    }
+    doc->cur += 10;
+    if (0 == agoo_doc_skip_white(doc)) {
+	return agoo_doc_err(doc, err, "Expected white after 'implements'");
+    }
+    while (doc->cur < doc->end) {
+	agoo_doc_skip_white(doc);
+	if ('{' == *doc->cur || '@' == *doc->cur) {
+	    break;
+	}
+	if ('&' == *doc->cur) {
+	    doc->cur++;
+	    agoo_doc_skip_white(doc);
+	} else if (!first) {
+	    return agoo_doc_err(doc, err, "Expected &");
+	}
+	first = false;
+	required = false;
+	type = NULL;
+    	if (AGOO_ERR_OK != read_type(err, doc, &type, &required)) {
+	    return err->code;
+	}
+	if (NULL == (link = (gqlTypeLink)AGOO_MALLOC(sizeof(struct _gqlTypeLink)))) {
+	    return agoo_err_set(err, AGOO_ERR_MEMORY, "Failed to allocation memory for a GraphQL interface.");
+	}
+	link->next = NULL;
+	link->type = type;
+	if (NULL == *interfacesp) {
+	    *interfacesp = link;
+	} else {
+	    gqlTypeLink	tl = *interfacesp;
+
+	    for (; NULL != tl->next; tl = tl->next) {
+	    }
+	    tl->next = link;
+	}
+    }
+    return AGOO_ERR_OK;
+}
+
+static int
+make_type(agooErr err, agooDoc doc, const char *desc, int len) {
+    char	name[256];
+    gqlType	type;
+    gqlDirUse	uses = NULL;
+    gqlTypeLink	interfaces = NULL;
+
+    if (AGOO_ERR_OK != extract_name(err, doc, type_str, sizeof(type_str) - 1, name, sizeof(name))) {
+	return err->code;
+    }
+    if (AGOO_ERR_OK != extract_interfaces(err, doc, &interfaces)) {
+	return err->code;
+    }
+    if (AGOO_ERR_OK != extract_dir_use(err, doc, &uses)) {
+	return err->code;
+    }
+    agoo_doc_skip_white(doc);
+    if ('{' != *doc->cur) {
+	return agoo_doc_err(doc, err, "Expected '{'");
+    }
+    doc->cur++;
+    agoo_doc_skip_white(doc);
+
+    if (NULL == (type = gql_type_create(err, name, desc, len, interfaces))) {
+	return err->code;
+    }
+    type->dir = uses;
+
+    while (doc->cur < doc->end) {
+	if ('}' == *doc->cur) {
+	    doc->cur++; // skip }
+	    break;
+	}
+	if (AGOO_ERR_OK != make_field(err, doc, type, true)) {
+	    return err->code;
+	}
+	agoo_doc_skip_white(doc);
+    }
+    return AGOO_ERR_OK;
+}
+
+int
+sdl_parse(agooErr err, const char *str, int len) {
+    struct _agooDoc	doc;
+    const char		*desc = NULL;
+    size_t		dlen = 0;
+    
+    agoo_doc_init(&doc, str, len);
+
+    while (doc.cur < doc.end) {
+	agoo_doc_next_token(&doc);
+	switch (*doc.cur) {
+	case '"':
+	    if (AGOO_ERR_OK != extract_desc(err, &doc, &desc, &dlen)) {
+		return err->code;
+	    }
+	    break;
+	case 's': // scalar
+	    if (AGOO_ERR_OK != make_scalar(err, &doc, desc, dlen)) {
+		return err->code;
+	    }
+	    desc = NULL;
+	    dlen = 0;
+	    break;
+	case 'e': // enum, and extend interface or type
+	    if (4 < (doc.end - doc.cur)) {
+		if ('n' == doc.cur[1]) {
+		    if (AGOO_ERR_OK != make_enum(err, &doc, desc, dlen)) {
+			return err->code;
+		    }
+		    desc = NULL;
+		    dlen = 0;
+		    break;
+		} else {
+		    // TBD extend
+		    desc = NULL;
+		    dlen = 0;
+		    break;
+		}
+	    }
+	    return agoo_doc_err(&doc, err, "Unknown directive");
+	case 'u': // union
+	    if (AGOO_ERR_OK != make_union(err, &doc, desc, dlen)) {
+		return err->code;
+	    }
+	    desc = NULL;
+	    dlen = 0;
+	    break;
+	case 'd': // directive
+	    if (AGOO_ERR_OK != make_directive(err, &doc, desc, dlen)) {
+		return err->code;
+	    }
+	    desc = NULL;
+	    dlen = 0;
+	    break;
+	case 't': // type
+	    if (AGOO_ERR_OK != make_type(err, &doc, desc, dlen)) {
+		return err->code;
+	    }
+	    desc = NULL;
+	    dlen = 0;
+	    break;
+	case 'i': // interface, input
+	    if (5 < (doc.end - doc.cur) && 'n' == doc.cur[1]) {
+		if ('p' == doc.cur[2]) {
+		    if (AGOO_ERR_OK != make_input(err, &doc, desc, dlen)) {
+			return err->code;
+		    }	
+		    desc = NULL;
+		    dlen = 0;
+		    break;
+		} else {
+		    if (AGOO_ERR_OK != make_interface(err, &doc, desc, dlen)) {
+			return err->code;
+		    }
+		    desc = NULL;
+		    dlen = 0;
+		    break;
+		}
+	    }
+	    return agoo_doc_err(&doc, err, "Unknown directive");
+	case '\0':
+	    return AGOO_ERR_OK;
+	default:
+	    return agoo_doc_err(&doc, err, "Unknown directive");
+	}
+    }
+    return AGOO_ERR_OK;
+}
+
+// Parse Execution Definition.
+
+static gqlSelArg
+sel_arg_create(agooErr err, const char *name, gqlValue value, gqlVar var) {
+    gqlSelArg	arg;
+
+    if (NULL == (arg = (gqlSelArg)AGOO_MALLOC(sizeof(struct _gqlSelArg)))) {
+	agoo_err_set(err, AGOO_ERR_MEMORY, "Failed to allocation memory for a selection field argument.");
+    } else {
+	arg->next = NULL;
+	if (NULL == (arg->name = AGOO_STRDUP(name))) {
+	    agoo_err_set(err, AGOO_ERR_MEMORY, "strdup of field name failed. %s:%d", __FILE__, __LINE__);
+	    return NULL;
+	}
+	arg->var = var;
+	arg->value = value;
+    }
+    return arg;
+}
+static int
+make_sel_arg(agooErr err, agooDoc doc, gqlDoc gdoc, gqlOp op, gqlSel sel) {
+    char	name[256];
+    gqlValue	value = NULL;
+    gqlVar	var = NULL;
+    gqlSelArg	arg;
+    
+    agoo_doc_skip_white(doc);
+    if (0 == read_name(err, doc, name, sizeof(name))) {
+	return err->code;
+    }
+    agoo_doc_skip_white(doc);
+    if (':' != *doc->cur) {
+	return agoo_doc_err(doc, err, "Expected :");
+    }
+    doc->cur++;
+    agoo_doc_skip_white(doc);
+    if ('$' == *doc->cur && NULL != op) {
+	char	var_name[256];
+	
+	doc->cur++;
+	if (0 == read_name(err, doc, var_name, sizeof(var_name))) {
+	    return err->code;
+	}
+	for (var = op->vars; NULL != var; var = var->next) {
+	    if (0 == strcmp(var_name, var->name)) {
+		break;
+	    }
+	}
+	if (NULL == var) {
+	    for (var = gdoc->vars; NULL != var; var = var->next) {
+		if (0 == strcmp(var_name, var->name)) {
+		    break;
+		}
+	    }
+	}
+	if (NULL == var) {
+	    return agoo_doc_err(doc, err, "variable $%s not defined for operation or document", var_name);
+	}
+    } else if (NULL == (value = agoo_doc_read_value(err, doc, NULL))) {
+	return err->code;
+    }
+    if (NULL == (arg = sel_arg_create(err, name, value, var))) {
+	return err->code;
+    }
+    if (NULL == sel->args) {
+	sel->args = arg;
+    } else {
+	gqlSelArg	a;
+
+	for (a = sel->args; NULL != a->next; a = a->next) {
+	}
+	a->next = arg;
+    }
+    return AGOO_ERR_OK;
+}
+
+gqlVar
+gql_op_var_create(agooErr err, const char *name, gqlType type, gqlValue value) {
+    gqlVar	var;
+
+    if (NULL == (var = (gqlVar)AGOO_MALLOC(sizeof(struct _gqlVar)))) {
+	agoo_err_set(err, AGOO_ERR_MEMORY, "Failed to allocation memory for a operation variable.");
+    } else {
+	var->next = NULL;
+	if (NULL == (var->name = AGOO_STRDUP(name))) {
+	    agoo_err_set(err, AGOO_ERR_MEMORY, "strdup of variable name failed. %s:%d", __FILE__, __LINE__);
+	    return NULL;
+	}
+	var->type = type;
+	var->value = value;
+    }
+    return var;
+}
+
+static int
+make_op_var(agooErr err, agooDoc doc, gqlOp op) {
+    char	name[256];
+    gqlType	type;
+    bool	ignore;
+    gqlValue	value = NULL;
+    gqlVar	var;
+    
+    agoo_doc_skip_white(doc);
+    if ('$' != *doc->cur) {
+	return agoo_doc_err(doc, err, "Expected $");
+    }
+    doc->cur++;
+    if (0 == read_name(err, doc, name, sizeof(name))) {
+	return err->code;
+    }
+    agoo_doc_skip_white(doc);
+    if (':' != *doc->cur) {
+	return agoo_doc_err(doc, err, "Expected :");
+    }
+    doc->cur++;
+    
+    if (AGOO_ERR_OK != read_type(err, doc, &type, &ignore)) {
+	return err->code;
+    }
+    agoo_doc_skip_white(doc);
+
+    if ('=' == *doc->cur) {
+	doc->cur++;
+	if (NULL == (value = agoo_doc_read_value(err, doc, type))) {
+	    return err->code;
+	}
+    }
+    if (NULL == (var = gql_op_var_create(err, name, type, value))) {
+	return err->code;
+    }
+    if (NULL == op->vars) {
+	op->vars = var;
+    } else {
+	gqlVar	v;
+
+	for (v = op->vars; NULL != v->next; v = v->next) {
+	}
+	v->next = var;
+    }
+    return AGOO_ERR_OK;
+}
+
+static gqlSel
+sel_create(agooErr err, const char *alias, const char *name, const char *frag) {
+    gqlSel	sel;
+
+    if (NULL == (sel = (gqlSel)AGOO_MALLOC(sizeof(struct _gqlSel)))) {
+	agoo_err_set(err, AGOO_ERR_MEMORY, "Failed to allocation memory for a selection set.");
+    } else {
+	sel->next = NULL;
+	if (NULL == name) {
+	    sel->name = NULL;
+	} else {
+	    if (NULL == (sel->name = AGOO_STRDUP(name))) {
+		agoo_err_set(err, AGOO_ERR_MEMORY, "strdup of selection name failed. %s:%d", __FILE__, __LINE__);
+		return NULL;
+	    }
+	}
+	if (NULL == alias) {
+	    sel->alias = NULL;
+	} else {
+	    if (NULL == (sel->alias = AGOO_STRDUP(alias))) {
+		agoo_err_set(err, AGOO_ERR_MEMORY, "strdup of selection alias failed. %s:%d", __FILE__, __LINE__);
+		return NULL;
+	    }
+	}
+	if (NULL == frag) {
+	    sel->frag = NULL;
+	} else {
+	    if (NULL == (sel->frag = AGOO_STRDUP(frag))) {
+		agoo_err_set(err, AGOO_ERR_MEMORY, "strdup of selection fragment failed. %s:%d", __FILE__, __LINE__);
+		return NULL;
+	    }
+	}
+	sel->type = NULL;
+	sel->dir = NULL;
+    	sel->args = NULL;
+	sel->sels = NULL;
+	sel->inline_frag = NULL;
+    }
+    return sel;
+}    
+
+static gqlSel
+make_sel_inline(agooErr err, agooDoc doc, gqlDoc gdoc, gqlOp op) {
+    gqlSel	sel = NULL;
+
+    doc->cur += 3;
+    agoo_doc_skip_white(doc);
+    if ('o' == *doc->cur && 'n' == doc->cur[1]) { // inline fragment
+	char	type_name[256];
+	    
+	doc->cur += 2;
+	agoo_doc_skip_white(doc);
+	if (0 == read_name(err, doc, type_name, sizeof(type_name))) {
+	    return NULL;
+	}
+	if (NULL == (sel = sel_create(err, NULL, NULL, NULL))) {
+	    return NULL;
+	}
+	if (NULL == (sel->inline_frag = gql_fragment_create(err, NULL, gql_assure_type(err, type_name)))) {
+	    return NULL;
+	}
+	if (AGOO_ERR_OK != extract_dir_use(err, doc, &sel->dir)) {
+	    return NULL;
+	}
+	agoo_doc_skip_white(doc);
+	if ('{' == *doc->cur) {
+	    doc->cur++;
+	    while (doc->cur < doc->end) {
+		agoo_doc_skip_white(doc);
+		if ('}' == *doc->cur) {
+		    doc->cur++;
+		    break;
+		}
+		if (AGOO_ERR_OK != make_sel(err, doc, gdoc, op, &sel->inline_frag->sels)) {
+		    return NULL;
+		}
+	    }
+	    if (doc->end <= doc->cur && '}' != doc->cur[-1]) {
+		agoo_doc_err(doc, err, "Expected a }");
+		return NULL;
+	    }
+	}
+    } else if ('@' == *doc->cur) {
+	if (NULL == (sel = sel_create(err, NULL, NULL, NULL))) {
+	    return NULL;
+	}
+	if (NULL == (sel->inline_frag = gql_fragment_create(err, NULL, NULL))) {
+	    return NULL;
+	}
+	if (AGOO_ERR_OK != extract_dir_use(err, doc, &sel->inline_frag->dir)) {
+	    return NULL;
+	}
+	agoo_doc_skip_white(doc);
+	if ('{' == *doc->cur) {
+	    doc->cur++;
+	    while (doc->cur < doc->end) {
+		agoo_doc_skip_white(doc);
+		if ('}' == *doc->cur) {
+		    doc->cur++;
+		    break;
+		}
+		if (AGOO_ERR_OK != make_sel(err, doc, gdoc, op, &sel->inline_frag->sels)) {
+		    return NULL;
+		}
+	    }
+	    if (doc->end <= doc->cur && '}' != doc->cur[-1]) {
+		agoo_doc_err(doc, err, "Expected a }");
+		return NULL;
+	    }
+	}
+    } else { // reference to a fragment
+	char	frag_name[256];
+
+	if (0 == read_name(err, doc, frag_name, sizeof(frag_name))) {
+	    return NULL;
+	}
+	sel = sel_create(err, NULL, NULL, frag_name);
+    }
+    return sel;
+}
+
+static int
+make_sel(agooErr err, agooDoc doc, gqlDoc gdoc, gqlOp op, gqlSel *parentp) {
+    char	alias[256];
+    char	name[256];
+    gqlSel	sel = NULL;
+
+    if (NULL == op && NULL == parentp) {
+	return agoo_doc_err(doc, err, "Fields can only be in a fragment, operation, or another field.");
+    }
+    *alias = '\0';
+    *name = '\0';
+    agoo_doc_skip_white(doc);
+    if ('.' == *doc->cur && '.' == doc->cur[1] && '.' == doc->cur[2]) {
+	if (NULL == (sel = make_sel_inline(err, doc, gdoc, op))) {
+	    return err->code;
+	}
+    } else {
+	if (0 == read_name(err, doc, alias, sizeof(alias))) {
+	    return err->code;
+	}
+	agoo_doc_skip_white(doc);
+	if (':' == *doc->cur) {
+	    doc->cur++;
+	    agoo_doc_skip_white(doc);
+	    if (0 == read_name(err, doc, name, sizeof(name))) {
+		return err->code;
+	    }
+	    agoo_doc_skip_white(doc);
+	}
+
+	if ('\0' == *name) { // no alias
+	    sel = sel_create(err, NULL, alias, NULL);
+	} else {
+	    sel = sel_create(err, alias, name, NULL);
+	}
+    }
+    if (NULL == sel) {
+	return err->code;
+    }
+    if (NULL == parentp) {
+	if (NULL == op->sels) {
+	    op->sels = sel;
+	} else {
+	    gqlSel	s;
+
+	    for (s = op->sels; NULL != s->next; s = s->next) {
+	    }
+	    s->next = sel;
+	}
+    } else {
+	if (NULL == *parentp) {
+	    *parentp = sel;
+	} else {
+	    gqlSel	s;
+
+	    for (s = *parentp; NULL != s->next; s = s->next) {
+	    }
+	    s->next = sel;
+	}
+    }
+    if (NULL == sel->frag && '(' == *doc->cur) {
+	doc->cur++;
+	while (doc->cur < doc->end) {
+	    agoo_doc_skip_white(doc);
+	    if (')' == *doc->cur) {
+		doc->cur++;
+		break;
+	    }
+	    if (AGOO_ERR_OK != make_sel_arg(err, doc, gdoc, op, sel)) {
+		return err->code;
+	    }
+	}
+	agoo_doc_skip_white(doc);
+    }
+    if (AGOO_ERR_OK != extract_dir_use(err, doc, &sel->dir)) {
+	return err->code;
+    }
+    if (NULL == sel->frag && '{' == *doc->cur) {
+	doc->cur++;
+	while (doc->cur < doc->end) {
+	    agoo_doc_skip_white(doc);
+	    if ('}' == *doc->cur) {
+		doc->cur++;
+		break;
+	    }
+	    if (AGOO_ERR_OK != make_sel(err, doc, gdoc, op, &sel->sels)) {
+		return err->code;
+	    }
+	}
+	if (doc->end <= doc->cur && '}' != doc->cur[-1]) {
+	    return agoo_doc_err(doc, err, "Expected a }");
+	}
+    }
+    return AGOO_ERR_OK;
+}
+
+
+static int
+make_op(agooErr err, agooDoc doc, gqlDoc gdoc) {
+    char	name[256];
+    const char	*start;
+    gqlOpKind	kind;
+    gqlOp	op;
+    size_t	nlen;
+
+    agoo_doc_skip_white(doc);
+    start = doc->cur;
+    agoo_doc_read_token(doc);
+    if (doc->cur == start ||
+	(5 == (doc->cur - start) && 0 == strncmp(query_str, start, sizeof(query_str) - 1))) {
+	kind = GQL_QUERY;
+    } else if (8 == (doc->cur - start) && 0 == strncmp(mutation_str, start, sizeof(mutation_str) - 1)) {
+	kind = GQL_MUTATION;
+    } else if (12 == (doc->cur - start) && 0 == strncmp(subscription_str, start, sizeof(subscription_str) - 1)) {
+	kind = GQL_SUBSCRIPTION;
+    } else {
+	return agoo_doc_err(doc, err, "Invalid operation type");
+    }
+    agoo_doc_skip_white(doc);
+    start = doc->cur;
+    agoo_doc_read_token(doc);
+    nlen = doc->cur - start;
+    if (sizeof(name) <= nlen) {
+	agoo_doc_err(doc, err, "Name too long");
+	return err->code;
+    }
+    if (0 < nlen) {
+	strncpy(name, start, nlen);
+    }
+    name[nlen] = '\0';
+    if (NULL == (op = gql_op_create(err, name, kind))) {
+	return err->code;
+    }
+    agoo_doc_skip_white(doc);
+    if ('(' == *doc->cur) {
+	doc->cur++;
+	while (doc->cur < doc->end) {
+	    agoo_doc_skip_white(doc);
+	    if (')' == *doc->cur) {
+		doc->cur++;
+		break;
+	    }
+	    if (AGOO_ERR_OK != make_op_var(err, doc, op)) {
+		return err->code;
+	    }
+	}
+	agoo_doc_skip_white(doc);
+    }
+    if (AGOO_ERR_OK != extract_dir_use(err, doc, &op->dir)) {
+	return err->code;
+    }
+    if ('{' != *doc->cur) {
+	return agoo_doc_err(doc, err, "Expected a {");
+    }
+    doc->cur++;
+    while (doc->cur < doc->end) {
+	agoo_doc_skip_white(doc);
+	if ('}' == *doc->cur) {
+	    doc->cur++;
+	    break;
+	}
+	if (AGOO_ERR_OK != make_sel(err, doc, gdoc, op, NULL)) {
+	    return err->code;
+	}
+    }
+    if (doc->end <= doc->cur && '}' != doc->cur[-1]) {
+	return agoo_doc_err(doc, err, "Expected a }");
+    }
+    if (NULL == gdoc->ops) {
+	gdoc->ops = op;
+    } else {
+	gqlOp	o;
+
+	for (o = gdoc->ops; NULL != o->next; o = o->next) {
+	}
+	o->next = op;
+    }
+    return AGOO_ERR_OK;
+}
+
+static int
+make_fragment(agooErr err, agooDoc doc, gqlDoc gdoc) {
+    char	name[256];
+    char	type_name[256];
+    const char	*start;
+    gqlFrag	frag;
+
+    agoo_doc_skip_white(doc);
+    start = doc->cur;
+    agoo_doc_read_token(doc);
+    if (8 != (doc->cur - start) || 0 != strncmp("fragment", start, 8)) {
+	agoo_doc_err(doc, err, "Expected the key word 'fragment'.");
+    }
+    agoo_doc_skip_white(doc);
+    if (0 == read_name(err, doc, name, sizeof(name))) {
+	return err->code;
+    }
+    agoo_doc_skip_white(doc);
+    start = doc->cur;
+    agoo_doc_read_token(doc);
+    if (2 != (doc->cur - start) || 0 != strncmp("on", start, 2)) {
+	agoo_doc_err(doc, err, "Expected the key word 'on'.");
+    }
+    agoo_doc_skip_white(doc);
+    if (0 == read_name(err, doc, type_name, sizeof(type_name))) {
+	return err->code;
+    }
+    agoo_doc_skip_white(doc);
+
+    if (NULL == (frag = gql_fragment_create(err, name, gql_assure_type(err, type_name)))) {
+	return err->code;
+    }
+    if (AGOO_ERR_OK != extract_dir_use(err, doc, &frag->dir)) {
+	return err->code;
+    }
+    if ('{' != *doc->cur) {
+	return agoo_doc_err(doc, err, "Expected a {");
+    }
+    doc->cur++;
+
+    while (doc->cur < doc->end) {
+	agoo_doc_skip_white(doc);
+	if ('}' == *doc->cur) {
+	    doc->cur++;
+	    break;
+	}
+	if (AGOO_ERR_OK != make_sel(err, doc, gdoc, NULL, &frag->sels)) {
+	    return err->code;
+	}
+    }
+    if (doc->end <= doc->cur  && '}' != doc->cur[-1]) {
+	return agoo_doc_err(doc, err, "Expected a }");
+    }
+    if (NULL == gdoc->frags) {
+	gdoc->frags = frag;
+    } else {
+	gqlFrag	f;
+
+	for (f = gdoc->frags; NULL != f->next; f = f->next) {
+	}
+	f->next = frag;
+    }
+    return AGOO_ERR_OK;
+}
+
+static gqlType
+lookup_field_type(gqlType type, const char *field, bool qroot) {
+    gqlType	ftype = NULL;
+    
+    switch (type->kind) {
+    case GQL_OBJECT:
+    case GQL_INPUT:
+    case GQL_INTERFACE: {
+	gqlField	f;
+
+	for (f = type->fields; NULL != f; f = f->next) {
+	    if (0 == strcmp(field, f->name)) {
+		ftype = f->type;
+		break;
+	    }
+	}
+	if (NULL == ftype) {
+	    if (0 == strcmp("__typename", field)) {
+		ftype = &gql_string_type;
+	    } else if (qroot) {
+		if (0 == strcmp("__type", field)) {
+		    ftype = gql_type_get("__Type");
+		} else if (0 == strcmp("__schema", field)) {
+		    ftype = gql_type_get("__Schema");
+		}
+	    }
+	}
+	break;
+    }
+    case GQL_LIST:
+	ftype = lookup_field_type(type->base, field, false);
+	break;
+    case GQL_UNION: // Can not be used directly for query type determinations.
+    default:
+	break;
+    }
+    return ftype;
+}
+
+static int
+sel_set_type(agooErr err, gqlType type, gqlSel sels, bool qroot) {
+    gqlSel	sel;
+    
+    for (sel = sels; NULL != sel; sel = sel->next) {
+	if (NULL == sel->name) { // inline or fragment
+	    sel->type = type;
+	    if (NULL != sel->inline_frag) {
+		gqlType	ftype = type;
+
+		if (NULL != sel->inline_frag->on) {
+		    ftype = sel->inline_frag->on;
+		}
+		if (AGOO_ERR_OK != sel_set_type(err, ftype, sel->inline_frag->sels, false)) {
+		    return err->code;
+		}
+	    }
+	} else {
+	    if (NULL == (sel->type = lookup_field_type(type, sel->name, qroot))) {
+		return agoo_err_set(err, AGOO_ERR_EVAL, "Failed to determine the type for %s.", sel->name);
+	    }
+	}
+	if (NULL != sel->sels) {
+	    if (AGOO_ERR_OK != sel_set_type(err, sel->type, sel->sels, false)) {
+		return err->code;
+	    }
+	}
+    }
+    return AGOO_ERR_OK;
+}
+
+static int
+validate_doc(agooErr err, gqlDoc doc) {
+    gqlOp	op;
+    gqlType	schema;
+    gqlType	type = NULL;
+    gqlFrag	frag;
+    int		cnt;
+    
+    if (NULL == (schema = gql_type_get("schema"))) {
+	return agoo_err_set(err, AGOO_ERR_EVAL, "No root (schema) type defined.");
+    }
+    for (frag = doc->frags; NULL != frag; frag = frag->next) {
+	if (AGOO_ERR_OK != sel_set_type(err, frag->on, frag->sels, false)) {
+	    return err->code;
+	}
+    }
+    cnt = 0;
+    for (op = doc->ops; NULL != op; op = op->next) {
+	if (NULL == op->name) {
+	    cnt++;
+	    if (1 < cnt) {
+		return agoo_err_set(err, AGOO_ERR_EVAL, "Multiple un-named operation.");
+	    }
+	} else {
+	    gqlOp	o2 = op->next;
+	    
+	    for (; NULL != o2; o2 = o2->next) {
+		if (NULL == o2->name) {
+		    continue;
+		}
+		if (0 == strcmp(o2->name, op->name)) {
+		    return agoo_err_set(err, AGOO_ERR_EVAL, "Multiple operation named '%s'.", op->name);
+		}
+	    }
+	}
+    }
+    for (op = doc->ops; NULL != op; op = op->next) {
+	switch (op->kind) {
+	case GQL_QUERY:
+	    type = lookup_field_type(schema, query_str, false);
+	    break;
+	case GQL_MUTATION:
+	    type = lookup_field_type(schema, mutation_str, false);
+	    break;
+	case GQL_SUBSCRIPTION:
+	    type = lookup_field_type(schema, subscription_str, false);
+	    break;
+	default:
+	    break;
+	}
+	if (NULL == type) {
+	    return agoo_err_set(err, AGOO_ERR_EVAL, "Not a supported operation type.");
+	}
+	if (AGOO_ERR_OK != sel_set_type(err, type, op->sels, GQL_QUERY == op->kind)) {
+	    return err->code;
+	}
+    }
+    return AGOO_ERR_OK;
+}
+
+gqlDoc
+sdl_parse_doc(agooErr err, const char *str, int len, gqlVar vars) {
+    struct _agooDoc	doc;
+    gqlDoc		gdoc = NULL;
+    
+    agoo_doc_init(&doc, str, len);
+    if (NULL == (gdoc = gql_doc_create(err))) {
+	return NULL;
+    }
+    gdoc->vars = vars;
+    while (doc.cur < doc.end) {
+	agoo_doc_next_token(&doc);
+	if (doc.end <= doc.cur) {
+	    break;
+	}
+	switch (*doc.cur) {
+	case '{': // no name query
+	case 'q':
+	case 'm':
+	case 's':
+	    if (AGOO_ERR_OK != make_op(err, &doc, gdoc)) {
+		gql_doc_destroy(gdoc);
+		return NULL;
+	    }
+	    break;
+	case 'f':
+	    if (AGOO_ERR_OK != make_fragment(err, &doc, gdoc)) {
+		gql_doc_destroy(gdoc);
+		return NULL;
+	    }
+	    break;
+	case '\0':
+	    goto DONE;
+	default:
+	    agoo_doc_err(&doc, err, "unexpected character");
+	    gql_doc_destroy(gdoc);
+	    return NULL;
+	}
+    }
+DONE:
+    if (AGOO_ERR_OK != validate_doc(err, gdoc)) {
+	gql_doc_destroy(gdoc);
+	return NULL;
+    }
+    return gdoc;
+}