graphql#GraphQLEnumValueConfig TypeScript Examples
The following examples show how to use
graphql#GraphQLEnumValueConfig.
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example. You may check out the related API usage on the sidebar.
Example #1
| Source File: schema.ts From Deep-Lynx with MIT License | 5 votes |
|
// each key in the metatype should be included on the input object as a field to be filtered on
inputFieldsForMetatype(metatype: Metatype): {[key: string]: any} {
const fields: {[key: string]: any} = {};
metatype.keys?.forEach((metatypeKey) => {
const propertyName = stringToValidPropertyName(metatypeKey.property_name);
switch (metatypeKey.data_type) {
// because we have no specification on our internal number type, we
// must set this as a float for now
case 'number': {
fields[propertyName] = {
type: GraphQLFloat,
};
break;
}
case 'boolean': {
fields[propertyName] = {
type: GraphQLBoolean,
};
break;
}
case 'string' || 'date' || 'file': {
fields[propertyName] = {
type: GraphQLString,
};
break;
}
case 'list': {
fields[propertyName] = {
type: new GraphQLList(GraphQLJSON),
};
break;
}
case 'enumeration': {
const enumMap: {[key: string]: GraphQLEnumValueConfig} = {};
if (metatypeKey.options) {
metatypeKey.options.forEach((option) => {
enumMap[option] = {
value: option,
};
});
}
// we have to include a UUID here so that we can insure a uniquely named type
fields[propertyName] = {
type: new GraphQLEnumType({
name: stringToValidPropertyName(`${metatype.name}_${metatypeKey.name}_Enum_Type_B`),
values: enumMap,
}),
};
break;
}
default: {
fields[propertyName] = {
type: GraphQLString,
};
}
}
});
return fields;
}
Example #2
| Source File: schema.ts From Deep-Lynx with MIT License | 5 votes |
|
// each key in the relationship should be included on the input object as a field to be filtered on
inputFieldsForRelationship(relationship: MetatypeRelationship): {[key: string]: any} {
const fields: {[key: string]: any} = {};
relationship.keys?.forEach((relationshipKey) => {
const propertyName = stringToValidPropertyName(relationshipKey.property_name);
switch (relationshipKey.data_type) {
// because we have no specification on our internal number type, we
// must set this as a float for now
case 'number': {
fields[propertyName] = {
type: GraphQLFloat,
};
break;
}
case 'boolean': {
fields[propertyName] = {
type: GraphQLBoolean,
};
break;
}
case 'string' || 'date' || 'file': {
fields[propertyName] = {
type: GraphQLString,
};
break;
}
case 'list': {
fields[propertyName] = {
type: new GraphQLList(GraphQLJSON),
};
break;
}
case 'enumeration': {
const enumMap: {[key: string]: GraphQLEnumValueConfig} = {};
if (relationshipKey.options) {
relationshipKey.options.forEach((option) => {
enumMap[option] = {
value: option,
};
});
}
fields[propertyName] = {
type: new GraphQLEnumType({
name: stringToValidPropertyName(`${relationship.name}_${relationshipKey.name}_Enum_TypeB`),
values: enumMap,
}),
};
break;
}
default: {
fields[propertyName] = {
type: GraphQLString,
};
}
}
});
return fields;
}
Example #3
| Source File: schema.ts From Deep-Lynx with MIT License | 4 votes |
|
// generate requires a containerID because the schema it generates is based on a user's ontology and ontologies are
// separated by containers
async ForContainer(containerID: string, options: ResolverOptions): Promise<Result<GraphQLSchema>> {
// fetch the currently published ontology if the versionID wasn't provided
if (!options.ontologyVersionID) {
const ontResults = await this.#ontologyRepo
.where()
.containerID('eq', containerID)
.and()
.status('eq', 'published')
.list({sortBy: 'id', sortDesc: true});
if (ontResults.isError || ontResults.value.length === 0) {
Logger.error('unable to fetch current ontology, or no currently published ontology');
} else {
options.ontologyVersionID = ontResults.value[0].id;
}
}
// fetch all metatypes for the container, with their keys - the single most expensive call of this function
const metatypeResults = await this.#metatypeRepo
.where()
.containerID('eq', containerID)
.and()
.ontologyVersion('eq', options.ontologyVersionID)
.list(true);
if (metatypeResults.isError) {
return Promise.resolve(Result.Pass(metatypeResults));
}
// fetch all metatype relationship pairs - used for _relationship queries.
const metatypePairResults = await this.#metatypePairRepo
.where()
.containerID('eq', containerID)
.and()
.ontologyVersion('eq', options.ontologyVersionID)
.list();
if (metatypePairResults.isError) {
return Promise.resolve(Result.Pass(metatypePairResults));
}
// fetch all relationship types. Used for relationship wrapper queries.
const relationshipResults = await this.#relationshipRepo
.where()
.containerID('eq', containerID)
.and()
.ontologyVersion('eq', options.ontologyVersionID)
.list(true);
if (relationshipResults.isError) {
return Promise.resolve(Result.Pass(relationshipResults));
}
// used for querying edges based on node (see input._relationship resolver)
const metatypePairObjects: {[key: string]: any} = {};
metatypePairResults.value.forEach((pair) => {
const origin = stringToValidPropertyName(pair.origin_metatype_name!);
const rel = stringToValidPropertyName(pair.relationship_name!);
const dest = stringToValidPropertyName(pair.destination_metatype_name!);
// populate list for forward searching
if (!(origin in metatypePairObjects)) {
metatypePairObjects[origin] = {};
}
if (!(rel in metatypePairObjects[origin])) {
metatypePairObjects[origin][rel] = {};
}
if (!(dest in metatypePairObjects[origin][rel])) {
metatypePairObjects[origin][rel][dest] = {type: GraphQLString};
}
});
const metatypeGraphQLObjects: {[key: string]: any} = {};
// we must declare the metadata input object beforehand so we can include it in the final schema entry for each
// metatype
const recordInputType = new GraphQLInputObjectType({
name: 'record_input',
fields: {
id: {type: GraphQLString},
data_source_id: {type: GraphQLString},
original_id: {type: GraphQLJSON}, // since the original ID might be a number, treat it as valid JSON
import_id: {type: GraphQLString},
limit: {type: GraphQLInt, defaultValue: 10000},
page: {type: GraphQLInt, defaultValue: 1},
},
});
const recordInfo = new GraphQLObjectType({
name: 'recordInfo',
fields: {
id: {type: GraphQLString},
data_source_id: {type: GraphQLString},
original_id: {type: GraphQLJSON}, // since the original ID might be a number, treat it as valid JSON
import_id: {type: GraphQLString},
metatype_id: {type: GraphQLString},
metatype_name: {type: GraphQLString},
created_at: {type: GraphQLString},
created_by: {type: GraphQLString},
modified_at: {type: GraphQLString},
modified_by: {type: GraphQLString},
metadata: {type: GraphQLJSON},
count: {type: GraphQLInt},
page: {type: GraphQLInt},
},
});
// needed when a user decides they want the results as a file vs. a raw return
const fileInfo = new GraphQLObjectType({
name: 'fileInfo',
fields: {
id: {type: GraphQLString},
file_name: {type: GraphQLString},
file_size: {type: GraphQLFloat},
md5hash: {type: GraphQLString},
metadata: {type: GraphQLJSON},
url: {type: GraphQLString},
},
});
metatypeResults.value.forEach((metatype) => {
if (!metatype.keys || metatype.keys.length === 0) return;
// the following 4 input/object types are used for querying or introspection on _relationship
const destinationInputType = new GraphQLInputObjectType({
name: `${stringToValidPropertyName(metatype.name)}_destination_input`,
// needed because the return type accepts an object, but throws a fit about it
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
// @ts-ignore
fields: () => {
const fields: {[key: string]: {[key: string]: any}} = {};
if (metatypePairObjects[stringToValidPropertyName(metatype.name)]) {
Object.keys(metatypePairObjects[stringToValidPropertyName(metatype.name)]).forEach((pair) => {
Object.keys(metatypePairObjects[stringToValidPropertyName(metatype.name)][pair]).forEach((dest) => {
fields[dest] = {type: GraphQLBoolean};
});
});
}
return fields;
},
});
const relationshipInputType = new GraphQLInputObjectType({
name: `${stringToValidPropertyName(metatype.name)}_relationship_input`,
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
// @ts-ignore
fields: () => {
const fields: {[key: string]: {[key: string]: GraphQLNamedType | GraphQLList<any>}} = {};
if (metatypePairObjects[metatype.name]) {
Object.keys(metatypePairObjects[metatype.name]).forEach((rel) => {
fields[rel] = {type: new GraphQLList(destinationInputType)};
});
} else {
// if no relationships exists, set relationship to _none: true
fields._none = {type: GraphQLBoolean};
}
return fields;
},
});
const destinationInfo = new GraphQLObjectType({
name: `${stringToValidPropertyName(metatype.name)}_destinationInfo`,
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
// @ts-ignore
fields: () => {
const fields: {[key: string]: any} = {};
if (metatypePairObjects[metatype.name]) {
Object.keys(metatypePairObjects[metatype.name]).forEach((pair) => {
Object.keys(metatypePairObjects[metatype.name][pair]).forEach((dest) => {
fields[dest] = {type: GraphQLString};
});
});
}
return fields;
},
});
const relationshipInfo = new GraphQLObjectType({
name: `${stringToValidPropertyName(metatype.name)}_relationshipInfo`,
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
// @ts-ignore
fields: () => {
const fields: {[key: string]: any} = {};
if (metatypePairObjects[metatype.name]) {
Object.keys(metatypePairObjects[metatype.name]).forEach((pair) => {
fields[pair] = {type: destinationInfo};
});
} else {
// if no relationships exists, set relationship to _none: true
fields._none = {type: GraphQLBoolean};
}
return fields;
},
});
metatypeGraphQLObjects[stringToValidPropertyName(metatype.name)] = {
args: {
...this.inputFieldsForMetatype(metatype),
_record: {type: recordInputType},
_relationship: {type: relationshipInputType},
},
description: metatype.description,
type: options.returnFile
? fileInfo
: new GraphQLList(
new GraphQLObjectType({
name: stringToValidPropertyName(metatype.name),
// needed because the return type accepts an object, but throws a fit about it
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
// @ts-ignore
fields: () => {
const output: {[key: string]: {[key: string]: GraphQLNamedType | GraphQLList<any>}} = {};
output._record = {type: recordInfo};
output._relationship = {type: relationshipInfo};
output._file = {type: fileInfo};
metatype.keys?.forEach((metatypeKey) => {
// keys must match the regex format of /^[_a-zA-Z][_a-zA-Z0-9]*$/ in order to be considered
// valid graphql property names. While we force the user to meet these requirements at key
// creation, we can't guarantee that legacy data will conform to these standards
const propertyName = stringToValidPropertyName(metatypeKey.property_name);
switch (metatypeKey.data_type) {
// because we have no specification on our internal number type, we
// must set this as a float for now
case 'number': {
output[propertyName] = {
type: GraphQLFloat,
};
break;
}
case 'boolean': {
output[propertyName] = {
type: GraphQLBoolean,
};
break;
}
case 'string' || 'date' || 'file': {
output[propertyName] = {
type: GraphQLString,
};
break;
}
case 'list': {
output[propertyName] = {
type: new GraphQLList(GraphQLJSON),
};
break;
}
case 'enumeration': {
const enumMap: {[key: string]: GraphQLEnumValueConfig} = {};
if (metatypeKey.options) {
metatypeKey.options.forEach((option) => {
enumMap[option] = {
value: option,
};
});
}
output[propertyName] = {
type: new GraphQLEnumType({
name: stringToValidPropertyName(`${metatype.name}_${metatypeKey.name}_Enum_TypeA`),
values: enumMap,
}),
};
break;
}
default: {
output[propertyName] = {
type: GraphQLString,
};
}
}
});
return output;
},
}),
),
resolve: this.resolverForMetatype(containerID, metatype, options),
};
});
const relationshipGraphQLObjects: {[key: string]: any} = {};
// metadata objects for edges (metatype relationships)
const edgeRecordInputType = new GraphQLInputObjectType({
name: 'edge_record_input',
fields: {
id: {type: GraphQLString},
pair_id: {type: GraphQLString},
data_source_id: {type: GraphQLString},
import_id: {type: GraphQLString},
origin_id: {type: GraphQLString},
destination_id: {type: GraphQLString},
limit: {type: GraphQLInt, defaultValue: 10000},
page: {type: GraphQLInt, defaultValue: 1},
},
});
const edgeRecordInfo = new GraphQLObjectType({
name: 'edge_recordInfo',
fields: {
id: {type: GraphQLString},
pair_id: {type: GraphQLString},
data_source_id: {type: GraphQLString},
import_id: {type: GraphQLString},
origin_id: {type: GraphQLString},
origin_metatype_id: {type: GraphQLString},
destination_id: {type: GraphQLString},
destination_metatype_id: {type: GraphQLString},
relationship_name: {type: GraphQLString},
created_at: {type: GraphQLString},
created_by: {type: GraphQLString},
modified_at: {type: GraphQLString},
modified_by: {type: GraphQLString},
metadata: {type: GraphQLJSON},
count: {type: GraphQLInt},
page: {type: GraphQLInt},
},
});
relationshipResults.value.forEach((relationship) => {
relationshipGraphQLObjects[stringToValidPropertyName(relationship.name)] = {
args: {
...this.inputFieldsForRelationship(relationship),
_record: {type: edgeRecordInputType},
},
description: relationship.description,
type: (options.returnFile) ? fileInfo : new GraphQLList(
new GraphQLObjectType({
name: stringToValidPropertyName(relationship.name),
// needed because the return type accepts an object, but throws a fit about it
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
// @ts-ignore
fields: () => {
const output: {[key: string]: {[key: string]: GraphQLNamedType | GraphQLList<any>}} = {};
output._record = {type: edgeRecordInfo};
relationship.keys?.forEach((relationshipKey) => {
const propertyName = stringToValidPropertyName(relationshipKey.property_name);
switch (relationshipKey.data_type) {
// because we have no specification on our internal number type, we
// must set this as a float for now
case 'number': {
output[propertyName] = {
type: GraphQLFloat,
};
break;
}
case 'boolean': {
output[propertyName] = {
type: GraphQLBoolean,
};
break;
}
case 'string' || 'date' || 'file': {
output[propertyName] = {
type: GraphQLString,
};
break;
}
case 'list': {
output[propertyName] = {
type: new GraphQLList(GraphQLJSON),
};
break;
}
case 'enumeration': {
const enumMap: {[key: string]: GraphQLEnumValueConfig} = {};
if (relationshipKey.options) {
relationshipKey.options.forEach((option) => {
enumMap[option] = {
value: option,
};
});
}
output[propertyName] = {
type: new GraphQLEnumType({
name: stringToValidPropertyName(`${relationship.name}_${relationshipKey.name}_Enum_TypeA`),
values: enumMap,
}),
};
break;
}
default: {
output[propertyName] = {
type: GraphQLString,
};
}
}
});
return output;
},
}),
),
resolve: this.resolverForRelationships(containerID, relationship, options),
};
});
const metatypeObjects = new GraphQLObjectType({
name: 'metatypes',
fields: metatypeGraphQLObjects,
});
const relationshipObjects = new GraphQLObjectType({
name: 'relationships',
fields: relationshipGraphQLObjects,
});
// nodeType and edgeType for flexibility in filtering graph return
const nodeInputType = new GraphQLInputObjectType({
name: 'node_input',
fields: {
name: {type: GraphQLString},
id: {type: GraphQLString},
origin_name: {type: GraphQLString},
origin_id: {type: GraphQLString},
destination_name: {type: GraphQLString},
destination_id: {type: GraphQLString},
},
});
const edgeInputType = new GraphQLInputObjectType({
name: 'edge_input',
fields: {
name: {type: GraphQLString},
id: {type: GraphQLString},
},
});
// the fields on which a user can filter the graph return
const graphInput: {[key: string]: any} = {
root_node: {type: new GraphQLNonNull(GraphQLString)}, // root node must be specified
node_type: {type: nodeInputType},
edge_type: {type: edgeInputType},
depth: {type: new GraphQLNonNull(GraphQLString)}, // depth must be specified
};
const graphType = new GraphQLList(
new GraphQLObjectType({
name: 'graph_type',
fields: {
// For more advanced querying these may become an Object type of their own
// to retrieve only specific properties from origin, edge and destination.
// For now json will do.
origin_properties: {type: GraphQLJSON},
edge_properties: {type: GraphQLJSON},
destination_properties: {type: GraphQLJSON},
// origin data
origin_id: {type: GraphQLString},
origin_metatype_name: {type: GraphQLString},
origin_metatype_id: {type: GraphQLString},
origin_data_source: {type: GraphQLString},
origin_metadata: {type: GraphQLJSON},
origin_created_by: {type: GraphQLString},
origin_created_at: {type: GraphQLString},
origin_modified_by: {type: GraphQLString},
origin_modified_at: {type: GraphQLString},
// edge data
edge_id: {type: GraphQLString},
relationship_name: {type: GraphQLString},
relationship_pair_id: {type: GraphQLString},
relationship_id: {type: GraphQLString},
edge_data_source: {type: GraphQLString},
edge_metadata: {type: GraphQLJSON},
edge_created_by: {type: GraphQLString},
edge_created_at: {type: GraphQLString},
edge_modified_by: {type: GraphQLString},
edge_modified_at: {type: GraphQLString},
// destination data
destination_id: {type: GraphQLString},
destination_metatype_name: {type: GraphQLString},
destination_metatype_id: {type: GraphQLString},
destination_data_source: {type: GraphQLString},
destination_metadata: {type: GraphQLJSON},
destination_created_by: {type: GraphQLString},
destination_created_at: {type: GraphQLString},
destination_modified_by: {type: GraphQLString},
destination_modified_at: {type: GraphQLString},
// graph metadata
depth: {type: GraphQLInt},
path: {type: GraphQLList(GraphQLString)},
},
}),
);
const fields: {[key: string]: any} = {};
if (Object.keys(metatypeGraphQLObjects).length > 0) {
fields.metatypes = {
type: metatypeObjects,
resolve: () => {
return metatypeGraphQLObjects;
},
};
}
if (Object.keys(relationshipGraphQLObjects).length > 0) {
fields.relationships = {
type: relationshipObjects,
resolve: () => {
return relationshipGraphQLObjects;
},
};
}
fields.graph = {
args: {...graphInput},
type: (options.returnFile) ? fileInfo : graphType,
resolve: this.resolverForGraph(containerID, options) as any,
};
return Promise.resolve(
Result.Success(
new GraphQLSchema({
query: new GraphQLObjectType({
name: 'Query',
fields,
}),
}),
),
);
}
