agoo 2.7.0 → 2.8.0

data/ext/agoo/gqlvalue.c

@@ -34,7 +34,7 @@ static agooText
 int_to_text(agooText text, gqlValue value, int indent, int depth) {
     char	num[32];
     int		cnt;
-    
+
     cnt = snprintf(num, sizeof(num), "%lld", (long long)value->i);
 
     return agoo_text_append(text, num, cnt);
@@ -56,7 +56,7 @@ static agooText
 i64_to_text(agooText text, gqlValue value, int indent, int depth) {
     char	num[32];
     int		cnt;
-    
+
     cnt = snprintf(num, sizeof(num), "%lld", (long long)value->i64);
 
     return agoo_text_append(text, num, cnt);
@@ -132,6 +132,18 @@ struct _gqlType	gql_token_type = {
     .to_sdl = token_to_text,
 };
 
+// ID type
+struct _gqlType	gql_id_type = {
+    .name = "ID",
+    .desc = "ID scalar.",
+    .kind = GQL_SCALAR,
+    .scalar_kind = GQL_SCALAR_ID,
+    .core = true,
+    .destroy = string_destroy,
+    .to_json = string_to_text,
+    .to_sdl = string_to_text,
+};
+
 // Variable type ($var)
 static agooText
 var_to_text(agooText text, gqlValue value, int indent, int depth) {
@@ -185,7 +197,7 @@ static agooText
 float_to_text(agooText text, gqlValue value, int indent, int depth) {
     char	num[32];
     int		cnt;
-    
+
     cnt = snprintf(num, sizeof(num), "%g", value->f);
 
     return agoo_text_append(text, num, cnt);
@@ -235,7 +247,7 @@ read_zone(const char *s, int *vp) {
 	return NULL;
     }
     *vp = hr * 60 + min;
-    
+
     return s;
 }
 
@@ -248,7 +260,7 @@ time_parse(agooErr err, const char *str, int len) {
     uint64_t	nsecs = 0;
     int		i = 9;
     int64_t	secs;
-    
+
     if (0 > len) {
 	len = (int)strlen(str);
     }
@@ -309,7 +321,7 @@ time_parse(agooErr err, const char *str, int len) {
 	// fall through
     case '+': {
 	int	v = 0;
-	
+
 	if (NULL == (s = read_zone(s, &v))) {
 	    agoo_err_set(err, AGOO_ERR_PARSE, "Invalid time format.");
 	    return 0;
@@ -397,7 +409,7 @@ time_parse(agooErr err, const char *str, int len) {
 	if (end <= s) {
 	    agoo_err_set(err, AGOO_ERR_PARSE, "Invalid time format.");
 	    return 0;
-	}	
+	}
 	if ('0' <= *s && *s <= '9') {
 	    nsecs = nsecs * 10 + *s - '0';
 	} else {
@@ -463,7 +475,7 @@ time_to_text(agooText text, gqlValue value, int indent, int depth) {
     }
     agoo_sectime(t, &at);
     cnt = sprintf(str, "\"%04d-%02d-%02dT%02d:%02d:%02d.%09ldZ\"", at.year, at.mon, at.day, at.hour, at.min, at.sec, (long)nsecs);
-    
+
     return agoo_text_append(text, str, cnt);
 }
 
@@ -482,7 +494,7 @@ struct _gqlType	gql_time_type = {
 static int
 hexVal(int c) {
     int	h = -1;
-    
+
     if ('0' <= c && c <= '9') {
 	h = c - '0';
     } else if ('a' <= c && c <= 'f') {
@@ -500,7 +512,7 @@ parse_uuid(agooErr err, const char *str, int len, uint64_t *hip, uint64_t *lop)
     uint64_t	lo = 0;
     int		i;
     int		n;
-    
+
     if (0 >= len) {
 	len = (int)strlen(str);
     }
@@ -679,7 +691,7 @@ gql_object_to_json(agooText text, gqlValue value, int indent, int depth) {
     int		i2 = i + indent;
     int		d2 = depth + 1;
     gqlLink	link;
-    
+
     if (0 < indent) {
 	i++; // for \n
 	i2++;
@@ -719,7 +731,7 @@ gql_object_to_sdl(agooText text, gqlValue value, int indent, int depth) {
     int		i2 = i + indent;
     int		d2 = depth + 1;
     gqlLink	link;
-    
+
     if (0 < indent) {
 	i++; // for \n
 	i2++;
@@ -772,7 +784,6 @@ gql_value_destroy(gqlValue value) {
 		value->type->destroy(value);
 	    }
 	} else if (GQL_ENUM == value->type->kind) {
-	    // TBD destroy string
 	    string_destroy(value);
 	} else {
 	    return;
@@ -789,6 +800,7 @@ gql_value_init(agooErr err) {
 	AGOO_ERR_OK != gql_type_set(err, &gql_float_type) ||
 	AGOO_ERR_OK != gql_type_set(err, &gql_time_type) ||
 	AGOO_ERR_OK != gql_type_set(err, &gql_uuid_type) ||
+	AGOO_ERR_OK != gql_type_set(err, &gql_id_type) ||
 	AGOO_ERR_OK != gql_type_set(err, &gql_string_type)) {
 	return err->code;
     }
@@ -808,9 +820,8 @@ gql_i64_set(gqlValue value, int64_t i) {
     value->i64 = i;
 }
 
-int
-gql_string_set(agooErr err, gqlValue value, const char *str, int len) {
-    value->type = &gql_string_type;
+static int
+string_set(agooErr err, gqlValue value, const char *str, int len) {
     if (NULL == str) {
 	value->str.alloced = true;
 	value->str.ptr = NULL;
@@ -831,27 +842,25 @@ gql_string_set(agooErr err, gqlValue value, const char *str, int len) {
     return AGOO_ERR_OK;
 }
 
+int
+gql_string_set(agooErr err, gqlValue value, const char *str, int len) {
+    value->type = &gql_string_type;
+
+    return string_set(err, value, str, len);
+}
+
 int
 gql_token_set(agooErr err, gqlValue value, const char *str, int len) {
     value->type = &gql_token_type;
-    if (NULL == str) {
-	value->str.alloced = true;
-	value->str.ptr = NULL;
-    } else {
-	if (0 >= len) {
-	    len = (int)strlen(str);
-	}
-	if (len < (int)sizeof(value->str.a)) {
-	    strncpy(value->str.a, str, len);
-	    value->str.alloced = false;
-	} else {
-	    value->str.alloced = true;
-	    if (NULL == (value->str.ptr = AGOO_STRNDUP(str, len))) {
-		return AGOO_ERR_MEM(err, "strndup()");
-	    }
-	}
-    }
-    return AGOO_ERR_OK;
+
+    return string_set(err, value, str, len);
+}
+
+int
+gql_id_set(agooErr err, gqlValue value, const char *str, int len) {
+    value->type = &gql_id_type;
+
+    return string_set(err, value, str, len);
 }
 
 void
@@ -989,7 +998,7 @@ gql_object_set(agooErr err, gqlValue obj, const char *key, gqlValue item) {
 static gqlValue
 value_create(gqlType type) {
     gqlValue	v = (gqlValue)AGOO_CALLOC(1, sizeof(struct _gqlValue));
-    
+
     if (NULL != v) {
 	v->type = type;
     }
@@ -999,7 +1008,7 @@ value_create(gqlType type) {
 gqlValue
 gql_int_create(agooErr err, int32_t i) {
     gqlValue	v = value_create(&gql_int_type);
-    
+
     if (NULL != v) {
 	v->i = i;
     }
@@ -1009,7 +1018,7 @@ gql_int_create(agooErr err, int32_t i) {
 gqlValue
 gql_i64_create(agooErr err, int64_t i) {
     gqlValue	v = value_create(&gql_i64_type);
-    
+
     if (NULL != v) {
 	v->i64 = i;
     }
@@ -1019,7 +1028,7 @@ gql_i64_create(agooErr err, int64_t i) {
 gqlValue
 gql_string_create(agooErr err, const char *str, int len) {
     gqlValue	v;
-    
+
     if (0 >= len) {
 	len = (int)strlen(str);
     }
@@ -1042,7 +1051,7 @@ gql_string_create(agooErr err, const char *str, int len) {
 gqlValue
 gql_token_create(agooErr err, const char *str, int len, gqlType type) {
     gqlValue	v;
-    
+
     if (0 >= len) {
 	len = (int)strlen(str);
     }
@@ -1065,10 +1074,33 @@ gql_token_create(agooErr err, const char *str, int len, gqlType type) {
     return v;
 }
 
+gqlValue
+gql_id_create(agooErr err, const char *str, int len) {
+    gqlValue	v;
+
+    if (0 >= len) {
+	len = (int)strlen(str);
+    }
+    if (NULL != (v = value_create(&gql_id_type))) {
+	if ((int)sizeof(v->str.a) <= len) {
+	    v->str.alloced = true;
+	    if (NULL == (v->str.ptr = AGOO_STRNDUP(str, len))) {
+		AGOO_ERR_MEM(err, "strdup()");
+		return NULL;
+	    }
+	} else {
+	    v->str.alloced = false;
+	    strncpy(v->str.a, str, len);
+	    v->str.a[len] = '\0';
+	}
+    }
+    return v;
+}
+
 gqlValue
 gql_var_create(agooErr err, const char *str, int len) {
     gqlValue	v;
-    
+
     if (0 >= len) {
 	len = (int)strlen(str);
     }
@@ -1091,7 +1123,7 @@ gql_var_create(agooErr err, const char *str, int len) {
 gqlValue
 gql_bool_create(agooErr err, bool b) {
     gqlValue	v = value_create(&gql_bool_type);
-    
+
     if (NULL != v) {
 	v->b = b;
     }
@@ -1101,7 +1133,7 @@ gql_bool_create(agooErr err, bool b) {
 gqlValue
 gql_float_create(agooErr err, double f) {
     gqlValue	v = value_create(&gql_float_type);
-    
+
     if (NULL != v) {
 	v->f = f;
     }
@@ -1111,7 +1143,7 @@ gql_float_create(agooErr err, double f) {
 gqlValue
 gql_time_create(agooErr err, int64_t t) {
     gqlValue	v = value_create(&gql_time_type);
-    
+
     if (NULL != v) {
 	v->time = t;
     }
@@ -1121,7 +1153,7 @@ gql_time_create(agooErr err, int64_t t) {
 gqlValue
 gql_time_str_create(agooErr err, const char *str, int len) {
     gqlValue	v = value_create(&gql_time_type);
-    
+
     if (NULL != v) {
 	if (0 >= len) {
 	    len = (int)strlen(str);
@@ -1134,7 +1166,7 @@ gql_time_str_create(agooErr err, const char *str, int len) {
 gqlValue
 gql_uuid_create(agooErr err, uint64_t hi, uint64_t lo) {
     gqlValue	v = value_create(&gql_uuid_type);
-    
+
     if (NULL != v) {
 	v->uuid.hi = hi;
 	v->uuid.lo = lo;
@@ -1162,7 +1194,7 @@ gql_uuid_str_create(agooErr err, const char *str, int len) {
 gqlValue
 gql_null_create(agooErr err) {
     gqlValue	v = value_create(&gql_null_type);
-    
+
     return v;
 }
 
@@ -1225,7 +1257,7 @@ gql_string_get(gqlValue value) {
     const char	*s = NULL;
 
     if (NULL != value) {
-	if (&gql_string_type == value->type || &gql_token_type == value->type || &gql_var_type == value->type ||
+	if (&gql_string_type == value->type || &gql_token_type == value->type || &gql_var_type == value->type || &gql_id_type == value->type ||
 	    GQL_ENUM == value->type->kind) {
 	    if (value->str.alloced) {
 		s = value->str.ptr;
@@ -1252,7 +1284,7 @@ convert_to_bool(agooErr err, gqlValue value) {
     case GQL_SCALAR_STRING:
     case GQL_SCALAR_TOKEN: {
 	const char	*s = gql_string_get(value);
-	
+
 	value->type = &gql_bool_type;
 	if (0 == strcasecmp("true", s)) {
 	    value->b = true;
@@ -1392,7 +1424,7 @@ static int
 convert_to_string(agooErr err, gqlValue value) {
     char	buf[64];
     int		cnt;
-    
+
     switch (value->type->scalar_kind) {
     case GQL_SCALAR_BOOL:
 	if (value->b) {
@@ -1416,6 +1448,9 @@ convert_to_string(agooErr err, gqlValue value) {
     case GQL_SCALAR_TOKEN:
 	value->type = &gql_string_type;
 	break;
+    case GQL_SCALAR_ID:
+	value->type = &gql_string_type;
+	break;
     case GQL_SCALAR_TIME: {
 	struct _agooTime	at;
 	int64_t			tt = value->time;
@@ -1450,6 +1485,7 @@ static int
 convert_to_token(agooErr err, gqlValue value) {
     switch (value->type->scalar_kind) {
     case GQL_SCALAR_STRING:
+    case GQL_SCALAR_ID:
 	value->type = &gql_token_type;
 	break;
     default:
@@ -1459,6 +1495,20 @@ convert_to_token(agooErr err, gqlValue value) {
     return err->code;
 }
 
+static int
+convert_to_id(agooErr err, gqlValue value) {
+    switch (value->type->scalar_kind) {
+    case GQL_SCALAR_STRING:
+    case GQL_SCALAR_TOKEN:
+	value->type = &gql_id_type;
+	break;
+    default:
+	agoo_err_set(err, AGOO_ERR_PARSE, "Can not coerce a %s into a ID value.", value->type->name);
+	break;
+    }
+    return err->code;
+}
+
 static int
 convert_to_time(agooErr err, gqlValue value) {
     switch (value->type->scalar_kind) {
@@ -1489,7 +1539,7 @@ convert_to_uuid(agooErr err, gqlValue value) {
     case GQL_SCALAR_STRING: {
 	const char	*s = gql_string_get(value);
 	bool		alloced = value->str.alloced;
-	
+
 	if (AGOO_ERR_OK == gql_uuid_str_set(err, value, s, 0)) {
 	    if (alloced) {
 		AGOO_FREE((char*)s);
@@ -1507,7 +1557,7 @@ convert_to_uuid(agooErr err, gqlValue value) {
 int
 gql_value_convert(agooErr err, gqlValue value, struct _gqlType *type) {
     int	code = AGOO_ERR_OK;
-    
+
     if (type != value->type) {
 	switch (type->scalar_kind) {
 	case GQL_SCALAR_BOOL:
@@ -1528,6 +1578,9 @@ gql_value_convert(agooErr err, gqlValue value, struct _gqlType *type) {
 	case GQL_SCALAR_TOKEN:
 	    code = convert_to_token(err, value);
 	    break;
+	case GQL_SCALAR_ID:
+	    code = convert_to_id(err, value);
+	    break;
 	case GQL_SCALAR_TIME:
 	    code = convert_to_time(err, value);
 	    break;
@@ -1564,6 +1617,7 @@ gql_value_dup(agooErr err, gqlValue value) {
 	break;
     case GQL_SCALAR_STRING:
     case GQL_SCALAR_TOKEN:
+    case GQL_SCALAR_ID:
 	if (value->str.alloced) {
 	    if (NULL == (dup->str.ptr = strdup(value->str.ptr))) {
 		AGOO_ERR_MEM(err, "strdup()");
@@ -1586,4 +1640,3 @@ gql_value_dup(agooErr err, gqlValue value) {
     }
     return dup;
 }
-

data/ext/agoo/gqlvalue.h

@@ -58,6 +58,7 @@ extern void	gql_link_destroy(gqlLink link);
 extern gqlValue	gql_int_create(agooErr err, int32_t i);
 extern gqlValue	gql_i64_create(agooErr err, int64_t i);
 extern gqlValue	gql_string_create(agooErr err, const char *str, int len);
+extern gqlValue	gql_id_create(agooErr err, const char *str, int len);
 extern gqlValue	gql_token_create(agooErr err, const char *str, int len, struct _gqlType *type);
 extern gqlValue	gql_var_create(agooErr err, const char *str, int len);
 extern gqlValue	gql_bool_create(agooErr err, bool b);
@@ -77,6 +78,7 @@ extern int	gql_object_set(agooErr err, gqlValue obj, const char *key, gqlValue i
 extern void	gql_int_set(gqlValue value, int32_t i);
 extern void	gql_i64_set(gqlValue value, int64_t i);
 extern int	gql_string_set(agooErr err, gqlValue value, const char *str, int len);
+extern int	gql_id_set(agooErr err, gqlValue value, const char *str, int len);
 extern int	gql_token_set(agooErr err, gqlValue value, const char *str, int len);
 extern void	gql_bool_set(gqlValue value, bool b);
 extern void	gql_float_set(gqlValue value, double f);
@@ -105,6 +107,7 @@ extern struct _gqlType	gql_time_type;
 extern struct _gqlType	gql_uuid_type;
 extern struct _gqlType	gql_string_type;
 extern struct _gqlType	gql_token_type;   // used for enum values
+extern struct _gqlType	gql_id_type;
 extern struct _gqlType	gql_var_type;     // used for variable keys
 
 #endif // AGOO_GQLVALUE_H

data/ext/agoo/graphql.c

@@ -8,6 +8,7 @@
 #include "graphql.h"
 #include "gqlintro.h"
 #include "gqlvalue.h"
+#include "log.h"
 #include "req.h"
 #include "res.h"
 
@@ -46,7 +47,7 @@ static const char	spaces[16] = "                ";
 
 gqlDir	gql_directives = NULL;
 
-static gqlType	schema_type = NULL;
+//static gqlType	schema_type = NULL;
 static bool	inited = false;
 
 static void	gql_frag_destroy(gqlFrag frag);
@@ -75,13 +76,16 @@ static const char*
 kind_string(gqlKind kind) {
     switch (kind) {
     case GQL_UNDEF:	return "undefined";
+    case GQL_SCHEMA:	return "schema";
     case GQL_OBJECT:	return "object";
+    case GQL_FRAG:	return "fragment";
     case GQL_INPUT:	return "input";
     case GQL_UNION:	return "union";
     case GQL_INTERFACE:	return "interface";
     case GQL_ENUM:	return "enum";
     case GQL_SCALAR:	return "scalar";
     case GQL_LIST:	return "list";
+    case GQL_NON_NULL:	return "non-null";
     default:		break;
     }
     return "unknown";
@@ -158,6 +162,7 @@ type_clean(gqlType type) {
     type->dir = NULL;
 
     switch (type->kind) {
+    case GQL_SCHEMA:
     case GQL_OBJECT:
     case GQL_INTERFACE: {
 	gqlField	f;
@@ -218,6 +223,7 @@ type_destroy(gqlType type) {
 	&gql_uuid_type == type ||
 	&gql_token_type == type ||
 	&gql_var_type == type ||
+	&gql_id_type == type ||
 	&gql_string_type == type) {
 
 	return;
@@ -348,62 +354,6 @@ type_remove(gqlType type) {
     }
 }
 
-int
-gql_init(agooErr err) {
-    gqlType	query_type;
-    gqlType	mutation_type;
-    gqlType	subscription_type;
-
-    if (inited) {
-	return AGOO_ERR_OK;
-    }
-    memset(buckets, 0, sizeof(buckets));
-    if (AGOO_ERR_OK != gql_value_init(err) ||
-	AGOO_ERR_OK != gql_intro_init(err)) {
-
-	return err->code;
-    }
-    if (NULL == (query_type = gql_type_create(err, "Query", "The GraphQL root Query.", 0, NULL)) ||
-	NULL == (mutation_type = gql_type_create(err, "Mutation", "The GraphQL root Mutation.", 0, NULL)) ||
-	NULL == (subscription_type = gql_type_create(err, "Subscription", "The GraphQL root Subscription.", 0, NULL)) ||
-	NULL == (schema_type = gql_type_create(err, "schema", "The GraphQL root Object.", 0, NULL)) ||
-
-	NULL == gql_type_field(err, schema_type, "query", query_type, NULL, "Root level query.", 0, false) ||
-	NULL == gql_type_field(err, schema_type, "mutation", mutation_type, NULL, "Root level mutation.", 0, false) ||
-	NULL == gql_type_field(err, schema_type, "subscription", subscription_type, NULL, "Root level subscription.", 0, false)) {
-
-	return err->code;
-    }
-    inited = true;
-
-    return AGOO_ERR_OK;
-}
-
-void
-gql_destroy() {
-    Slot	*sp = buckets;
-    Slot	s;
-    Slot	n;
-    int		i;
-    gqlDir	dir;
-
-    for (i = BUCKET_SIZE; 0 < i; i--, sp++) {
-	s = *sp;
-
-	*sp = NULL;
-	for (; NULL != s; s = n) {
-	    n = s->next;
-	    type_destroy(s->type);
-	    AGOO_FREE(s);
-	}
-    }
-    while (NULL != (dir = gql_directives)) {
-	gql_directives = dir->next;
-	dir_destroy(dir);
-    }
-    inited = false;
-}
-
 static gqlType
 type_create(agooErr err, gqlKind kind, const char *name, const char *desc, size_t dlen) {
     gqlType	type = gql_type_get(name);
@@ -438,10 +388,11 @@ type_create(agooErr err, gqlKind kind, const char *name, const char *desc, size_
 	}
 	type->kind = kind;
     } else if (type->core) {
-	agoo_err_set(err, AGOO_ERR_LOCK, "%d can not be modified.", name);
+	agoo_err_set(err, AGOO_ERR_LOCK, "%s can not be modified.", name);
 	return NULL;
     } else if (kind == type->kind) { // looks like it is being modified so remove all the old stuff
-	type_clean(type);
+	agoo_err_set(err, AGOO_ERR_LOCK, "%s already exists.", name);
+	return NULL;
     } else {
 	agoo_err_set(err, AGOO_ERR_LOCK, "%d already exists as a %s.", name, kind_string(type->kind));
 	return NULL;
@@ -449,17 +400,65 @@ type_create(agooErr err, gqlKind kind, const char *name, const char *desc, size_
     return type;
 }
 
+gqlType
+gql_schema_create(agooErr err, const char *desc, size_t dlen) {
+    gqlType	type = type_create(err, GQL_SCHEMA, "schema", desc, dlen);
+
+    if (NULL != type) {
+	type->fields = NULL;
+	type->interfaces = NULL;
+    }
+    return type;
+}
+
+int
+gql_init(agooErr err) {
+    if (inited) {
+	return AGOO_ERR_OK;
+    }
+    memset(buckets, 0, sizeof(buckets));
+    if (AGOO_ERR_OK != gql_value_init(err) ||
+	AGOO_ERR_OK != gql_intro_init(err)) {
+
+	return err->code;
+    }
+    inited = true;
+
+    return AGOO_ERR_OK;
+}
+
+extern gqlType	_gql_root_type;
+void
+gql_destroy() {
+    Slot	*sp = buckets;
+    Slot	s;
+    Slot	n;
+    int		i;
+    gqlDir	dir;
+
+    for (i = BUCKET_SIZE; 0 < i; i--, sp++) {
+	s = *sp;
+
+	*sp = NULL;
+	for (; NULL != s; s = n) {
+	    n = s->next;
+	    type_destroy(s->type);
+	    AGOO_FREE(s);
+	}
+    }
+    while (NULL != (dir = gql_directives)) {
+	gql_directives = dir->next;
+	dir_destroy(dir);
+    }
+    _gql_root_type = NULL;
+    inited = false;
+}
+
 static gqlType
 type_undef_create(agooErr err, const char *name) {
     return type_create(err, GQL_UNDEF, name, NULL, 0);
 }
 
-agooText
-gql_object_to_graphql(agooText text, gqlValue value, int indent, int depth) {
-    // TBD
-    return text;
-}
-
 gqlType
 gql_assure_type(agooErr err, const char *name) {
     gqlType	type = NULL;
@@ -679,9 +678,16 @@ gql_enum_create(agooErr err, const char *name, const char *desc, size_t dlen) {
 
 gqlEnumVal
 gql_enum_append(agooErr err, gqlType type, const char *value, size_t len, const char *desc, size_t dlen) {
-    gqlEnumVal	ev = (gqlEnumVal)AGOO_MALLOC(sizeof(struct _gqlEnumVal));
+    gqlEnumVal	last = type->choices;
+    gqlEnumVal	ev;
 
-    if (NULL == ev) {
+    for (; NULL != last; last = last->next) {
+	if (0 == strcmp(value, last->value)) {
+	    agoo_err_set(err, AGOO_ERR_TOO_MANY, "Enum %s already has a choice of %s.", type->name, value);
+	    return NULL;
+	}
+    }
+    if (NULL == (ev = (gqlEnumVal)AGOO_MALLOC(sizeof(struct _gqlEnumVal)))) {
 	AGOO_ERR_MEM(err, "GraphQL Enum Value");
 	return NULL;
     }
@@ -702,9 +708,7 @@ gql_enum_append(agooErr err, gqlType type, const char *value, size_t len, const
 	ev->next = type->choices;
 	type->choices = ev;
     } else {
-	gqlEnumVal	last = type->choices;
-
-	for (; NULL != last->next; last = last->next) {
+	for (last = type->choices; NULL != last->next; last = last->next) {
 	}
 	ev->next = NULL;
 	last->next = ev;
@@ -1038,6 +1042,18 @@ gql_type_sdl(agooText text, gqlType type, bool with_desc) {
 	desc_sdl(text, type->desc, 0);
     }
     switch (type->kind) {
+    case GQL_SCHEMA: {
+	gqlField	f;
+
+	text = agoo_text_append(text, "schema", 6);
+	text = append_dir_use(text, type->dir);
+	text = agoo_text_append(text, " {\n", 3);
+	for (f = type->fields; NULL != f; f = f->next) {
+	    text = field_sdl(text, f, with_desc);
+	}
+	text = agoo_text_append(text, "}\n", 2);
+	break;
+    }
     case GQL_OBJECT:
     case GQL_FRAG: {
 	gqlField	f;
@@ -1126,7 +1142,6 @@ gql_type_sdl(agooText text, gqlType type, bool with_desc) {
 	text = agoo_text_append(text, " {\n", 3);
 	for (a = type->args; NULL != a; a = a->next) {
 	    text = arg_sdl(text, a, with_desc, false, NULL == a->next);
-	    // TBD zzzzzz
 	}
 	text = agoo_text_append(text, "}\n", 2);
 	break;
@@ -1171,12 +1186,6 @@ type_cmp(const void *v0, const void *v1) {
     gqlType	t1 = *(gqlType*)v1;
 
     if (t0->kind == t1->kind) {
-	if (0 == strcmp("schema", t0->name)) {
-	    return -1;
-	}
-	if (0 == strcmp("schema", t1->name)) {
-	    return 1;
-	}
 	return strcmp(t0->name, t1->name);
     }
     return t0->kind - t1->kind;
@@ -1268,17 +1277,35 @@ gql_dir_use_arg(agooErr err, gqlDirUse use, const char *key, gqlValue value) {
     return AGOO_ERR_OK;
 }
 
-void
-gql_type_directive_use(gqlType type, gqlDirUse use) {
+int
+gql_type_directive_use(agooErr err, gqlType type, gqlDirUse use) {
     if (NULL == type->dir) {
 	type->dir = use;
+    } else if (0 == strcmp(use->dir->name, type->dir->dir->name)) {
+	return agoo_err_set(err, AGOO_ERR_TOO_MANY, "Directive %s on type %s is a duplicate.", use->dir->name, type->name);
     } else {
 	gqlDirUse	u = type->dir;
 
 	for (; NULL != u->next; u = u->next) {
+	    if (0 == strcmp(use->dir->name, u->dir->name)) {
+		return agoo_err_set(err, AGOO_ERR_TOO_MANY, "Directive %s on type %s is a duplicate.", use->dir->name, type->name);
+	    }
 	}
 	u->next = use;
     }
+    return AGOO_ERR_OK;
+}
+
+bool
+gql_type_has_directive_use(gqlType type, const char *dir) {
+    gqlDirUse	u = type->dir;
+
+    for (; NULL != u; u = u->next) {
+	if (0 == strcmp(dir, u->dir->name)) {
+	    return true;
+	}
+    }
+    return false;
 }
 
 gqlFrag
@@ -1617,7 +1644,9 @@ gql_dump_hook(agooReq req) {
     }
     text = gql_schema_sdl(text, with_desc, all);
     cnt = snprintf(buf, sizeof(buf), "HTTP/1.1 200 Okay\r\nContent-Type: application/graphql\r\nContent-Length: %ld\r\n\r\n", text->len);
-    text = agoo_text_prepend(text, buf, cnt);
+    if (NULL == (text = agoo_text_prepend(text, buf, cnt))) {
+	agoo_log_cat(&agoo_error_cat, "Failed to allocate memory for a GraphQL dump.");
+    }
     agoo_res_set_message(req->res, text);
 }
 
@@ -1629,6 +1658,7 @@ gql_type_get_field(gqlType type, const char *field) {
 	return NULL;
     }
     switch (type->kind) {
+    case GQL_SCHEMA:
     case GQL_OBJECT:
     case GQL_INTERFACE:
 	for (f = type->fields; NULL != f; f = f->next) {