agoo 2.7.0 → 2.8.0

data/ext/agoo/rserver.c

@@ -11,6 +11,7 @@
 #include <ruby/thread.h>
 #include <ruby/encoding.h>
 
+#include "atomic.h"
 #include "bind.h"
 #include "con.h"
 #include "debug.h"
@@ -33,7 +34,8 @@
 #include "upgraded.h"
 #include "websocket.h"
 
-extern void	agoo_shutdown();
+extern void		agoo_shutdown();
+extern sig_atomic_t	agoo_stop;
 
 static VALUE	server_mod = Qundef;
 
@@ -160,7 +162,7 @@ configure(agooErr err, int port, const char *root, VALUE options) {
 	if (Qnil != (v = rb_hash_lookup(options, ID2SYM(rb_intern("bind"))))) {
 	    int	len;
 	    int	i;
-	    
+
 	    switch (rb_type(v)) {
 	    case T_STRING:
 		url_bind(v);
@@ -171,7 +173,7 @@ configure(agooErr err, int port, const char *root, VALUE options) {
 		    url_bind(rb_ary_entry(v, i));
 		}
 		break;
-	    default:	
+	    default:
 		rb_raise(rb_eArgError, "bind option must be a String or Array of Strings.");
 		break;
 	    }
@@ -317,7 +319,7 @@ rescue_error(VALUE x) {
 	int		blen = RARRAY_LEN(bt);
 	int		i;
 	VALUE		rline;
-	
+
 	for (i = 0; i < blen; i++) {
 	    rline = rb_ary_entry(bt, i);
 	}
@@ -357,7 +359,7 @@ header_cb(VALUE key, VALUE value, agooText *tp) {
     const char		*vs = StringValuePtr(value);
     int			vlen = (int)RSTRING_LEN(value);
     struct _agooErr	err = AGOO_ERR_INIT;
-    
+
     if (agoo_server.pedantic) {
 	if (AGOO_ERR_OK != agoo_http_header_ok(&err, ks, klen, vs, vlen)) {
 	    rb_raise(rb_eArgError, "%s", err.msg);
@@ -436,7 +438,7 @@ handle_rack_inner(void *x) {
 	rb_raise(rb_eArgError, "invalid rack call() response body does not respond to each.");
     }
     if (NULL == (t = agoo_text_allocate(1024))) {
-	rb_raise(rb_eArgError, "failed to allocate response.");
+	rb_raise(rb_eNoMemError, "Failed to allocate memory for a response.");
     }
     if (T_ARRAY == rb_type(bv)) {
 	int	i;
@@ -629,7 +631,7 @@ handle_push_inner(void *x) {
 	break;
     }
     agoo_upgraded_release(req->up);
-    
+
     return Qfalse;
 }
 
@@ -678,8 +680,8 @@ handle_protected(agooReq req, bool gvi) {
 	agoo_queue_wakeup(&agoo_server.con_queue);
 	break;
     default: {
-	char	buf[256];
-	int	cnt = snprintf(buf, sizeof(buf), "HTTP/1.1 500 Internal Error\r\nConnection: Close\r\nContent-Length: 0\r\n\r\n");
+	char		buf[256];
+	int		cnt = snprintf(buf, sizeof(buf), "HTTP/1.1 500 Internal Error\r\nConnection: Close\r\nContent-Length: 0\r\n\r\n");
 	agooText	message = agoo_text_create(buf, cnt);
 
 	req->res->close = true;
@@ -693,13 +695,17 @@ handle_protected(agooReq req, bool gvi) {
 static void*
 process_loop(void *ptr) {
     agooReq	req;
-    
+
     atomic_fetch_add(&agoo_server.running, 1);
     while (agoo_server.active) {
 	if (NULL != (req = (agooReq)agoo_queue_pop(&agoo_server.eval_queue, 0.1))) {
 	    handle_protected(req, true);
 	    agoo_req_destroy(req);
 	}
+	if (agoo_stop) {
+	    agoo_shutdown();
+	    break;
+	}
     }
     atomic_fetch_sub(&agoo_server.running, 1);
 
@@ -727,9 +733,9 @@ rserver_start(VALUE self) {
     struct _agooErr	err = AGOO_ERR_INIT;
     VALUE		agoo = rb_const_get_at(rb_cObject, rb_intern("Agoo"));
     VALUE		v = rb_const_get_at(agoo, rb_intern("VERSION"));
-    
+
     *the_rserver.worker_pids = getpid();
-    
+
     // If workers then set the loop_max based on the expected number of
     // threads per worker.
     if (1 < the_rserver.worker_cnt) {
@@ -774,11 +780,15 @@ rserver_start(VALUE self) {
 	    } else {
 		rb_thread_schedule();
 	    }
-
+	    if (agoo_stop) {
+		agoo_shutdown();
+		break;
+	    }
 	}
     } else {
-	the_rserver.eval_threads = (VALUE*)AGOO_MALLOC(sizeof(VALUE) * (agoo_server.thread_cnt + 1));
-
+	if (NULL == (the_rserver.eval_threads = (VALUE*)AGOO_MALLOC(sizeof(VALUE) * (agoo_server.thread_cnt + 1)))) {
+	    rb_raise(rb_eNoMemError, "Failed to allocate memory for the thread pool.");
+	}
 	for (i = agoo_server.thread_cnt, vp = the_rserver.eval_threads; 0 < i; i--, vp++) {
 	    *vp = rb_thread_create(wrap_process_loop, NULL);
 	}
@@ -834,7 +844,7 @@ rserver_shutdown(VALUE self) {
 	    int	status;
 	    int	exit_cnt = 1;
 	    int	j;
-	    
+
 	    for (i = 1; i < the_rserver.worker_cnt; i++) {
 		kill(the_rserver.worker_pids[i], SIGKILL);
 	    }
@@ -912,7 +922,7 @@ handle(VALUE self, VALUE method, VALUE pattern, VALUE handler) {
 	if (Qtrue == rb_funcall(handler, static_id, 0, Qnil)) {
 	    VALUE	res = rb_funcall(handler, call_id, 1, Qnil);
 	    VALUE	bv;
-	    
+
 	    rb_check_type(res, T_ARRAY);
 	    if (3 != RARRAY_LEN(res)) {
 		rb_raise(rb_eArgError, "a rack call() response must be an array of 3 members.");
@@ -932,6 +942,9 @@ handle(VALUE self, VALUE method, VALUE pattern, VALUE handler) {
 		    v = rb_ary_entry(bv, i);
 		    t = agoo_text_append(t, StringValuePtr(v), (int)RSTRING_LEN(v));
 		}
+		if (NULL == t) {
+		    rb_raise(rb_eNoMemError, "Failed to allocate memory for a response.");
+		}
 		if (NULL == agoo_page_immutable(&err, pat, t->text, t->len)) {
 		    rb_raise(rb_eArgError, "%s", err.msg);
 		}
@@ -973,7 +986,7 @@ handle_not_found(VALUE self, VALUE handler) {
 	rb_raise(rb_eStandardError, "out of memory.");
     }
     rb_gc_register_address((VALUE*)&agoo_server.hook404->handler);
-    
+
     return Qnil;
 }
 
@@ -987,7 +1000,7 @@ handle_not_found(VALUE self, VALUE handler) {
 static VALUE
 add_mime(VALUE self, VALUE suffix, VALUE type) {
     struct _agooErr	err = AGOO_ERR_INIT;
-    
+
     if (AGOO_ERR_OK != mime_set(&err, StringValuePtr(suffix), StringValuePtr(type))) {
 	rb_raise(rb_eArgError, "%s", err.msg);
     }
@@ -1014,7 +1027,7 @@ path_group(VALUE self, VALUE path, VALUE dirs) {
 	int	i;
 	int	dcnt = (int)RARRAY_LEN(dirs);
 	VALUE	entry;
-	
+
 	for (i = dcnt - 1; 0 <= i; i--) {
 	    entry = rb_ary_entry(dirs, i);
 	    if (T_STRING != rb_type(entry)) {
@@ -1047,7 +1060,7 @@ path_group(VALUE self, VALUE path, VALUE dirs) {
 static VALUE
 header_rule(VALUE self, VALUE path, VALUE mime, VALUE key, VALUE value) {
     struct _agooErr	err = AGOO_ERR_INIT;
-    
+
     rb_check_type(path, T_STRING);
     rb_check_type(mime, T_STRING);
     rb_check_type(key, T_STRING);
@@ -1086,7 +1099,7 @@ server_init(VALUE mod) {
     on_message_id = rb_intern("on_message");
     on_request_id = rb_intern("on_request");
     to_i_id = rb_intern("to_i");
-    
+
     connect_sym = ID2SYM(rb_intern("CONNECT"));		rb_gc_register_address(&connect_sym);
     delete_sym = ID2SYM(rb_intern("DELETE"));		rb_gc_register_address(&delete_sym);
     get_sym = ID2SYM(rb_intern("GET"));			rb_gc_register_address(&get_sym);

data/ext/agoo/sdl.c

@@ -9,14 +9,16 @@
 #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	extend_str[] = "extend";
+static const char	input_str[] = "input";
+static const char	interface_str[] = "interface";
 static const char	mutation_str[] = "mutation";
+static const char	query_str[] = "query";
+static const char	schema_str[] = "schema";
 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 const char	union_str[] = "union";
 
 static int	make_sel(agooErr err, agooDoc doc, gqlDoc gdoc, gqlOp op, gqlSel *parentp);
 
@@ -80,56 +82,6 @@ extract_name(agooErr err, agooDoc doc, const char *key, int klen, char *name, si
     return AGOO_ERR_OK;
 }
 
-static int
-make_scalar(agooErr err, agooDoc doc, const char *desc, int len) {
-    char	name[256];
-
-    if (AGOO_ERR_OK != extract_name(err, doc, "scalar", 6, name, sizeof(name))) {
-	return err->code;
-    }
-    gql_scalar_create(err, name, desc, len);
-
-    return AGOO_ERR_OK;
-}
-
-static int
-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];
@@ -195,7 +147,66 @@ extract_dir_use(agooErr err, agooDoc doc, gqlDirUse *uses) {
 }
 
 static int
-make_enum(agooErr err, agooDoc doc, const char *desc, size_t dlen) {
+make_scalar(agooErr err, agooDoc doc, const char *desc, int len, bool x) {
+    char	name[256];
+    gqlType	type;
+
+    if (AGOO_ERR_OK != extract_name(err, doc, "scalar", 6, name, sizeof(name))) {
+	return err->code;
+    }
+    if (x) {
+	if (NULL == (type = gql_type_get(name))) {
+	    return agoo_doc_err(doc, err, "%s not defined. Can not be extended.", name);
+	}
+    } else if (NULL == (type = gql_scalar_create(err, name, desc, len))) {
+	return err->code;
+    }
+    if (AGOO_ERR_OK != extract_dir_use(err, doc, &type->dir)) {
+	return err->code;
+    }
+    return AGOO_ERR_OK;
+}
+
+static int
+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_enum(agooErr err, agooDoc doc, const char *desc, size_t dlen, bool x) {
     char	name[256];
     const char	*start;
     gqlType	type;
@@ -214,8 +225,11 @@ make_enum(agooErr err, agooDoc doc, const char *desc, size_t dlen) {
 	return agoo_doc_err(doc, err, "Expected '{'");
     }
     doc->cur++;
-
-    if (NULL == (type = gql_enum_create(err, name, desc, dlen))) {
+    if (x) {
+	if (NULL == (type = gql_type_get(name))) {
+	    return agoo_doc_err(doc, err, "%s not defined. Can not be extended.", name);
+	}
+    } else if (NULL == (type = gql_enum_create(err, name, desc, dlen))) {
 	return err->code;
     }
     type->dir = uses;
@@ -224,60 +238,69 @@ make_enum(agooErr err, agooDoc doc, const char *desc, size_t dlen) {
 	uses = NULL;
 
 	if (AGOO_ERR_OK != extract_desc(err, doc, &desc, &dlen)) {
-	    return err->code;
+	    goto ERROR;
 	}
 	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;
+	    goto ERROR;
 	}
 	if (doc->cur == start) {
 	    if ('}' == *doc->cur) {
 		doc->cur++;
 		break;
 	    }
-	    return agoo_doc_err(doc, err, "Invalid Enum value");
+	    agoo_doc_err(doc, err, "Invalid Enum value");
+	    goto ERROR;
 	}
 	if (NULL == (ev = gql_enum_append(err, type, start, len, desc, dlen))) {
-	    return err->code;
+	    goto ERROR;
 	}
 	ev->dir = uses;
     }
     return AGOO_ERR_OK;
+ERROR:
+    if (!x) {
+	gql_type_destroy(type);
+    }
+    return err->code;
 }
 
 static int
-make_union(agooErr err, agooDoc doc, const char *desc, int len) {
+make_union(agooErr err, agooDoc doc, const char *desc, int len, bool x) {
     char	name[256];
     gqlType	type;
-    gqlDirUse	uses = NULL;
     gqlType	member;
     bool	required;
 
     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)) {
+    if (x) {
+	if (NULL == (type = gql_type_get(name))) {
+	    return agoo_doc_err(doc, err, "%s not defined. Can not be extended.", name);
+	}
+    } else if (NULL == (type = gql_union_create(err, name, desc, len))) {
 	return err->code;
     }
+    if (AGOO_ERR_OK != extract_dir_use(err, doc, &type->dir)) {
+	goto ERROR;
+    }
     agoo_doc_skip_white(doc);
     if ('=' != *doc->cur) {
-	return agoo_doc_err(doc, err, "Expected '='");
+	agoo_doc_err(doc, err, "Expected '='");
+	goto ERROR;
     }
     doc->cur++;
     agoo_doc_skip_white(doc);
 
-    if (NULL == (type = gql_union_create(err, name, desc, len))) {
-	return err->code;
-    }
-    type->dir = uses;
     while (doc->cur < doc->end) {
 	if (AGOO_ERR_OK != read_type(err, doc, &member, &required)) {
-	    return err->code;
+	    goto ERROR;
 	}
  	if (AGOO_ERR_OK != gql_union_add(err, type, member)) {
-	    return err->code;
+	    goto ERROR;
 	}
 	agoo_doc_skip_white(doc);
 	if ('|' != *doc->cur) {
@@ -286,6 +309,11 @@ make_union(agooErr err, agooDoc doc, const char *desc, int len) {
 	doc->cur++; // skip |
     }
     return AGOO_ERR_OK;
+ERROR:
+    if (!x) {
+	gql_type_destroy(type);
+    }
+    return err->code;
 }
 
 static int
@@ -570,8 +598,6 @@ make_input_arg(agooErr err, agooDoc doc, gqlType type) {
     if (AGOO_ERR_OK != extract_dir_use(err, doc, &uses)) {
 	return err->code;
     }
-    // TBD zzzzzzzz
-
     if (NULL == (arg = gql_input_arg(err, type, name, return_type, desc, dlen, dval, required))) {
 	return err->code;
     }
@@ -581,77 +607,90 @@ make_input_arg(agooErr err, agooDoc doc, gqlType type) {
 }
 
 static int
-make_interface(agooErr err, agooDoc doc, const char *desc, int len) {
+make_interface(agooErr err, agooDoc doc, const char *desc, int len, bool x) {
     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)) {
+    if (x) {
+	if (NULL == (type = gql_type_get(name))) {
+	    return agoo_doc_err(doc, err, "%s not defined. Can not be extended.", name);
+	}
+    } else if (NULL == (type = gql_interface_create(err, name, desc, len))) {
 	return err->code;
     }
+    if (AGOO_ERR_OK != extract_dir_use(err, doc, &type->dir)) {
+	goto ERROR;
+    }
     agoo_doc_skip_white(doc);
     if ('{' != *doc->cur) {
-	return agoo_doc_err(doc, err, "Expected '{'");
+	goto ERROR;
     }
     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)) {
-	    return err->code;
+	    goto ERROR;
 	}
 	agoo_doc_skip_white(doc);
     }
     return AGOO_ERR_OK;
+ERROR:
+    if (!x) {
+	gql_type_destroy(type);
+    }
+    return err->code;
 }
 
 static int
-make_input(agooErr err, agooDoc doc, const char *desc, int len) {
+make_input(agooErr err, agooDoc doc, const char *desc, int len, bool x) {
     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)) {
+    if (x) {
+	if (NULL == (type = gql_type_get(name))) {
+	    return agoo_doc_err(doc, err, "%s not defined. Can not be extended.", name);
+	}
+    } else if (NULL == (type = gql_input_create(err, name, desc, len))) {
 	return err->code;
     }
+    if (AGOO_ERR_OK != extract_dir_use(err, doc, &type->dir)) {
+	goto ERROR;
+    }
     agoo_doc_skip_white(doc);
     if ('{' != *doc->cur) {
-	return agoo_doc_err(doc, err, "Expected '{'");
+	agoo_doc_err(doc, err, "Expected '{'");
+	goto ERROR;
     }
     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;
 	}
-	// TBD zzzzzzzzzz make_arg
 	if (AGOO_ERR_OK != make_input_arg(err, doc, type)) {
-	    return err->code;
+	    goto ERROR;
 	}
 	agoo_doc_skip_white(doc);
     }
     return AGOO_ERR_OK;
+ERROR:
+    if (!x) {
+	gql_type_destroy(type);
+    }
+    return err->code;
 }
 
 static int
@@ -705,33 +744,82 @@ extract_interfaces(agooErr err, agooDoc doc, gqlTypeLink *interfacesp) {
 }
 
 static int
-make_type(agooErr err, agooDoc doc, const char *desc, int len) {
+make_type(agooErr err, agooDoc doc, const char *desc, int len, bool x) {
     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)) {
+    if (x) {
+	if (NULL == (type = gql_type_get(name))) {
+	    return agoo_doc_err(doc, err, "%s not defined. Can not be extended.", name);
+	}
+    } else if (NULL == (type = gql_type_create(err, name, desc, len, NULL))) {
 	return err->code;
     }
-    if (AGOO_ERR_OK != extract_dir_use(err, doc, &uses)) {
-	return err->code;
+    if (AGOO_ERR_OK != extract_interfaces(err, doc, &type->interfaces)) {
+	goto ERROR;
+    }
+    if (AGOO_ERR_OK != extract_dir_use(err, doc, &type->dir)) {
+	goto ERROR;
     }
     agoo_doc_skip_white(doc);
     if ('{' != *doc->cur) {
-	return agoo_doc_err(doc, err, "Expected '{'");
+	agoo_doc_err(doc, err, "Expected '{'");
+	goto ERROR;
     }
     doc->cur++;
     agoo_doc_skip_white(doc);
 
-    if (NULL == (type = gql_type_create(err, name, desc, len, interfaces))) {
-	return err->code;
+    while (doc->cur < doc->end) {
+	if ('}' == *doc->cur) {
+	    doc->cur++; // skip }
+	    break;
+	}
+	if (AGOO_ERR_OK != make_field(err, doc, type)) {
+	    goto ERROR;
+	}
+	agoo_doc_skip_white(doc);
     }
-    type->dir = uses;
+    return AGOO_ERR_OK;
+ERROR:
+    if (!x) {
+	gql_type_destroy(type);
+    }
+    return err->code;
+}
+
+static int
+make_schema(agooErr err, agooDoc doc, const char *desc, int len, bool x) {
+    gqlType	type;
 
+    if (0 != strncmp(doc->cur, schema_str, sizeof(schema_str) - 1)) {
+	return agoo_doc_err(doc, err, "Expected schema key word");
+    }
+    doc->cur += sizeof(schema_str) - 1;
+    if (0 == agoo_doc_skip_white(doc)) {
+	return agoo_doc_err(doc, err, "Expected schema key word");
+    }
+    if (x) {
+	if (NULL == (type = gql_type_get(schema_str))) {
+	    return agoo_doc_err(doc, err, "schema not defined. Can not be extended.");
+	}
+    } else if (NULL == (type = gql_schema_create(err, desc, len))) {
+	return err->code;
+    }
+    if (AGOO_ERR_OK != extract_dir_use(err, doc, &type->dir)) {
+	return err->code;
+    }
+    agoo_doc_skip_white(doc);
+    if ('{' != *doc->cur) {
+	if (!x) {
+	    gql_type_destroy(type);
+	}
+	return agoo_doc_err(doc, err, "Expected '{'");
+    }
+    doc->cur++;
+    agoo_doc_skip_white(doc);
     while (doc->cur < doc->end) {
 	if ('}' == *doc->cur) {
 	    doc->cur++; // skip }
@@ -745,11 +833,24 @@ make_type(agooErr err, agooDoc doc, const char *desc, int len) {
     return AGOO_ERR_OK;
 }
 
+static int
+extend(agooErr err, agooDoc doc) {
+    if (0 != strncmp(doc->cur, extend_str, sizeof(extend_str) - 1)) {
+	return agoo_doc_err(doc, err, "Expected extend key word");
+    }
+    doc->cur += sizeof(extend_str) - 1;
+    if (0 == agoo_doc_skip_white(doc)) {
+	return agoo_doc_err(doc, err, "Expected extend key word");
+    }
+    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;
+    bool		extend_next = false;
 
     agoo_doc_init(&doc, str, len);
 
@@ -761,32 +862,47 @@ sdl_parse(agooErr err, const char *str, int len) {
 		return err->code;
 	    }
 	    break;
-	case 's': // scalar
-	    if (AGOO_ERR_OK != make_scalar(err, &doc, desc, dlen)) {
-		return err->code;
+	case 's': // schema or scalar
+	    if (6 < (doc.end - doc.cur) && 'c' == doc.cur[1]) {
+		if ('a' == doc.cur[2]) {
+		    if (AGOO_ERR_OK != make_scalar(err, &doc, desc, dlen, extend_next)) {
+			return err->code;
+		    }
+		    desc = NULL;
+		    dlen = 0;
+		    break;
+		} else {
+		    if (AGOO_ERR_OK != make_schema(err, &doc, desc, dlen, extend_next)) {
+			return err->code;
+		    }
+		    desc = NULL;
+		    dlen = 0;
+		    break;
+		}
 	    }
-	    desc = NULL;
-	    dlen = 0;
-	    break;
-	case 'e': // enum, and extend interface or type
+	    return agoo_doc_err(&doc, err, "Unknown directive");
+	case 'e': // enum or extend
 	    if (4 < (doc.end - doc.cur)) {
 		if ('n' == doc.cur[1]) {
-		    if (AGOO_ERR_OK != make_enum(err, &doc, desc, dlen)) {
+		    if (AGOO_ERR_OK != make_enum(err, &doc, desc, dlen, extend_next)) {
 			return err->code;
 		    }
 		    desc = NULL;
 		    dlen = 0;
 		    break;
 		} else {
-		    // TBD extend
+		    if (AGOO_ERR_OK != extend(err, &doc)) {
+			return err->code;
+		    }
 		    desc = NULL;
 		    dlen = 0;
+		    extend_next = true;
 		    break;
 		}
 	    }
 	    return agoo_doc_err(&doc, err, "Unknown directive");
 	case 'u': // union
-	    if (AGOO_ERR_OK != make_union(err, &doc, desc, dlen)) {
+	    if (AGOO_ERR_OK != make_union(err, &doc, desc, dlen, extend_next)) {
 		return err->code;
 	    }
 	    desc = NULL;
@@ -800,7 +916,7 @@ sdl_parse(agooErr err, const char *str, int len) {
 	    dlen = 0;
 	    break;
 	case 't': // type
-	    if (AGOO_ERR_OK != make_type(err, &doc, desc, dlen)) {
+	    if (AGOO_ERR_OK != make_type(err, &doc, desc, dlen, extend_next)) {
 		return err->code;
 	    }
 	    desc = NULL;
@@ -809,14 +925,14 @@ sdl_parse(agooErr err, const char *str, int len) {
 	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)) {
+		    if (AGOO_ERR_OK != make_input(err, &doc, desc, dlen, extend_next)) {
 			return err->code;
 		    }
 		    desc = NULL;
 		    dlen = 0;
 		    break;
 		} else {
-		    if (AGOO_ERR_OK != make_interface(err, &doc, desc, dlen)) {
+		    if (AGOO_ERR_OK != make_interface(err, &doc, desc, dlen, extend_next)) {
 			return err->code;
 		    }
 		    desc = NULL;
@@ -1352,6 +1468,7 @@ lookup_field_type(gqlType type, const char *field, bool qroot) {
     gqlType	ftype = NULL;
 
     switch (type->kind) {
+    case GQL_SCHEMA:
     case GQL_OBJECT:
     case GQL_INPUT:
     case GQL_INTERFACE: {
@@ -1425,7 +1542,7 @@ validate_doc(agooErr err, gqlDoc doc) {
     gqlFrag	frag;
     int		cnt;
 
-    if (NULL == (schema = gql_type_get("schema"))) {
+    if (NULL == (schema = gql_root_type())) {
 	return agoo_err_set(err, AGOO_ERR_EVAL, "No root (schema) type defined.");
     }
     for (frag = doc->frags; NULL != frag; frag = frag->next) {