agoo 2.5.7 → 2.6.0

data/ext/agoo/gqlvalue.h

@@ -20,14 +20,22 @@ typedef struct _gqlLink {
 typedef struct _gqlValue {
     struct _gqlType		*type;
     union {
-	char			*url;
 	int32_t			i;
 	int64_t			i64;
 	double			f;
 	bool			b;
 	int64_t			time;
-	char			*str;
-	char			str16[16];
+	union {
+	    struct {
+		char		alloced;
+		char		a[15];
+	    };
+	    struct {
+		char		x; // same memory location as kind
+		char		pad[7];
+		const char	*ptr;
+	    };
+	} str;
 	struct {
 	    uint64_t		hi;
 	    uint64_t		lo;
@@ -42,11 +50,16 @@ typedef struct _gqlValue {
 extern int	gql_value_init(agooErr err);
 
 extern void	gql_value_destroy(gqlValue value);
+extern gqlValue	gql_value_dup(agooErr err, gqlValue value);
+
+extern gqlLink	gql_link_create(agooErr err, const char *key, gqlValue value);
+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_url_create(agooErr err, const char *url, 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);
 extern gqlValue	gql_float_create(agooErr err, double f);
 extern gqlValue	gql_time_create(agooErr err, int64_t t);
@@ -54,7 +67,7 @@ extern gqlValue	gql_time_str_create(agooErr err, const char *str, int len);
 extern gqlValue	gql_uuid_create(agooErr err, uint64_t hi, uint64_t lo);
 extern gqlValue	gql_uuid_str_create(agooErr err, const char *str, int len);
 extern gqlValue	gql_null_create(agooErr err);
-extern gqlValue	gql_list_create(agooErr err, struct _gqlType *itemType);
+extern gqlValue	gql_list_create(agooErr err, struct _gqlType *item_type);
 extern gqlValue	gql_object_create(agooErr err);
 
 extern int	gql_list_append(agooErr err, gqlValue list, gqlValue item);
@@ -64,7 +77,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_url_set(agooErr err, gqlValue value, const char *url, 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);
 extern void	gql_time_set(gqlValue value, int64_t t);
@@ -73,7 +86,15 @@ extern void	gql_uuid_set(gqlValue value, uint64_t hi, uint64_t lo);
 extern int	gql_uuid_str_set(agooErr err, gqlValue value, const char *str, int len);
 extern void	gql_null_set(gqlValue value);
 
+extern const char*	gql_string_get(gqlValue value);
+
 extern agooText	gql_value_json(agooText text, gqlValue value, int indent, int depth);
+extern agooText	gql_value_sdl(agooText text, gqlValue value, int indent, int depth);
+
+//extern agooText	gql_object_to_json(agooText text, gqlValue value, int indent, int depth);
+extern agooText	gql_object_to_sdl(agooText text, gqlValue value, int indent, int depth);
+
+extern int	gql_value_convert(agooErr err, gqlValue value, struct _gqlType *type);
 
 extern struct _gqlType	gql_null_type;
 extern struct _gqlType	gql_int_type;
@@ -82,7 +103,8 @@ extern struct _gqlType	gql_bool_type;
 extern struct _gqlType	gql_float_type;
 extern struct _gqlType	gql_time_type;
 extern struct _gqlType	gql_uuid_type;
-extern struct _gqlType	gql_url_type;
 extern struct _gqlType	gql_string_type;
+extern struct _gqlType	gql_token_type;   // used for enum values
+extern struct _gqlType	gql_var_type;     // used for variable keys
 
 #endif // AGOO_GQLVALUE_H

data/ext/agoo/graphql.c

@@ -44,11 +44,12 @@ static uint8_t	name_chars[256] = "\
 
 static const char	spaces[16] = "                ";
 
-static gqlType	query_type = NULL;
-static gqlType	mutation_type = NULL;
-static gqlType	subscription_type = NULL;
+gqlDir	gql_directives = NULL;
+
 static gqlType	schema_type = NULL;
-static gqlDir	directives = NULL;
+static bool	inited = false;
+
+static void	gql_frag_destroy(gqlFrag frag);
 
 static uint64_t
 calc_hash(const char *name) {
@@ -70,89 +71,184 @@ get_bucketp(uint64_t h) {
     return buckets + (BUCKET_MASK & (h ^ (h << 5) ^ (h >> 7)));
 }
 
-static void
-type_destroy(gqlType type) {
-    if (!type->core) {
-	free((char*)type->name);
-	free((char*)type->desc);
-	switch (type->kind) {
-	case GQL_OBJECT:
-	case GQL_FRAG:
-	case GQL_INTERFACE:
-	case GQL_INPUT: {
-	    gqlField	f;
-	    gqlArg	a;
-	
-	    while (NULL != (f = type->fields)) {
-		type->fields = f->next;
-		while (NULL != (a = f->args)) {
-		    f->args = a->next;
-		    free((char*)a->name);
-		    free((char*)a->type_name);
-		    free((char*)a->desc);
-		    gql_value_destroy(a->default_value);
-		    DEBUG_FREE(mem_graphql_arg, a);
-		    free(a);
-		}
-		free((char*)f->name);
-		free((char*)f->desc);
-		DEBUG_FREE(mem_graphql_field, f);
-		free(f);
+static const char*
+kind_string(gqlKind kind) {
+    switch (kind) {
+    case GQL_UNDEF:	return "undefined";
+    case GQL_OBJECT:	return "object";
+    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";
+    default:		break;
+    }
+    return "unknown";
+}
+
+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.");
+	    }
+	    len = strlen(a);
+	} else {
+	    if (NULL == (a = AGOO_STRNDUP(s, len))) {
+		agoo_err_set(err, AGOO_ERR_MEMORY, "strndup() of length %d failed.", len);
 	    }
-	    free(type->interfaces);
-	    break;
 	}
-	case GQL_UNION: {
-	    gqlTypeLink	link;
+    }
+    return a;
+}
 
-	    while (NULL != (link = type->types)) {
-		type->types = link->next;
-		free(link->name);
-		free(link);
-	    }
-	    break;
+static void
+free_dir_uses(gqlDirUse uses) {
+    gqlDirUse	u;
+    gqlLink	link;
+    
+    while (NULL != (u = uses)) {
+	uses = u->next;
+	while (NULL != (link = u->args)) {
+	    u->args = link->next;
+	    gql_link_destroy(link);
 	}
-	case GQL_ENUM: {
-	    gqlStrLink	link;
+	AGOO_FREE(u);
+    }
+}
 
-	    while (NULL != (link = type->choices)) {
-		type->choices = link->next;
-		free(link->str);
-		free(link);
-	    }
-	    break;
+static void
+arg_destroy(gqlArg a) {
+    AGOO_FREE((char*)a->name);
+    AGOO_FREE((char*)a->desc);
+    if (NULL != a->default_value) {
+	gql_value_destroy(a->default_value);
+    }
+    free_dir_uses(a->dir);
+
+    AGOO_FREE(a);
+}
+
+static void
+field_destroy(gqlField f) {
+    gqlArg	a;
+    
+    AGOO_FREE((char*)f->name);
+    AGOO_FREE((char*)f->desc);
+    while (NULL != (a = f->args)) {
+	f->args = a->next;
+	arg_destroy(a);
+    }
+    free_dir_uses(f->dir);
+    if (NULL != f->default_value) {
+	gql_value_destroy(f->default_value);
+    }
+    AGOO_FREE(f);
+}
+
+static void
+type_clean(gqlType type) {
+    AGOO_FREE((char*)type->desc);
+    type->desc = NULL;
+    free_dir_uses(type->dir);
+    type->dir = NULL;
+    
+    switch (type->kind) {
+    case GQL_OBJECT:
+    case GQL_INTERFACE: {
+	gqlField	f;
+	gqlTypeLink	link;
+
+	while (NULL != (f = type->fields)) {
+	    type->fields = f->next;
+	    field_destroy(f);
 	}
-	default:
-	    break;
+	while (NULL != (link = type->interfaces)) {
+	    type->interfaces = link->next;
+	    AGOO_FREE(link);
 	}
-	DEBUG_FREE(mem_graphql_type, type);
-	free(type);
+	break;
+    }
+    case GQL_INPUT: {
+	gqlArg	a;
+    
+	while (NULL != (a = type->args)) {
+	    type->args = a->next;
+	    arg_destroy(a);
+	}
+	break;
+    }
+    case GQL_UNION: {
+	gqlTypeLink	link;
+
+	while (NULL != (link = type->types)) {
+	    type->types = link->next;
+	    AGOO_FREE(link);
+	}
+	break;
+    }
+    case GQL_ENUM: {
+	gqlEnumVal	ev;
+
+	while (NULL != (ev = type->choices)) {
+	    type->choices = ev->next;
+	    AGOO_FREE((char*)ev->value);
+	    AGOO_FREE((char*)ev->desc);
+	    free_dir_uses(ev->dir);
+	    AGOO_FREE(ev);
+	}
+	break;
+    }
+    default:
+	break;
     }
 }
 
 static void
-dir_destroy(gqlDir dir) {
+type_destroy(gqlType type) {
+    if (&gql_int_type == type ||
+	&gql_i64_type == type ||
+	&gql_bool_type == type ||
+	&gql_float_type == type ||
+	&gql_time_type == type ||
+	&gql_uuid_type == type ||
+	&gql_token_type == type ||
+	&gql_var_type == type ||
+	&gql_string_type == type) {
+
+	return;
+    }
+    type_clean(type);
+    AGOO_FREE((char*)type->name);
+    AGOO_FREE(type);
+}
+
+static void
+dir_clean(gqlDir dir) {
     gqlArg	a;
     gqlStrLink	link;
     
-    free((char*)dir->name);
-    free((char*)dir->desc);
+    AGOO_FREE((char*)dir->desc);
     while (NULL != (a = dir->args)) {
 	dir->args = a->next;
-	free((char*)a->name);
-	free((char*)a->type_name);
-	free((char*)a->desc);
-	gql_value_destroy(a->default_value);
-	DEBUG_FREE(mem_graphql_arg, a);
-	free(a);
+	arg_destroy(a);
     }
     while (NULL != (link = dir->locs)) {
 	dir->locs = link->next;
-	free(link->str);
-	free(link);
+	AGOO_FREE(link->str);
+	AGOO_FREE(link);
     }
-    DEBUG_FREE(mem_graphql_directive, dir);
-    free(dir);
+}
+
+static void
+dir_destroy(gqlDir dir) {
+    AGOO_FREE((char*)dir->name);
+    dir_clean(dir);
+    AGOO_FREE(dir);
 }
 
 gqlType
@@ -174,9 +270,22 @@ gql_type_get(const char *name) {
     return type;
 }
 
+void
+gql_type_iterate(void (*fun)(gqlType type, void *ctx), void *ctx) {
+    Slot	*sp = buckets;
+    Slot	s;
+    int		i;
+
+    for (i = BUCKET_SIZE; 0 < i; i--, sp++) {
+	for (s = *sp; NULL != s; s = s->next) {
+	    fun(s->type, ctx);
+	}
+    }
+}
+
 gqlDir
 gql_directive_get(const char *name) {
-    gqlDir	dir = directives;
+    gqlDir	dir = gql_directives;
 
     for (; NULL != dir; dir = dir->next) {
 	if (0 == strcmp(name, dir->name)) {
@@ -203,10 +312,9 @@ gql_type_set(agooErr err, gqlType type) {
 		return AGOO_ERR_OK;
 	    }
 	}
-	if (NULL == (s = (Slot)malloc(sizeof(struct _slot)))) {
-	    return agoo_err_set(err, AGOO_ERR_MEMORY, "Failed to allocation memory for a GraphQL 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.");
 	}
-	DEBUG_ALLOC(mem_graphql_slot, s);
 	s->hash = h;
 	s->type = type;
 	s->next = *bucket;
@@ -231,8 +339,7 @@ type_remove(gqlType type) {
 		} else {
 		    prev->next = s->next;
 		}
-		DEBUG_FREE(mem_graphql_slot, s);
-		free(s);
+		AGOO_FREE(s);
 
 		break;
 	    }
@@ -243,24 +350,32 @@ type_remove(gqlType type) {
 
 int
 gql_init(agooErr err) {
-    memset(buckets, 0, sizeof(buckets));
+    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.", -1, false, NULL)) ||
-	NULL == (mutation_type = gql_type_create(err, "Mutation", "The GraphQL root Mutation.", -1, false, NULL)) ||
-	NULL == (subscription_type = gql_type_create(err, "Subscription", "The GraphQL root Subscription.", -1, false, NULL)) ||
-	NULL == (schema_type = gql_type_create(err, "schema", "The GraphQL root Object.", -1, false, NULL)) ||
-	NULL == gql_type_field(err, schema_type, "query", query_type, "Root level query.", false, false, false, NULL) ||
-	NULL == gql_type_field(err, schema_type, "mutation", mutation_type, "Root level mutation.", false, false, false, NULL) ||
-	NULL == gql_type_field(err, schema_type, "subscription", subscription_type, "Root level subscription.", false, false, false, NULL)) {
+    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;
 }
 
@@ -271,63 +386,69 @@ gql_destroy() {
     Slot	n;
     int		i;
     gqlDir	dir;
-    
-    for (i = BUCKET_SIZE; 0 < i; i--, sp++) {
-	Slot	*b = sp;
 
+    for (i = BUCKET_SIZE; 0 < i; i--, sp++) {
+	s = *sp;
+	
 	*sp = NULL;
-	for (s = *b; NULL != s; s = n) {
+	for (; NULL != s; s = n) {
 	    n = s->next;
-	    DEBUG_FREE(mem_graphql_slot, s);
-	    gql_type_destroy(s->type);
-	    free(s);
+	    type_destroy(s->type);
+	    AGOO_FREE(s);
 	}
-	*sp = NULL;
     }
-    while (NULL != (dir = directives)) {
-	directives = dir->next;
+    while (NULL != (dir = gql_directives)) {
+	gql_directives = dir->next;
 	dir_destroy(dir);
     }
+    inited = false;
 }
 
 static gqlType
-type_create(agooErr err, const char *name, const char *desc, int dlen, bool locked) {
-    gqlType	type = (gqlType)malloc(sizeof(struct _gqlType));
+type_create(agooErr err, gqlKind kind, const char *name, const char *desc, size_t dlen) {
+    gqlType	type = gql_type_get(name);
 
     if (NULL == type) {
-	agoo_err_set(err, AGOO_ERR_MEMORY, "Failed to allocation memory for a GraphQL Type.");
-    } else {
-	DEBUG_ALLOC(mem_graphql_type, type);
-	type->name = strdup(name);
-	if (NULL == desc) {
-	    type->desc = NULL;
-	} else {
-	    if (0 >= dlen) {
-		type->desc = strdup(desc);
-	    } else {
-		type->desc = strndup(desc, dlen);
-	    }
-	    if (NULL == type->desc) {
-		agoo_err_set(err, AGOO_ERR_MEMORY, "strdup or strndup of length %d failed.", dlen);
-		return NULL;
-	    }
+	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;
+	}
+	if (NULL == (type->name = AGOO_STRDUP(name))) {
+	    agoo_err_set(err, AGOO_ERR_MEMORY, "strdup of type name failed. %s:%d", __FILE__, __LINE__);
+	    return NULL;
+	}
+	if (NULL == (type->desc = alloc_string(err, desc, dlen)) && AGOO_ERR_OK != err->code) {
+	    return NULL;
 	}
-	type->locked = locked;
-	type->core = false;
 	type->dir = NULL;
+	type->kind = kind;
+	type->scalar_kind = GQL_SCALAR_UNDEF;
+	type->core = false;
 
 	if (AGOO_ERR_OK != gql_type_set(err, type)) {
 	    gql_type_destroy(type);
 	    type = NULL;
 	}
+    } else if (GQL_UNDEF == type->kind) {
+	if (NULL == (type->desc = alloc_string(err, desc, dlen)) && AGOO_ERR_OK != err->code) {
+	    return NULL;
+	}
+	type->kind = kind;
+    } else if (type->core) {
+	agoo_err_set(err, AGOO_ERR_LOCK, "%d 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);
+    } else {
+	agoo_err_set(err, AGOO_ERR_LOCK, "%d already exists as a %s.", name, kind_string(type->kind));
+	return NULL;
     }
     return type;
 }
 
-agooText
-gql_object_to_json(agooText text, gqlValue value, int indent, int depth) {
-    // TBD
-    return text;
+static gqlType
+type_undef_create(agooErr err, const char *name) {
+    return type_create(err, GQL_UNDEF, name, NULL, 0);
 }
 
 agooText
@@ -337,70 +458,76 @@ gql_object_to_graphql(agooText text, gqlValue value, int indent, int depth) {
 }
 
 gqlType
-gql_type_create(agooErr err, const char *name, const char *desc, int dlen, bool locked, gqlType *interfaces) {
-    gqlType	type = type_create(err, name, desc, dlen, locked);
-
-    if (NULL != type) {
-	type->kind = GQL_OBJECT;
-	type->to_json = gql_object_to_json;
-	type->fields = NULL;
-	type->interfaces = NULL;
-	if (NULL != interfaces) {
-	    gqlType	*tp = interfaces;
-	    gqlType	*np;
-	    int		cnt = 0;
+gql_assure_type(agooErr err, const char *name) {
+    gqlType	type = NULL;
+    
+    if (NULL != name) {
+	type = gql_type_get(name);
 
-	    for (; NULL != *tp; tp++) {
-		cnt++;
-	    }
-	    if (0 < cnt) {
-		if (NULL == (type->interfaces = (gqlType*)malloc(sizeof(gqlType) * (cnt + 1)))) {
-		    agoo_err_set(err, AGOO_ERR_MEMORY, "Failed to allocation memory for a GraphQL type interfaces.");
-		    free(type);
-		    return NULL;
-		}
-		for (np = type->interfaces, tp = interfaces; NULL != *tp; np++, tp++) {
-		    *np = *tp;
-		}
-		*np = NULL;
+	if (NULL == type) {
+	    if (NULL == (type = type_undef_create(err, name))) {
+		return NULL;
 	    }
 	}
     }
     return type;
 }
 
+static gqlDir
+assure_directive(agooErr err, const char *name) {
+    gqlDir	dir = gql_directive_get(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;
+	}
+	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;
+}
+
+gqlType
+gql_type_create(agooErr err, const char *name, const char *desc, size_t dlen, gqlTypeLink interfaces) {
+    gqlType	type = type_create(err, GQL_OBJECT, name, desc, dlen);
+
+    if (NULL != type) {
+	type->fields = NULL;
+	type->interfaces = interfaces;
+    }
+    return type;
+}
+
 gqlField
-gql_type_field(agooErr err,
-	       gqlType type,
-	       const char *name,
-	       gqlType return_type,
-	       const char *desc,
-	       bool required,
-	       bool list,
-	       bool not_empty,
-	       gqlResolveFunc resolve) {
-    gqlField	f = (gqlField)malloc(sizeof(struct _gqlField));
+gql_type_field(agooErr		err,
+	       gqlType		type,
+	       const char	*name,
+	       gqlType		return_type,
+	       gqlValue		default_value,
+	       const char	*desc,
+	       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 allocation memory for a GraphQL field.");
+	agoo_err_set(err, AGOO_ERR_MEMORY, "Failed to allocate memory for a GraphQL field.");
     } else {
-	DEBUG_ALLOC(mem_graphql_field, f);
 	f->next = NULL;
-	f->name = strdup(name);
+	f->name = AGOO_STRDUP(name);
 	f->type = return_type;
-	if (NULL == desc) {
-	    f->desc = NULL;
-	} else {
-	    f->desc = strdup(desc);
+	if (NULL == (f->desc = alloc_string(err, desc, dlen)) && AGOO_ERR_OK != err->code) {
+	    return NULL;
 	}
-	f->reason = NULL;
 	f->args = NULL;
 	f->dir = NULL;
-	f->resolve = resolve;
+	f->default_value = default_value;
 	f->required = required;
-	f->list = list;
-	f->not_empty = not_empty;
-	f->deprecated = false;
 	if (NULL == type->fields) {
 	    type->fields = f;
 	} else {
@@ -420,21 +547,19 @@ gql_field_arg(agooErr		err,
 	      const char	*name,
 	      gqlType		type,
 	      const char	*desc,
+	      size_t		dlen,
 	      struct _gqlValue	*def_value,
 	      bool		required) {
-    gqlArg	a = (gqlArg)malloc(sizeof(struct _gqlArg));
+    gqlArg	a = (gqlArg)AGOO_MALLOC(sizeof(struct _gqlArg));
     
     if (NULL == a) {
-	agoo_err_set(err, AGOO_ERR_MEMORY, "Failed to allocation memory for a GraphQL field argument.");
+	agoo_err_set(err, AGOO_ERR_MEMORY, "Failed to allocate memory for a GraphQL field argument.");
     } else {
-	DEBUG_ALLOC(mem_graphql_arg, a);
 	a->next = NULL;
-	a->name = strdup(name);
+	a->name = AGOO_STRDUP(name);
 	a->type = type;
-	if (NULL == desc) {
-	    a->desc = NULL;
-	} else {
-	    a->desc = strdup(desc);
+	if (NULL == (a->desc = alloc_string(err, desc, dlen)) && AGOO_ERR_OK != err->code) {
+	    return NULL;
 	}
 	a->default_value = def_value;
 	a->dir = NULL;
@@ -452,37 +577,24 @@ gql_field_arg(agooErr		err,
     return a;
 }
 
-agooText
-gql_union_to_json(agooText text, gqlValue value, int indent, int depth) {
-    // TBD
-    return text;
-}
-
 gqlType
-gql_union_create(agooErr err, const char *name, const char *desc, int dlen, bool locked) {
-    gqlType	type = type_create(err, name, desc, dlen, locked);
+gql_union_create(agooErr err, const char *name, const char *desc, size_t dlen) {
+    gqlType	type = type_create(err, GQL_UNION, name, desc, dlen);
 
     if (NULL != type) {
-	type->kind = GQL_UNION;
-	type->to_json = gql_union_to_json;
 	type->types = NULL;
     }
     return type;
 }
 
 int
-gql_union_add(agooErr err, gqlType type, const char *name, int len) {
-    gqlTypeLink	link = (gqlTypeLink)malloc(sizeof(gqlTypeLink));
+gql_union_add(agooErr err, gqlType type, gqlType member) {
+    gqlTypeLink	link = (gqlTypeLink)AGOO_MALLOC(sizeof(struct _gqlTypeLink));
 
     if (NULL == link) {
-	agoo_err_set(err, AGOO_ERR_MEMORY, "Failed to allocation memory for a GraphQL Union value.");
-    }
-    if (0 >= len) {
-	len = (int)strlen(name);
-    }
-    if (NULL == (link->name = strndup(name, len))) {
-	return agoo_err_set(err, AGOO_ERR_MEMORY, "strndup of length %d failed.", len);
+	return agoo_err_set(err, AGOO_ERR_MEMORY, "Failed to allocate memory for a GraphQL Union value.");
     }
+    link->type = member;
     if (NULL == type->types) {
 	link->next = type->types;
 	type->types = link;
@@ -497,175 +609,122 @@ gql_union_add(agooErr err, gqlType type, const char *name, int len) {
     return AGOO_ERR_OK;
 }
 
-agooText
-gql_enum_to_json(agooText text, gqlValue value, int indent, int depth) {
-    // TBD
-    return text;
-}
-
 gqlType
-gql_enum_create(agooErr err, const char *name, const char *desc, int dlen, bool locked) {
-    gqlType	type = type_create(err, name, desc, dlen, locked);
+gql_enum_create(agooErr err, const char *name, const char *desc, size_t dlen) {
+    gqlType	type = type_create(err, GQL_ENUM, name, desc, dlen);
 
     if (NULL != type) {
-	type->kind = GQL_ENUM;
-	type->to_json = gql_enum_to_json;
 	type->choices = NULL;
     }
     return type;
 }
 
-int
-gql_enum_add(agooErr err, gqlType type, const char *value, int len) {
-    gqlStrLink	link = (gqlStrLink)malloc(sizeof(gqlStrLink));
+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));
 
-    if (NULL == link) {
-	agoo_err_set(err, AGOO_ERR_MEMORY, "Failed to allocation memory for a GraphQL Enum value.");
+    if (NULL == ev) {
+	agoo_err_set(err, AGOO_ERR_MEMORY, "Failed to allocate memory for a GraphQL Enum value.");
+	return NULL;
     }
     if (0 >= len) {
-	len = (int)strlen(value);
-    }
-    link->next = type->choices;
-    type->choices = link;
-    if (NULL == (link->str = strndup(value, len))) {
-	return agoo_err_set(err, AGOO_ERR_MEMORY, "strdup or strndup of length %d failed.", len);
-    }
-    return AGOO_ERR_OK;
-}
-
-int
-gql_enum_append(agooErr err, gqlType type, const char *value, int len) {
-    gqlStrLink	link = (gqlStrLink)malloc(sizeof(gqlStrLink));
-
-    if (NULL == link) {
-	agoo_err_set(err, AGOO_ERR_MEMORY, "Failed to allocation memory for a GraphQL Enum value.");
+	len = strlen(value);
     }
-    if (0 >= len) {
-	len = (int)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__);
+	return NULL;
     }
-    if (NULL == (link->str = strndup(value, len))) {
-	return agoo_err_set(err, AGOO_ERR_MEMORY, "strdup or strndup of length %d failed.", len);
+    ev->dir = NULL;
+    if (NULL == (ev->desc = alloc_string(err, desc, dlen)) && AGOO_ERR_OK != err->code) {
+	return NULL;
     }
     if (NULL == type->choices) {
-	link->next = type->choices;
-	type->choices = link;
+	ev->next = type->choices;
+	type->choices = ev;
     } else {
-	gqlStrLink	last = type->choices;
+	gqlEnumVal	last = type->choices;
 
 	for (; NULL != last->next; last = last->next) {
 	}
-	link->next = NULL;
-	last->next = link;
-    }
-    return AGOO_ERR_OK;
-}
-
-static agooText
-fragment_to_json(agooText text, gqlValue value, int indent, int depth) {
-    // TBD
-    return text;
-}
-
-gqlType
-gql_fragment_create(agooErr err, const char *name, const char *desc, int dlen, bool locked, gqlType on) {
-    gqlType	type = type_create(err, name, desc, dlen, locked);
-
-    if (NULL != type) {
-	type->kind = GQL_FRAG;
-	type->to_json = fragment_to_json;
-	type->fields = NULL;
-	type->on = on;
+	ev->next = NULL;
+	last->next = ev;
     }
-    return type;
-}
-
-static agooText
-input_to_json(agooText text, gqlValue value, int indent, int depth) {
-    // TBD
-    return text;
+    return ev;
 }
 
 gqlType
-gql_input_create(agooErr err, const char *name, const char *desc, int dlen, bool locked) {
-    gqlType	type = type_create(err, name, desc, dlen, locked);
+gql_input_create(agooErr err, const char *name, const char *desc, size_t dlen) {
+    gqlType	type = type_create(err, GQL_INPUT, name, desc, dlen);
 
     if (NULL != type) {
-	type->kind = GQL_INPUT;
-	type->to_json = input_to_json;
-	type->fields = NULL;
+	type->args = NULL;
     }
     return type;
 }
 
-static agooText
-interface_to_json(agooText text, gqlValue value, int indent, int depth) {
-    // TBD
-    return text;
-}
-
 gqlType
-gql_interface_create(agooErr err, const char *name, const char *desc, int dlen, bool locked) {
-    gqlType	type = type_create(err, name, desc, dlen, locked);
+gql_interface_create(agooErr err, const char *name, const char *desc, size_t dlen) {
+    gqlType	type = type_create(err, GQL_INTERFACE, name, desc, dlen);
 
     if (NULL != type) {
-	type->kind = GQL_INTERFACE;
-	type->to_json = interface_to_json;
 	type->fields = NULL;
+	type->interfaces = NULL;
     }
     return type;
 }
 
+// TBD this is not correct. Is it used?
 static agooText
-scalar_to_json(agooText text, gqlValue value, int indent, int depth) {
-    if (NULL == value->str) {
-	text = agoo_text_append(text, "null", 4);
-    } else {
-	text = agoo_text_append(text, "\"", 1);
-	text = agoo_text_append(text, value->str, -1);
-	text = agoo_text_append(text, "\"", 1);
-    }
+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, int dlen, bool locked) {
-    gqlType	type = type_create(err, name, desc, dlen, locked);
+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->kind = GQL_SCALAR;
-	type->to_json = scalar_to_json;
-	type->coerce = NULL;
+	type->to_json = scalar_to_text;
+	type->to_sdl = scalar_to_text;
 	type->destroy = NULL;
     }
     return type;
 }
 
 gqlDir
-gql_directive_create(agooErr err, const char *name, const char *desc, int dlen, bool locked) {
-    gqlDir	dir;
-    
-    if (NULL == (dir = (gqlDir)malloc(sizeof(struct _gqlDir)))) {
-	agoo_err_set(err, AGOO_ERR_MEMORY, "Failed to allocation memory for a GraphQL directive.");
-	return NULL;
-    }
-    DEBUG_ALLOC(mem_graphql_directive, dir);
-    dir->next = directives;
-    directives = dir;
-    dir->name = strdup(name);
-    dir->args = NULL;
-    dir->locs = NULL;
-    dir->locked = locked;
-    if (NULL == desc) {
-	dir->desc = NULL;
-    } else {
-	if (0 >= dlen) {
-	    dir->desc = strdup(desc);
+gql_directive_create(agooErr err, const char *name, const char *desc, size_t dlen) {
+    gqlDir	dir = gql_directive_get(name);
+
+    if (NULL != dir) {
+	if (!dir->defined) {
+	    dir->defined = true;
+	    if (NULL == (dir->desc = alloc_string(err, desc, dlen)) && AGOO_ERR_OK != err->code) {
+		return NULL;
+	    }
 	} else {
-	    dir->desc = strndup(desc, dlen);
+	    dir_clean(dir);
+	    dir->args = NULL;
+	    dir->locs = NULL;
+	    dir->defined = true;
+	    if (NULL == (dir->desc = alloc_string(err, desc, dlen)) && AGOO_ERR_OK != err->code) {
+		return NULL;
+	    }
 	}
-	if (NULL == dir->desc) {
-	    agoo_err_set(err, AGOO_ERR_MEMORY, "strdup or strndup of length %d failed.", dlen);
+    } 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.");
+	    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) {
 	    return NULL;
 	}
     }
@@ -676,31 +735,21 @@ gqlArg
 gql_dir_arg(agooErr 		err,
 	    gqlDir 		dir,
 	    const char 		*name,
-	    const char 		*type_name,
+	    gqlType		type,
 	    const char	 	*desc,
-	    int			dlen,
+	    size_t		dlen,
 	    struct _gqlValue	*def_value,
 	    bool 		required) {
 
-    gqlArg	a = (gqlArg)malloc(sizeof(struct _gqlArg));
+    gqlArg	a = (gqlArg)AGOO_MALLOC(sizeof(struct _gqlArg));
     
     if (NULL == a) {
-	agoo_err_set(err, AGOO_ERR_MEMORY, "Failed to allocation memory for a GraphQL directive argument.");
+	agoo_err_set(err, AGOO_ERR_MEMORY, "Failed to allocate memory for a GraphQL directive argument.");
     } else {
-	DEBUG_ALLOC(mem_graphql_arg, a);
 	a->next = NULL;
-	a->name = strdup(name);
-	a->type_name = strdup(type_name);
-	a->type = NULL;
-	if (NULL == desc) {
-	    a->desc = NULL;
-	} else if (0 < dlen) {
-	    a->desc = strdup(desc);
-	} else {
-	    a->desc = strndup(desc, dlen);
-	}
-	if (NULL == a->desc) {
-	    agoo_err_set(err, AGOO_ERR_MEMORY, "strdup or strndup of length %d failed.", dlen);
+	a->name = AGOO_STRDUP(name);
+	a->type = type;
+	if (NULL == (a->desc = alloc_string(err, desc, dlen)) && AGOO_ERR_OK != err->code) {
 	    return NULL;
 	}
 	a->default_value = def_value;
@@ -721,11 +770,11 @@ gql_dir_arg(agooErr 		err,
 
 int
 gql_directive_on(agooErr err, gqlDir d, const char *on, int len) {
-    gqlStrLink	link = (gqlStrLink)malloc(sizeof(gqlStrLink));
+    gqlStrLink	link = (gqlStrLink)AGOO_MALLOC(sizeof(struct _gqlStrLink));
     gqlStrLink	loc;
 
     if (NULL == link) {
-	agoo_err_set(err, AGOO_ERR_MEMORY, "Failed to allocation memory for a GraphQL directive location.");
+	agoo_err_set(err, AGOO_ERR_MEMORY, "Failed to allocate memory for a GraphQL directive location.");
     }
     if (0 >= len) {
 	len = (int)strlen(on);
@@ -739,12 +788,31 @@ gql_directive_on(agooErr err, gqlDir d, const char *on, int len) {
 	}
 	loc->next = link;
     }
-    if (NULL == (link->str = strndup(on, len))) {
-	return agoo_err_set(err, AGOO_ERR_MEMORY, "strdup or strndup of length %d failed.", len);
+    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_OK;
 }
 
+gqlType
+gql_assure_list(agooErr err, gqlType base, bool not_empty) {
+    char	name[256];
+    gqlType	type;
+
+    if ((int)sizeof(name) <= snprintf(name, sizeof(name), "[%s%s]", base->name, not_empty ? "!" : "")) {
+	agoo_err_set(err, AGOO_ERR_ARG, "Name too long");
+	return NULL;
+    }
+    if (NULL == (type = gql_type_get(name))) {
+	if (NULL == (type = type_create(err, GQL_LIST, name, NULL, 0))) {
+	    return NULL;
+	}
+	type->base = base;
+	type->not_empty = not_empty;
+    }
+    return type;
+}
+
 void
 gql_type_destroy(gqlType type) {
     type_destroy(type);
@@ -825,15 +893,14 @@ arg_sdl(agooText text, gqlArg a, bool with_desc, bool last) {
 	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, "!: ", 3);
-    } else {
-	text = agoo_text_append(text, ": ", 2);
+	text = agoo_text_append(text, "!", 1);
     }
-    text = agoo_text_append(text, a->type_name, -1);
     if (NULL != a->default_value) {
 	text = agoo_text_append(text, " = ", 3);
-	text = gql_value_json(text, a->default_value, 0, 0);
+	text = gql_value_sdl(text, a->default_value, 0, 0);
     }
     if (!last) {
 	text = agoo_text_append(text, ", ", 2);
@@ -841,6 +908,26 @@ arg_sdl(agooText text, gqlArg a, bool with_desc, bool last) {
     return text;
 }
 
+static agooText
+append_dir_use(agooText text, gqlDirUse use) {
+    for (; NULL != use; use = use->next) {
+	text = agoo_text_append(text, " @", 2);
+	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);
+	}
+    }
+    return text;
+}
+
 static agooText
 field_sdl(agooText text, gqlField f, bool with_desc) {
     if (with_desc) {
@@ -858,19 +945,15 @@ field_sdl(agooText text, gqlField f, bool with_desc) {
 	text = agoo_text_append(text, ")", 1);
     }
     text = agoo_text_append(text, ": ", 2);
-    if (f->list) {
-	text = agoo_text_append(text, "[", 1);
-	text = agoo_text_append(text, f->type->name, -1);
-	if (f->not_empty) {
-	    text = agoo_text_append(text, "!", 1);
-	}
-	text = agoo_text_append(text, "]", 1);
-    } else {
-	text = agoo_text_append(text, f->type->name, -1);
-    }
+    text = agoo_text_append(text, f->type->name, -1);
     if (f->required) {
 	text = agoo_text_append(text, "!", 1);
     }
+    if (NULL != f->default_value) {
+	text = agoo_text_append(text, " = ", 3);
+	text = gql_value_sdl(text, f->default_value, 0, 0);
+    }
+    text = append_dir_use(text, f->dir);
     text = agoo_text_append(text, "\n", 1);
 
     return text;
@@ -889,16 +972,17 @@ gql_type_sdl(agooText text, gqlType type, bool with_desc) {
 	text = agoo_text_append(text, "type ", 5);
 	text = agoo_text_append(text, type->name, -1);
 	if (NULL != type->interfaces) {
-	    gqlType	*tp = type->interfaces;
+	    gqlTypeLink	tp = type->interfaces;
 
 	    text = agoo_text_append(text, " implements ", 12);
-	    for (; NULL != *tp; tp++) {
-		text = agoo_text_append(text, (*tp)->name, -1);
-		if (NULL != *(tp + 1)) {
-		    text = agoo_text_append(text, ", ", 2);
+	    for (; NULL != tp; tp = tp->next) {
+		text = agoo_text_append(text, tp->type->name, -1);
+		if (NULL != tp->next) {
+		    text = agoo_text_append(text, " & ", 3);
 		}
 	    }
 	}
+	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);
@@ -911,9 +995,10 @@ gql_type_sdl(agooText text, gqlType type, bool with_desc) {
 
 	text = agoo_text_append(text, "union ", 6);
 	text = agoo_text_append(text, type->name, -1);
+	text = append_dir_use(text, type->dir);
 	text = agoo_text_append(text, " = ", 3);
 	for (link = type->types; NULL != link; link = link->next) {
-	    text = agoo_text_append(text, link->name, -1);
+	    text = agoo_text_append(text, link->type->name, -1);
 	    if (NULL != link->next) {
 		text = agoo_text_append(text, " | ", 3);
 	    }
@@ -921,14 +1006,19 @@ gql_type_sdl(agooText text, gqlType type, bool with_desc) {
 	break;
     }
     case GQL_ENUM: {
-	gqlStrLink	link;;
+	gqlEnumVal	ev;
 	
 	text = agoo_text_append(text, "enum ", 5);
 	text = agoo_text_append(text, type->name, -1);
+	text = append_dir_use(text, type->dir);
 	text = agoo_text_append(text, " {\n", 3);
-	for (link = type->choices; NULL != link; link = link->next) {
+	for (ev = type->choices; NULL != ev; ev = ev->next) {
 	    text = agoo_text_append(text, "  ", 2);
-	    text = agoo_text_append(text, link->str, -1);
+	    if (with_desc) {
+		text = desc_sdl(text, ev->desc, 2);
+	    }
+	    text = agoo_text_append(text, ev->value, -1);
+	    text = append_dir_use(text, ev->dir);
 	    text = agoo_text_append(text, "\n", 1);
 	}
 	text = agoo_text_append(text, "}\n", 2);
@@ -937,6 +1027,7 @@ gql_type_sdl(agooText text, gqlType type, bool with_desc) {
     case GQL_SCALAR:
 	text = agoo_text_append(text, "scalar ", 7);
 	text = agoo_text_append(text, type->name, -1);
+	text = append_dir_use(text, type->dir);
 	text = agoo_text_append(text, "\n", 1);
 	break;
     case GQL_INTERFACE: {
@@ -944,6 +1035,7 @@ gql_type_sdl(agooText text, gqlType type, bool with_desc) {
 
 	text = agoo_text_append(text, "interface ", 10);
 	text = agoo_text_append(text, type->name, -1);
+	text = append_dir_use(text, type->dir);
 	text = agoo_text_append(text, " {\n", 3);
 
 	for (f = type->fields; NULL != f; f = f->next) {
@@ -953,13 +1045,14 @@ gql_type_sdl(agooText text, gqlType type, bool with_desc) {
 	break;
     }
     case GQL_INPUT: {
-	gqlField	f;
+	gqlArg	a;
 
 	text = agoo_text_append(text, "input ", 6);
 	text = agoo_text_append(text, type->name, -1);
+	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);
+	for (a = type->args; NULL != a; a = a->next) {
+	    text = arg_sdl(text, a, with_desc, NULL == a->next);
 	}
 	text = agoo_text_append(text, "}\n", 2);
 	break;
@@ -1027,6 +1120,9 @@ gql_schema_sdl(agooText text, bool with_desc, bool all) {
     for (bucket = buckets, i = 0; i < BUCKET_SIZE; bucket++, i++) {
 	for (s = *bucket; NULL != s; s = s->next) {
 	    type = s->type;
+	    if (GQL_LIST == type->kind) {
+		continue;
+	    }
 	    if (!all && type->core) {
 		continue;
 	    }
@@ -1040,6 +1136,9 @@ gql_schema_sdl(agooText text, bool with_desc, bool all) {
 	for (bucket = buckets, i = 0; i < BUCKET_SIZE; bucket++, i++) {
 	    for (s = *bucket; NULL != s; s = s->next) {
 		type = s->type;
+		if (GQL_LIST == type->kind) {
+		    continue;
+		}
 		if (!all && type->core) {
 		    continue;
 		}
@@ -1054,7 +1153,10 @@ gql_schema_sdl(agooText text, bool with_desc, bool all) {
 	    }
 	}
     }
-    for (d = directives; NULL != d; d = d->next) {
+    for (d = gql_directives; NULL != d; d = d->next) {
+	if (!all && d->core) {
+	    continue;
+	}
 	text = agoo_text_append(text, "\n", 1);
 	text = gql_directive_sdl(text, d, with_desc);
 	text = agoo_text_append(text, "\n", 1);
@@ -1062,6 +1164,362 @@ gql_schema_sdl(agooText text, bool with_desc, bool all) {
     return text;
 }
 
+gqlDirUse
+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.");
+    } else {
+	if (NULL == (use->dir = assure_directive(err, name))) {
+	    return NULL;
+	}
+	use->next = NULL;
+	use->args = NULL;
+    }
+    return use;
+}
+
+int
+gql_dir_use_arg(agooErr err, gqlDirUse use, const char *key, gqlValue value) {
+    gqlLink	link = gql_link_create(err, key, value);
+
+    if (NULL == link) {
+	return err->code;
+    }
+    link->next = use->args;
+    use->args = link;
+    
+    return AGOO_ERR_OK;
+}
+
+void
+gql_type_directive_use(gqlType type, gqlDirUse use) {
+    if (NULL == type->dir) {
+	type->dir = use;
+    } else {
+	gqlDirUse	u = type->dir;
+
+	for (; NULL != u->next; u = u->next) {
+	}
+	u->next = 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__);
+    } 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__);
+		return NULL;
+	    }
+	} else {
+	    frag->name = NULL;
+	}
+	frag->dir = NULL;
+	frag->on = on;
+	frag->sels = NULL;
+    }
+    return frag;
+}
+
+int
+gql_validate(agooErr err) {
+
+    // TBD
+    // list members all the same or attempt to coerce
+    // check all validation rules in doc that are not covered in the parsing
+    // check the directive us in specified locations only
+    // set types if they are not already set or error out
+
+    return AGOO_ERR_OK;
+}
+
+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__);
+    } else {
+	doc->ops = NULL;
+	doc->vars = NULL;
+	doc->frags = NULL;
+    }
+    return doc;
+}
+
+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__);
+    } 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__);
+		return NULL;
+	    }
+	} else {
+	    op->name = NULL;
+	}
+	op->vars = NULL;
+	op->dir = NULL;
+	op->sels = NULL;
+	op->kind = kind;
+    }
+    return op;
+}
+
+static void
+var_destroy(gqlVar var) {
+    AGOO_FREE((char*)var->name);
+    if (NULL != var->value) {
+	gql_value_destroy(var->value);
+    }
+    AGOO_FREE(var);
+}
+
+static void
+sel_arg_destroy(gqlSelArg arg) {
+    AGOO_FREE((char*)arg->name);
+    if (NULL != arg->value) {
+	gql_value_destroy(arg->value);
+    }
+    AGOO_FREE(arg);
+}
+
+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)) {
+	sel->args = arg->next;
+	sel_arg_destroy(arg);
+    }
+    free_dir_uses(sel->dir);
+    while (NULL != (s = sel->sels)) {
+	sel->sels = s->next;
+	sel_destroy(s);
+    }
+    AGOO_FREE((char*)sel->frag);
+    if (NULL != sel->inline_frag) {
+	gql_frag_destroy(sel->inline_frag);
+    }
+    AGOO_FREE(sel);
+}
+
+void
+gql_op_destroy(gqlOp op) {
+    gqlSel	sel;
+    gqlVar	var;
+
+    AGOO_FREE((char*)op->name);
+    while (NULL != (var = op->vars)) {
+	op->vars = var->next;
+	var_destroy(var);
+    }
+    free_dir_uses(op->dir);
+    while (NULL != (sel = op->sels)) {
+	op->sels = sel->next;
+	sel_destroy(sel);
+    }
+    AGOO_FREE(op);
+}
+
+void
+gql_frag_destroy(gqlFrag frag) {
+    gqlSel	sel;
+
+    AGOO_FREE((char*)frag->name);
+    free_dir_uses(frag->dir);
+    while (NULL != (sel = frag->sels)) {
+	frag->sels = sel->next;
+	sel_destroy(sel);
+    }
+    AGOO_FREE(frag);
+}
+
+void
+gql_doc_destroy(gqlDoc doc) {
+    gqlOp	op;
+    gqlFrag	frag;
+    gqlVar	var;
+    
+    while (NULL != (op = doc->ops)) {
+	doc->ops = op->next;
+	gql_op_destroy(op);
+    }
+    while (NULL != (var = doc->vars)) {
+	doc->vars = var->next;
+	var_destroy(var);
+    }
+    while (NULL != (frag = doc->frags)) {
+	doc->frags = frag->next;
+	gql_frag_destroy(frag);
+    }
+    AGOO_FREE(doc);
+}
+
+static agooText
+sel_sdl(agooText text, gqlSel sel, int depth) {
+    int	indent = depth * 2;
+
+    if ((int)sizeof(spaces) <= indent) {
+	indent = sizeof(spaces) - 1;
+    }
+    text = agoo_text_append(text, spaces, indent);
+    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);
+    } else if (NULL != sel->inline_frag) {
+	if (NULL == sel->inline_frag->on) {
+	    text = agoo_text_append(text, "...", 3);
+	} else {
+	    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);
+	if (NULL != sel->inline_frag->sels) {
+	    gqlSel	s;
+	    int		d2 = depth + 1;
+
+	    text = agoo_text_append(text, " {\n", 3);
+	    for (s = sel->inline_frag->sels; NULL != s; s = s->next) {
+		text = sel_sdl(text, s, d2);
+	    }
+	    text = agoo_text_append(text, spaces, indent);
+	    text = agoo_text_append(text, "}", 1);
+	}
+    } else {
+	if (NULL != sel->alias) {
+	    text = agoo_text_append(text, sel->alias, -1);
+	    text = agoo_text_append(text, ": ", 2);
+	}
+	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);
+		text = agoo_text_append(text, ": ", 2);
+		if (NULL != arg->var) {
+		    text = agoo_text_append(text, "$", 1);
+		    text = agoo_text_append(text, arg->var->name, -1);
+		} else if (NULL != arg->value) {
+		    text = gql_value_sdl(text, arg->value, 0, 0);
+		} else {
+		    text = agoo_text_append(text, "null", 4);
+		}
+		if (NULL != arg->next) {
+		    text = agoo_text_append(text, ", ", 2);
+		}
+	    }
+	    text = agoo_text_append(text, ")", 1);
+	}
+	text = append_dir_use(text, sel->dir);
+	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);
+	    }
+	    text = agoo_text_append(text, spaces, indent);
+	    text = agoo_text_append(text, "}", 1);
+	}
+    }
+    text = agoo_text_append(text, "\n", 1);
+
+    return text;
+}
+
+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);
+	text = agoo_text_append(text, op->name, -1);
+    }
+    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);
+	    text = agoo_text_append(text, var->name, -1);
+	    text = agoo_text_append(text, ": ", 2);
+
+	    text = agoo_text_append(text, var->type->name, -1);
+	    if (NULL != var->value) {
+		text = agoo_text_append(text, " = ", 3);
+		text = gql_value_sdl(text, var->value, 0, 0);
+	    }
+	    if (NULL != var->next) {
+		text = agoo_text_append(text, ", ", 2);
+	    }
+	}
+	text = agoo_text_append(text, ")", 1);
+    }
+    text = append_dir_use(text, op->dir);
+
+    text = agoo_text_append(text, " {\n", 3);
+    for (sel = op->sels; NULL != sel; sel = sel->next) {
+	text = sel_sdl(text, sel, 1);
+    }
+    text = agoo_text_append(text, "}\n", 2);
+
+    return text;
+}
+
+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);
+    text = agoo_text_append(text, frag->on->name, -1);
+    text = append_dir_use(text, frag->dir);
+    text = agoo_text_append(text, " {\n", 3);
+    for (sel = frag->sels; NULL != sel; sel = sel->next) {
+	text = sel_sdl(text, sel, 1);
+    }
+    text = agoo_text_append(text, "}\n", 2);
+
+    return text;
+}
+
+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);
+    }
+    for (frag = doc->frags; NULL != frag; frag = frag->next) {
+	text = frag_sdl(text, frag);
+    }
+    return text;
+}
+
 void
 gql_dump_hook(agooReq req) {
     char	buf[256];
@@ -1086,11 +1544,32 @@ gql_dump_hook(agooReq req) {
     agoo_res_set_message(req->res, text);
 }
 
-void
-gql_eval_hook(agooReq req) {
-    // TBD detect introspection
-    //  start resolving by callout to some global handler as needed
-    //   pass target, field, args
-    //   return json or gqlValue
-    // for handler, if introspection then handler here else global
+gqlField
+gql_type_get_field(gqlType type, const char *field) {
+    gqlField	f;
+
+    if (NULL == type) {
+	return NULL;
+    }
+    switch (type->kind) {
+    case GQL_OBJECT:
+    case GQL_INTERFACE:
+	for (f = type->fields; NULL != f; f = f->next) {
+	    if (0 == strcmp(field, f->name)) {
+		return f;
+	    }
+	}
+	break;
+    case GQL_UNION:
+	// TBD
+	break;
+    case GQL_LIST:
+	return gql_type_get_field(type->base, field);
+	break;
+    default:
+	// TBD
+	break;
+    }
+    return NULL;
 }
+