agoo 2.6.1 → 2.7.0

data/ext/agoo/err.c

@@ -77,3 +77,10 @@ agoo_err_str(agooErrCode code) {
     }
     return str;
 }
+
+int
+agoo_err_memory(agooErr err, const char *type, const char *file, int line) {
+    return agoo_err_set(err, AGOO_ERR_MEMORY, "Failed to allocate memory for a %s at %s:%d.", type, file, line);
+}
+
+    

data/ext/agoo/err.h

@@ -8,6 +8,8 @@
 #define AGOO_ERR_START	300
 #define AGOO_ERR_INIT	{ 0, { 0 } }
 
+#define AGOO_ERR_MEM(err, type) agoo_err_memory(err, type, __FILE__, __LINE__)
+
 typedef enum {
     AGOO_ERR_OK	= 0,
     AGOO_ERR_MEMORY	= ENOMEM,
@@ -43,4 +45,6 @@ extern int		agoo_err_no(agooErr err, const char *fmt, ...);
 extern const char*	agoo_err_str(agooErrCode code);
 extern void		agoo_err_clear(agooErr err);
 
+extern int		agoo_err_memory(agooErr err, const char *type, const char *file, int line);
+
 #endif /* AGOO_ERR_H */

data/ext/agoo/error_stream.c

@@ -24,6 +24,12 @@ VALUE
 error_stream_new() {
     ErrorStream	es = (ErrorStream)AGOO_MALLOC(sizeof(struct _errorStream));
 
+    if (NULL == es) {
+	// Error stream is optional. If it is not there is still meets the
+	// specs. Better not to break everything if this fails.
+	return Qnil;
+    }
+    es->server = NULL;
     es->text = agoo_text_allocate(1024);
     
     return Data_Wrap_Struct(es_class, NULL, es_free, es);

data/ext/agoo/gqleval.c

@@ -64,7 +64,7 @@ value_resp(agooRes res, gqlValue result, int status, int indent) {
     gqlValue		msg = gql_object_create(&err);
 
     if (NULL == msg) {
-	agoo_err_set(&err, AGOO_ERR_MEMORY, "Out of memory.");
+	AGOO_ERR_MEM(&err, "response");
 	err_resp(res, &err, 500);
 	gql_value_destroy(result);
 	return;

data/ext/agoo/gqlvalue.c

@@ -824,7 +824,7 @@ gql_string_set(agooErr err, gqlValue value, const char *str, int len) {
 	} else {
 	    value->str.alloced = true;
 	    if (NULL == (value->str.ptr = AGOO_STRNDUP(str, len))) {
-		return agoo_err_set(err, AGOO_ERR_MEMORY, "strndup of length %d failed.", len);
+		return AGOO_ERR_MEM(err, "strndup()");
 	    }
 	}
     }
@@ -847,7 +847,7 @@ gql_token_set(agooErr err, gqlValue value, const char *str, int len) {
 	} else {
 	    value->str.alloced = true;
 	    if (NULL == (value->str.ptr = AGOO_STRNDUP(str, len))) {
-		return agoo_err_set(err, AGOO_ERR_MEMORY, "strndup of length %d failed.", len);
+		return AGOO_ERR_MEM(err, "strndup()");
 	    }
 	}
     }
@@ -912,13 +912,13 @@ gql_link_create(agooErr err, const char *key, gqlValue item) {
     gqlLink	link = (gqlLink)AGOO_MALLOC(sizeof(struct _gqlLink));
 
     if (NULL == link) {
-	agoo_err_set(err, AGOO_ERR_MEMORY, "Failed to allocation memory for a list link.");
+	AGOO_ERR_MEM(err, "GraphQL List Link");
     } else {
 	link->next = NULL;
 	link->key = NULL;
 	if (NULL != key) {
 	    if (NULL == (link->key = AGOO_STRDUP(key))) {
-		agoo_err_set(err, AGOO_ERR_MEMORY, "strdup() failed.");
+		AGOO_ERR_MEM(err, "strdup()");
 		return NULL;
 	    }
 	}
@@ -988,10 +988,9 @@ gql_object_set(agooErr err, gqlValue obj, const char *key, gqlValue item) {
 
 static gqlValue
 value_create(gqlType type) {
-    gqlValue	v = (gqlValue)AGOO_MALLOC(sizeof(struct _gqlValue));
+    gqlValue	v = (gqlValue)AGOO_CALLOC(1, sizeof(struct _gqlValue));
     
     if (NULL != v) {
-	memset(v, 0, sizeof(struct _gqlValue));
 	v->type = type;
     }
     return v;
@@ -1028,7 +1027,7 @@ gql_string_create(agooErr err, const char *str, int len) {
 	if ((int)sizeof(v->str.a) <= len) {
 	    v->str.alloced = true;
 	    if (NULL == (v->str.ptr = AGOO_STRNDUP(str, len))) {
-		agoo_err_set(err, AGOO_ERR_MEMORY, "strndup of length %d failed.", len);
+		AGOO_ERR_MEM(err, "strdup()");
 		return NULL;
 	    }
 	} else {
@@ -1054,7 +1053,7 @@ gql_token_create(agooErr err, const char *str, int len, gqlType type) {
 	if ((int)sizeof(v->str.a) <= len) {
 	    v->str.alloced = true;
 	    if (NULL == (v->str.ptr = AGOO_STRNDUP(str, len))) {
-		agoo_err_set(err, AGOO_ERR_MEMORY, "strndup of length %d failed.", len);
+		AGOO_ERR_MEM(err, "strdup()");
 		return NULL;
 	    }
 	} else {
@@ -1077,7 +1076,7 @@ gql_var_create(agooErr err, const char *str, int len) {
 	if ((int)sizeof(v->str.a) <= len) {
 	    v->str.alloced = true;
 	    if (NULL == (v->str.ptr = AGOO_STRNDUP(str, len))) {
-		agoo_err_set(err, AGOO_ERR_MEMORY, "strndup of length %d failed.", len);
+		AGOO_ERR_MEM(err, "strdup()");
 		return NULL;
 	    }
 	} else {
@@ -1547,7 +1546,7 @@ gql_value_dup(agooErr err, gqlValue value) {
     gqlValue	dup = value_create(value->type);
 
     if (NULL == dup) {
-	agoo_err_set(err, AGOO_ERR_MEMORY, "failed to duplicate a value.");
+	AGOO_ERR_MEM(err, "GraphQL Value");
 	return NULL;
     }
     switch (value->type->scalar_kind) {
@@ -1567,7 +1566,7 @@ gql_value_dup(agooErr err, gqlValue value) {
     case GQL_SCALAR_TOKEN:
 	if (value->str.alloced) {
 	    if (NULL == (dup->str.ptr = strdup(value->str.ptr))) {
-		agoo_err_set(err, AGOO_ERR_MEMORY, "strdup of length %d failed.", strlen(value->str.ptr));
+		AGOO_ERR_MEM(err, "strdup()");
 		AGOO_FREE(dup);
 		dup = NULL;
 	    }

data/ext/agoo/graphql.c

@@ -56,7 +56,7 @@ calc_hash(const char *name) {
     uint64_t		h = 0;
     const uint8_t	*k = (const uint8_t*)name;
     uint64_t		x;
-    
+
     for (; '\0' != *k; k++) {
 	if (0 == (x = name_chars[*k])) {
 	    return BAD_NAME;
@@ -90,16 +90,16 @@ kind_string(gqlKind kind) {
 static char*
 alloc_string(agooErr err, const char *s, size_t len) {
     char	*a = NULL;
-    
+
     if (NULL != s) {
 	if (0 >= len) {
 	    if (NULL == (a = AGOO_STRDUP(s))) {
-		agoo_err_set(err, AGOO_ERR_MEMORY, "strdup() failed.");
+		AGOO_ERR_MEM(err, "strdup()");
 	    }
 	    len = strlen(a);
 	} else {
 	    if (NULL == (a = AGOO_STRNDUP(s, len))) {
-		agoo_err_set(err, AGOO_ERR_MEMORY, "strndup() of length %d failed.", len);
+		AGOO_ERR_MEM(err, "strndup()");
 	    }
 	}
     }
@@ -110,7 +110,7 @@ static void
 free_dir_uses(gqlDirUse uses) {
     gqlDirUse	u;
     gqlLink	link;
-    
+
     while (NULL != (u = uses)) {
 	uses = u->next;
 	while (NULL != (link = u->args)) {
@@ -136,7 +136,7 @@ arg_destroy(gqlArg a) {
 static void
 field_destroy(gqlField f) {
     gqlArg	a;
-    
+
     AGOO_FREE((char*)f->name);
     AGOO_FREE((char*)f->desc);
     while (NULL != (a = f->args)) {
@@ -156,7 +156,7 @@ type_clean(gqlType type) {
     type->desc = NULL;
     free_dir_uses(type->dir);
     type->dir = NULL;
-    
+
     switch (type->kind) {
     case GQL_OBJECT:
     case GQL_INTERFACE: {
@@ -175,7 +175,7 @@ type_clean(gqlType type) {
     }
     case GQL_INPUT: {
 	gqlArg	a;
-    
+
 	while (NULL != (a = type->args)) {
 	    type->args = a->next;
 	    arg_destroy(a);
@@ -231,7 +231,7 @@ static void
 dir_clean(gqlDir dir) {
     gqlArg	a;
     gqlStrLink	link;
-    
+
     AGOO_FREE((char*)dir->desc);
     while (NULL != (a = dir->args)) {
 	dir->args = a->next;
@@ -304,7 +304,7 @@ gql_type_set(agooErr err, gqlType type) {
     } else {
 	Slot	*bucket = get_bucketp(h);
 	Slot	s;
-    
+
 	for (s = *bucket; NULL != s; s = s->next) {
 	    if (h == s->hash && 0 == strcmp(s->type->name, type->name)) {
 		type_destroy(s->type);
@@ -313,7 +313,7 @@ gql_type_set(agooErr err, gqlType type) {
 	    }
 	}
 	if (NULL == (s = (Slot)AGOO_MALLOC(sizeof(struct _slot)))) {
-	    return agoo_err_set(err, AGOO_ERR_MEMORY, "Failed to allocate memory for a GraphQL type.");
+	    return AGOO_ERR_MEM(err, "GraphQL Type");
 	}
 	s->hash = h;
 	s->type = type;
@@ -375,7 +375,7 @@ gql_init(agooErr err) {
 	return err->code;
     }
     inited = true;
-    
+
     return AGOO_ERR_OK;
 }
 
@@ -389,7 +389,7 @@ gql_destroy() {
 
     for (i = BUCKET_SIZE; 0 < i; i--, sp++) {
 	s = *sp;
-	
+
 	*sp = NULL;
 	for (; NULL != s; s = n) {
 	    n = s->next;
@@ -410,14 +410,17 @@ type_create(agooErr err, gqlKind kind, const char *name, const char *desc, size_
 
     if (NULL == type) {
 	if (NULL == (type = (gqlType)AGOO_MALLOC(sizeof(struct _gqlType)))) {
-	    agoo_err_set(err, AGOO_ERR_MEMORY, "Failed to allocate memory for a GraphQL Type.");
-	    return NULL;
+	    AGOO_ERR_MEM(err, "GraphQL Type");
+	    return type; // type will always be NULL but C++ checker flags this as an error otherwise
 	}
 	if (NULL == (type->name = AGOO_STRDUP(name))) {
-	    agoo_err_set(err, AGOO_ERR_MEMORY, "strdup of type name failed. %s:%d", __FILE__, __LINE__);
+	    AGOO_ERR_MEM(err, "strndup()");
+	    AGOO_FREE(type);
 	    return NULL;
 	}
 	if (NULL == (type->desc = alloc_string(err, desc, dlen)) && AGOO_ERR_OK != err->code) {
+	    AGOO_FREE((char*)type->name);
+	    AGOO_FREE(type);
 	    return NULL;
 	}
 	type->dir = NULL;
@@ -460,7 +463,7 @@ gql_object_to_graphql(agooText text, gqlValue value, int indent, int depth) {
 gqlType
 gql_assure_type(agooErr err, const char *name) {
     gqlType	type = NULL;
-    
+
     if (NULL != name) {
 	type = gql_type_get(name);
 
@@ -479,16 +482,20 @@ assure_directive(agooErr err, const char *name) {
 
     if (NULL == dir) {
 	if (NULL == (dir = (gqlDir)AGOO_MALLOC(sizeof(struct _gqlDir)))) {
-	    agoo_err_set(err, AGOO_ERR_MEMORY, "Failed to allocate memory for a GraphQL directive.");
-	    return NULL;
+	    AGOO_ERR_MEM(err, "GraphQL Directive");
+	} else {
+	    dir->next = gql_directives;
+	    gql_directives = dir;
+	    if (NULL == (dir->name = AGOO_STRDUP(name))) {
+		AGOO_ERR_MEM(err, "GraphQL Directive");
+		AGOO_FREE(dir);
+		return NULL;
+	    }
+	    dir->args = NULL;
+	    dir->locs = NULL;
+	    dir->defined = false;
+	    dir->desc = NULL;
 	}
-	dir->next = gql_directives;
-	gql_directives = dir;
-	dir->name = AGOO_STRDUP(name);
-	dir->args = NULL;
-	dir->locs = NULL;
-	dir->defined = false;
-	dir->desc = NULL;
     }
     return dir;
 }
@@ -514,14 +521,19 @@ gql_type_field(agooErr		err,
 	       size_t		dlen,
 	       bool		required) {
     gqlField	f = (gqlField)AGOO_MALLOC(sizeof(struct _gqlField));
-    
+
     if (NULL == f) {
-	agoo_err_set(err, AGOO_ERR_MEMORY, "Failed to allocate memory for a GraphQL field.");
+	AGOO_ERR_MEM(err, "GraphQL Field");
     } else {
 	f->next = NULL;
-	f->name = AGOO_STRDUP(name);
+	if (NULL == (f->name = AGOO_STRDUP(name))) {
+	    AGOO_ERR_MEM(err, "strdup()");
+	    AGOO_FREE(f);
+	    return NULL;
+	}
 	f->type = return_type;
 	if (NULL == (f->desc = alloc_string(err, desc, dlen)) && AGOO_ERR_OK != err->code) {
+	    AGOO_FREE(f);
 	    return NULL;
 	}
 	f->args = NULL;
@@ -551,14 +563,19 @@ gql_field_arg(agooErr		err,
 	      struct _gqlValue	*def_value,
 	      bool		required) {
     gqlArg	a = (gqlArg)AGOO_MALLOC(sizeof(struct _gqlArg));
-    
+
     if (NULL == a) {
-	agoo_err_set(err, AGOO_ERR_MEMORY, "Failed to allocate memory for a GraphQL field argument.");
+	AGOO_ERR_MEM(err, "GraphQL Field Argument");
     } else {
 	a->next = NULL;
-	a->name = AGOO_STRDUP(name);
+	if (NULL == (a->name = AGOO_STRDUP(name))) {
+	    AGOO_ERR_MEM(err, "strdup()");
+	    AGOO_FREE(a);
+	    return NULL;
+	}
 	a->type = type;
 	if (NULL == (a->desc = alloc_string(err, desc, dlen)) && AGOO_ERR_OK != err->code) {
+	    AGOO_FREE(a);
 	    return NULL;
 	}
 	a->default_value = def_value;
@@ -577,6 +594,47 @@ gql_field_arg(agooErr		err,
     return a;
 }
 
+gqlArg
+gql_input_arg(agooErr		err,
+	      gqlType		input,
+	      const char	*name,
+	      gqlType		type,
+	      const char	*desc,
+	      size_t		dlen,
+	      struct _gqlValue	*def_value,
+	      bool		required) {
+    gqlArg	a = (gqlArg)AGOO_MALLOC(sizeof(struct _gqlArg));
+
+    if (NULL == a) {
+	AGOO_ERR_MEM(err, "GraphQL Input Argument");
+    } else {
+	a->next = NULL;
+	if (NULL == (a->name = AGOO_STRDUP(name))) {
+	    AGOO_ERR_MEM(err, "strdup()");
+	    AGOO_FREE(a);
+	    return NULL;
+	}
+	a->type = type;
+	if (NULL == (a->desc = alloc_string(err, desc, dlen)) && AGOO_ERR_OK != err->code) {
+	    AGOO_FREE(a);
+	    return NULL;
+	}
+	a->default_value = def_value;
+	a->dir = NULL;
+	a->required = required;
+	if (NULL == input->args) {
+	    input->args = a;
+	} else {
+	    gqlArg	end;
+
+	    for (end = input->args; NULL != end->next; end = end->next) {
+	    }
+	    end->next = a;
+	}
+    }
+    return a;
+}
+
 gqlType
 gql_union_create(agooErr err, const char *name, const char *desc, size_t dlen) {
     gqlType	type = type_create(err, GQL_UNION, name, desc, dlen);
@@ -592,7 +650,7 @@ gql_union_add(agooErr err, gqlType type, gqlType member) {
     gqlTypeLink	link = (gqlTypeLink)AGOO_MALLOC(sizeof(struct _gqlTypeLink));
 
     if (NULL == link) {
-	return agoo_err_set(err, AGOO_ERR_MEMORY, "Failed to allocate memory for a GraphQL Union value.");
+	return AGOO_ERR_MEM(err, "GraphQL Union Value");
     }
     link->type = member;
     if (NULL == type->types) {
@@ -624,18 +682,20 @@ gql_enum_append(agooErr err, gqlType type, const char *value, size_t len, const
     gqlEnumVal	ev = (gqlEnumVal)AGOO_MALLOC(sizeof(struct _gqlEnumVal));
 
     if (NULL == ev) {
-	agoo_err_set(err, AGOO_ERR_MEMORY, "Failed to allocate memory for a GraphQL Enum value.");
+	AGOO_ERR_MEM(err, "GraphQL Enum Value");
 	return NULL;
     }
     if (0 >= len) {
 	len = strlen(value);
     }
     if (NULL == (ev->value = AGOO_STRNDUP(value, len))) {
-	agoo_err_set(err, AGOO_ERR_MEMORY, "strndup of length %d failed. %s:%d", len, __FILE__, __LINE__);
+	AGOO_ERR_MEM(err, "strdup()");
+	AGOO_FREE(ev);
 	return NULL;
     }
     ev->dir = NULL;
     if (NULL == (ev->desc = alloc_string(err, desc, dlen)) && AGOO_ERR_OK != err->code) {
+	AGOO_FREE(ev);
 	return NULL;
     }
     if (NULL == type->choices) {
@@ -673,21 +733,14 @@ gql_interface_create(agooErr err, const char *name, const char *desc, size_t dle
     return type;
 }
 
-// TBD this is not correct. Is it used?
-static agooText
-scalar_to_text(agooText text, gqlValue value, int indent, int depth) {
-    printf("********** scalar_to_text\n");
-    return text;
-}
-
 // Create a scalar type that will be represented as a string.
 gqlType
 gql_scalar_create(agooErr err, const char *name, const char *desc, size_t dlen) {
     gqlType	type = type_create(err, GQL_SCALAR, name, desc, dlen);
 
     if (NULL != type) {
-	type->to_json = scalar_to_text;
-	type->to_sdl = scalar_to_text;
+	type->to_json = NULL;
+	type->to_sdl = NULL;
 	type->destroy = NULL;
     }
     return type;
@@ -714,19 +767,24 @@ gql_directive_create(agooErr err, const char *name, const char *desc, size_t dle
 	}
     } else {
 	if (NULL == (dir = (gqlDir)AGOO_MALLOC(sizeof(struct _gqlDir)))) {
-	    agoo_err_set(err, AGOO_ERR_MEMORY, "Failed to allocate memory for a GraphQL directive.");
+	    AGOO_ERR_MEM(err, "GraphQL Directive");
+	    return NULL;
+	}
+	if (NULL == (dir->name = AGOO_STRDUP(name))) {
+	    AGOO_ERR_MEM(err, "strdup()");
+	    AGOO_FREE(dir);
 	    return NULL;
 	}
-	dir->next = gql_directives;
-	gql_directives = dir;
-	dir->name = AGOO_STRDUP(name);
 	dir->args = NULL;
 	dir->locs = NULL;
 	dir->defined = true;
 	dir->core = false;
 	if (NULL == (dir->desc = alloc_string(err, desc, dlen)) && AGOO_ERR_OK != err->code) {
+	    AGOO_FREE(dir);
 	    return NULL;
 	}
+	dir->next = gql_directives;
+	gql_directives = dir;
     }
     return dir;
 }
@@ -742,14 +800,19 @@ gql_dir_arg(agooErr 		err,
 	    bool 		required) {
 
     gqlArg	a = (gqlArg)AGOO_MALLOC(sizeof(struct _gqlArg));
-    
+
     if (NULL == a) {
-	agoo_err_set(err, AGOO_ERR_MEMORY, "Failed to allocate memory for a GraphQL directive argument.");
+	AGOO_ERR_MEM(err, "GraphQL Directive Argument");
     } else {
 	a->next = NULL;
-	a->name = AGOO_STRDUP(name);
+	if (NULL == (a->name = AGOO_STRDUP(name))) {
+	    AGOO_ERR_MEM(err, "strdup()");
+	    AGOO_FREE(a);
+	    return NULL;
+	}
 	a->type = type;
 	if (NULL == (a->desc = alloc_string(err, desc, dlen)) && AGOO_ERR_OK != err->code) {
+	    AGOO_FREE(a);
 	    return NULL;
 	}
 	a->default_value = def_value;
@@ -774,7 +837,7 @@ gql_directive_on(agooErr err, gqlDir d, const char *on, int len) {
     gqlStrLink	loc;
 
     if (NULL == link) {
-	agoo_err_set(err, AGOO_ERR_MEMORY, "Failed to allocate memory for a GraphQL directive location.");
+	AGOO_ERR_MEM(err, "GraphQL Directive Location");
     }
     if (0 >= len) {
 	len = (int)strlen(on);
@@ -789,7 +852,7 @@ gql_directive_on(agooErr err, gqlDir d, const char *on, int len) {
 	loc->next = link;
     }
     if (NULL == (link->str = AGOO_STRNDUP(on, len))) {
-	return agoo_err_set(err, AGOO_ERR_MEMORY, "strndup of length %d failed. %s:%d", len, __FILE__, __LINE__);
+	return AGOO_ERR_MEM(err, "strdup()");
     }
     return AGOO_ERR_OK;
 }
@@ -850,7 +913,7 @@ desc_sdl(agooText text, const char *desc, int indent) {
 	    if (0 < indent) {
 		const char	*start = desc;
 		const char	*d = desc;
-	    
+
 		for (; '\0' != *d; d++) {
 		    if ('\r' == *d) {
 			int	len = (int)(d - start);
@@ -887,27 +950,6 @@ desc_sdl(agooText text, const char *desc, int indent) {
     return text;
 }
 
-static agooText
-arg_sdl(agooText text, gqlArg a, bool with_desc, bool last) {
-    if (with_desc) {
-	text = desc_sdl(text, a->desc, 4);
-    }
-    text = agoo_text_append(text, a->name, -1);
-    text = agoo_text_append(text, ": ", 2);
-    text = agoo_text_append(text, a->type->name, -1);
-    if (a->required) {
-	text = agoo_text_append(text, "!", 1);
-    }
-    if (NULL != a->default_value) {
-	text = agoo_text_append(text, " = ", 3);
-	text = gql_value_sdl(text, a->default_value, 0, 0);
-    }
-    if (!last) {
-	text = agoo_text_append(text, ", ", 2);
-    }
-    return text;
-}
-
 static agooText
 append_dir_use(agooText text, gqlDirUse use) {
     for (; NULL != use; use = use->next) {
@@ -915,19 +957,50 @@ append_dir_use(agooText text, gqlDirUse use) {
 	text = agoo_text_append(text, use->dir->name, -1);
 	if (NULL != use->args) {
 	    gqlLink	link;
-	    
+
 	    text = agoo_text_append(text, "(", 1);
 	    for (link = use->args; NULL != link; link = link->next) {
 		text = agoo_text_append(text, link->key, -1);
 		text = agoo_text_append(text, ": ", 2);
 		text = gql_value_sdl(text, link->value, 0, 0);
 	    }
-	    text = agoo_text_append(text, ")", 1);
+	    text = agoo_text_append_char(text, ')');
 	}
     }
     return text;
 }
 
+static agooText
+arg_sdl(agooText text, gqlArg a, bool with_desc, bool same_line, bool last) {
+    if (with_desc) {
+	text = desc_sdl(text, a->desc, 4);
+    }
+    if (!same_line) {
+	text = agoo_text_append(text, "  ", 2);
+    }
+    text = agoo_text_append(text, a->name, -1);
+    text = agoo_text_append(text, ": ", 2);
+    if (NULL != a->type) { // should always be true
+	text = agoo_text_append(text, a->type->name, -1);
+    }
+    if (a->required) {
+	text = agoo_text_append(text, "!", 1);
+    }
+    if (NULL != a->default_value) {
+	text = agoo_text_append(text, " = ", 3);
+	text = gql_value_sdl(text, a->default_value, 0, 0);
+    }
+    if (same_line) {
+	if (!last) {
+	    text = agoo_text_append(text, ", ", 2);
+	}
+    } else {
+	text = append_dir_use(text, a->dir);
+	text = agoo_text_append_char(text, '\n');
+    }
+    return text;
+}
+
 static agooText
 field_sdl(agooText text, gqlField f, bool with_desc) {
     if (with_desc) {
@@ -940,7 +1013,7 @@ field_sdl(agooText text, gqlField f, bool with_desc) {
 
 	text = agoo_text_append(text, "(", 1);
 	for (a = f->args; NULL != a; a = a->next) {
-	    text = arg_sdl(text, a, with_desc, NULL == a->next);
+	    text = arg_sdl(text, a, with_desc, true, NULL == a->next);
 	}
 	text = agoo_text_append(text, ")", 1);
     }
@@ -954,7 +1027,7 @@ field_sdl(agooText text, gqlField f, bool with_desc) {
 	text = gql_value_sdl(text, f->default_value, 0, 0);
     }
     text = append_dir_use(text, f->dir);
-    text = agoo_text_append(text, "\n", 1);
+    text = agoo_text_append_char(text, '\n');
 
     return text;
 }
@@ -1007,7 +1080,7 @@ gql_type_sdl(agooText text, gqlType type, bool with_desc) {
     }
     case GQL_ENUM: {
 	gqlEnumVal	ev;
-	
+
 	text = agoo_text_append(text, "enum ", 5);
 	text = agoo_text_append(text, type->name, -1);
 	text = append_dir_use(text, type->dir);
@@ -1052,7 +1125,8 @@ gql_type_sdl(agooText text, gqlType type, bool with_desc) {
 	text = append_dir_use(text, type->dir);
 	text = agoo_text_append(text, " {\n", 3);
 	for (a = type->args; NULL != a; a = a->next) {
-	    text = arg_sdl(text, a, with_desc, NULL == a->next);
+	    text = arg_sdl(text, a, with_desc, false, NULL == a->next);
+	    // TBD zzzzzz
 	}
 	text = agoo_text_append(text, "}\n", 2);
 	break;
@@ -1066,7 +1140,7 @@ gql_type_sdl(agooText text, gqlType type, bool with_desc) {
 agooText
 gql_directive_sdl(agooText text, gqlDir d, bool with_desc) {
     gqlStrLink	link;
-    
+
     if (with_desc) {
 	text = desc_sdl(text, d->desc, 0);
     }
@@ -1077,7 +1151,7 @@ gql_directive_sdl(agooText text, gqlDir d, bool with_desc) {
 
 	text = agoo_text_append(text, "(", 1);
 	for (a = d->args; NULL != a; a = a->next) {
-	    text = arg_sdl(text, a, with_desc, NULL == a->next);
+	    text = arg_sdl(text, a, with_desc, true, NULL == a->next);
 	}
 	text = agoo_text_append(text, ")", 1);
     }
@@ -1132,7 +1206,7 @@ gql_schema_sdl(agooText text, bool with_desc, bool all) {
     if (0 < cnt) {
 	gqlType	types[cnt];
 	gqlType	*tp = types;
-	
+
 	for (bucket = buckets, i = 0; i < BUCKET_SIZE; bucket++, i++) {
 	    for (s = *bucket; NULL != s; s = s->next) {
 		type = s->type;
@@ -1169,9 +1243,10 @@ gql_dir_use_create(agooErr err, const char *name) {
     gqlDirUse	use;
 
     if (NULL == (use = (gqlDirUse)AGOO_MALLOC(sizeof(struct _gqlDirUse)))) {
-	agoo_err_set(err, AGOO_ERR_MEMORY, "Failed to allocate memory for a directive useage.");
+	AGOO_ERR_MEM(err, "GraphQL Directive Usage");
     } else {
 	if (NULL == (use->dir = assure_directive(err, name))) {
+	    AGOO_FREE(use);
 	    return NULL;
 	}
 	use->next = NULL;
@@ -1189,7 +1264,7 @@ gql_dir_use_arg(agooErr err, gqlDirUse use, const char *key, gqlValue value) {
     }
     link->next = use->args;
     use->args = link;
-    
+
     return AGOO_ERR_OK;
 }
 
@@ -1209,14 +1284,15 @@ gql_type_directive_use(gqlType type, gqlDirUse use) {
 gqlFrag
 gql_fragment_create(agooErr err, const char *name, gqlType on) {
     gqlFrag	frag = (gqlFrag)AGOO_MALLOC(sizeof(struct _gqlFrag));
-    
+
     if (NULL == frag) {
-	agoo_err_set(err, AGOO_ERR_MEMORY, "fragment creation failed. %s:%d", __FILE__, __LINE__);
+	AGOO_ERR_MEM(err, "GraphQL Fragment");
     } else {
 	frag->next = NULL;
 	if (NULL != name) {
 	    if (NULL == (frag->name = AGOO_STRDUP(name))) {
-		agoo_err_set(err, AGOO_ERR_MEMORY, "strdup of fragment name failed. %s:%d", __FILE__, __LINE__);
+		AGOO_ERR_MEM(err, "strdup()");
+		AGOO_FREE(frag);
 		return NULL;
 	    }
 	} else {
@@ -1244,9 +1320,9 @@ gql_validate(agooErr err) {
 gqlDoc
 gql_doc_create(agooErr err) {
     gqlDoc	doc = (gqlDoc)AGOO_MALLOC(sizeof(struct _gqlDoc));
-    
+
     if (NULL == doc) {
-	agoo_err_set(err, AGOO_ERR_MEMORY, "GraphQL Document creation failed. %s:%d", __FILE__, __LINE__);
+	AGOO_ERR_MEM(err, "GraphQL Document");
     } else {
 	doc->ops = NULL;
 	doc->vars = NULL;
@@ -1258,14 +1334,15 @@ gql_doc_create(agooErr err) {
 gqlOp
 gql_op_create(agooErr err, const char *name, gqlOpKind kind) {
     gqlOp	op = (gqlOp)AGOO_MALLOC(sizeof(struct _gqlOp));
-    
+
     if (NULL == op) {
-	agoo_err_set(err, AGOO_ERR_MEMORY, "GraphQL Operation creation failed. %s:%d", __FILE__, __LINE__);
+	AGOO_ERR_MEM(err, "GraphQL Operation");
     } else {
 	op->next = NULL;
 	if (NULL != name && '\0' != *name) {
 	    if (NULL == (op->name = AGOO_STRDUP(name))) {
-		agoo_err_set(err, AGOO_ERR_MEMORY, "strdup of operation name failed. %s:%d", __FILE__, __LINE__);
+		AGOO_ERR_MEM(err, "strdup()");
+		AGOO_FREE(op);
 		return NULL;
 	    }
 	} else {
@@ -1301,7 +1378,7 @@ static void
 sel_destroy(gqlSel sel) {
     gqlSelArg	arg;
     gqlSel	s;
-    
+
     AGOO_FREE((char*)sel->alias);
     AGOO_FREE((char*)sel->name);
     while (NULL != (arg = sel->args)) {
@@ -1356,7 +1433,7 @@ gql_doc_destroy(gqlDoc doc) {
     gqlOp	op;
     gqlFrag	frag;
     gqlVar	var;
-    
+
     while (NULL != (op = doc->ops)) {
 	doc->ops = op->next;
 	gql_op_destroy(op);
@@ -1380,7 +1457,7 @@ sel_sdl(agooText text, gqlSel sel, int depth) {
 	indent = sizeof(spaces) - 1;
     }
     text = agoo_text_append(text, spaces, indent);
-    if (NULL != sel->frag) {	
+    if (NULL != sel->frag) {
 	text = agoo_text_append(text, "...", 3);
 	text = agoo_text_append(text, sel->frag, -1);
 	text = append_dir_use(text, sel->dir);
@@ -1391,7 +1468,7 @@ sel_sdl(agooText text, gqlSel sel, int depth) {
 	    text = agoo_text_append(text, "... on ", 7);
 	    text = agoo_text_append(text, sel->inline_frag->on->name, -1);
 	}
-	text = append_dir_use(text, sel->dir);
+	text = append_dir_use(text, sel->inline_frag->dir);
 	if (NULL != sel->inline_frag->sels) {
 	    gqlSel	s;
 	    int		d2 = depth + 1;
@@ -1411,7 +1488,7 @@ sel_sdl(agooText text, gqlSel sel, int depth) {
 	text = agoo_text_append(text, sel->name, -1);
 	if (NULL != sel->args) {
 	    gqlSelArg	arg;
-	
+
 	    text = agoo_text_append(text, "(", 1);
 	    for (arg = sel->args; NULL != arg; arg = arg->next) {
 		text = agoo_text_append(text, arg->name, -1);
@@ -1434,7 +1511,7 @@ sel_sdl(agooText text, gqlSel sel, int depth) {
 	if (NULL != sel->sels) {
 	    gqlSel	s;
 	    int		d2 = depth + 1;
-	
+
 	    text = agoo_text_append(text, " {\n", 3);
 	    for (s = sel->sels; NULL != s; s = s->next) {
 		text = sel_sdl(text, s, d2);
@@ -1451,7 +1528,7 @@ sel_sdl(agooText text, gqlSel sel, int depth) {
 static agooText
 op_sdl(agooText text, gqlOp op) {
     gqlSel	sel;
-    
+
     text = agoo_text_append(text, "query", 5);
     if (NULL != op->name) {
 	text = agoo_text_append(text, " ", 1);
@@ -1459,7 +1536,7 @@ op_sdl(agooText text, gqlOp op) {
     }
     if (NULL != op->vars) {
 	gqlVar	var;
-	
+
 	text = agoo_text_append(text, "(", 1);
 	for (var = op->vars; NULL != var; var = var->next) {
 	    text = agoo_text_append(text, "$", 1);
@@ -1491,7 +1568,7 @@ op_sdl(agooText text, gqlOp op) {
 static agooText
 frag_sdl(agooText text, gqlFrag frag) {
     gqlSel	sel;
-    
+
     text = agoo_text_append(text, "fragment ", 9);
     text = agoo_text_append(text, frag->name, -1);
     text = agoo_text_append(text, " on ", 4);
@@ -1510,7 +1587,7 @@ agooText
 gql_doc_sdl(gqlDoc doc, agooText text) {
     gqlOp	op;
     gqlFrag	frag;
-    
+
     for (op = doc->ops; NULL != op; op = op->next) {
 	op_sdl(text, op);
     }
@@ -1572,4 +1649,3 @@ gql_type_get_field(gqlType type, const char *field) {
     }
     return NULL;
 }
-