Declarative primary keys, constraints and indexes with @id, @unique, and @index directives

src/augment/directives.js

@@ -10,6 +10,7 @@ import {
   buildDirective,
   buildName
 } from './ast';
+import { ApolloError } from 'apollo-server-errors';
 
 /**
  * An enum describing the names of directive definitions and instances
@@ -23,7 +24,10 @@ export const DirectiveDefinition = {
   IS_AUTHENTICATED: 'isAuthenticated',
   HAS_ROLE: 'hasRole',
   HAS_SCOPE: 'hasScope',
-  ADDITIONAL_LABELS: 'additionalLabels'
+  ADDITIONAL_LABELS: 'additionalLabels',
+  ID: 'id',
+  UNIQUE: 'unique',
+  INDEX: 'index'
 };
 
 // The name of Role type used in authorization logic
@@ -37,24 +41,84 @@ const RelationshipDirectionField = {
   TO: 'to'
 };
 
-/**
- * A predicate function for cypher directive fields
- */
 export const isCypherField = ({ directives = [] }) =>
   getDirective({
     directives,
     name: DirectiveDefinition.CYPHER
   });
 
-/**
- * A predicate function for neo4j_ignore directive fields
- */
 export const isIgnoredField = ({ directives = [] }) =>
   getDirective({
     directives,
     name: DirectiveDefinition.NEO4J_IGNORE
   });
 
+export const isRelationField = ({ directives = [] }) =>
+  getDirective({
+    directives,
+    name: DirectiveDefinition.RELATION
+  });
+
+export const isPrimaryKeyField = ({ directives = [] }) =>
+  getDirective({
+    directives,
+    name: DirectiveDefinition.ID
+  });
+
+export const isUniqueField = ({ directives = [] }) =>
+  getDirective({
+    directives,
+    name: DirectiveDefinition.UNIQUE
+  });
+
+export const isIndexedField = ({ directives = [] }) =>
+  getDirective({
+    directives,
+    name: DirectiveDefinition.INDEX
+  });
+
+export const validateFieldDirectives = ({ fields = [], directives = [] }) => {
+  const primaryKeyFields = fields.filter(field =>
+    isPrimaryKeyField({
+      directives: field.directives
+    })
+  );
+  if (primaryKeyFields.length > 1)
+    throw new ApolloError(
+      `The @id directive can only be used once per node type.`
+    );
+  const isPrimaryKey = isPrimaryKeyField({ directives });
+  const isUnique = isUniqueField({ directives });
+  const isIndex = isIndexedField({ directives });
+  const isComputed = isCypherField({ directives });
+  if (isComputed) {
+    if (isPrimaryKey)
+      throw new ApolloError(
+        `The @id directive cannot be used with the @cypher directive because computed fields are not stored as properties.`
+      );
+    if (isUnique)
+      throw new ApolloError(
+        `The @unique directive cannot be used with the @cypher directive because computed fields are not stored as properties.`
+      );
+    if (isIndex)
+      throw new ApolloError(
+        `The @index directive cannot used with the @cypher directive because computed fields are not stored as properties.`
+      );
+  }
+  if (isPrimaryKey && isUnique)
+    throw new ApolloError(
+      `The @id and @unique directive combined are redunant. The @id directive already sets a unique property constraint and an index.`
+    );
+  if (isPrimaryKey && isIndex)
+    throw new ApolloError(
+      `The @id and @index directive combined are redundant. The @id directive already sets a unique property constraint and an index.`
+    );
+  if (isUnique && isIndex)
+    throw new ApolloError(
+      `The @unique and @index directive combined are redunant. The @unique directive sets both a unique property constraint and an index.`
+    );
+};
+
 /**
  * The main export for augmenting directive definitions
  */
@@ -363,6 +427,24 @@ const directiveDefinitionBuilderMap = {
       name: DirectiveDefinition.NEO4J_IGNORE,
       locations: [DirectiveLocation.FIELD_DEFINITION]
     };
+  },
+  [DirectiveDefinition.ID]: ({ config }) => {
+    return {
+      name: DirectiveDefinition.ID,
+      locations: [DirectiveLocation.FIELD_DEFINITION]
+    };
+  },
+  [DirectiveDefinition.UNIQUE]: ({ config }) => {
+    return {
+      name: DirectiveDefinition.UNIQUE,
+      locations: [DirectiveLocation.FIELD_DEFINITION]
+    };
+  },
+  [DirectiveDefinition.INDEX]: ({ config }) => {
+    return {
+      name: DirectiveDefinition.INDEX,
+      locations: [DirectiveLocation.FIELD_DEFINITION]
+    };
   }
 };
 

src/augment/fields.js

@@ -267,3 +267,20 @@ export const propertyFieldExists = ({
     );
   });
 };
+
+export const getTypeFields = ({
+  typeName = '',
+  definition = {},
+  typeExtensionDefinitionMap = {}
+}) => {
+  const allFields = [];
+  const fields = definition.fields;
+  if (fields && fields.length) {
+    // if there are .fields, return them
+    allFields.push(...fields);
+    const extensions = typeExtensionDefinitionMap[typeName] || [];
+    // also return any .fields of extensions of this type
+    extensions.forEach(extension => allFields.push(...extension.fields));
+  }
+  return allFields;
+};

src/augment/types/node/mutation.js

@@ -11,14 +11,15 @@ import {
   useAuthDirective,
   isCypherField
 } from '../../directives';
-import { getPrimaryKey } from '../../../utils';
+import { getPrimaryKey } from './selection';
 import { shouldAugmentType } from '../../augment';
 import { OperationType } from '../../types/types';
 import {
   TypeWrappers,
   getFieldDefinition,
   isNeo4jIDField,
-  getTypeExtensionFieldDefinition
+  getTypeExtensionFieldDefinition,
+  getTypeFields
 } from '../../fields';
 
 /**
@@ -46,7 +47,12 @@ export const augmentNodeMutationAPI = ({
   typeExtensionDefinitionMap,
   config
 }) => {
-  const primaryKey = getPrimaryKey(definition);
+  const fields = getTypeFields({
+    typeName,
+    definition,
+    typeExtensionDefinitionMap
+  });
+  const primaryKey = getPrimaryKey({ fields });
   const mutationTypeName = OperationType.MUTATION;
   const mutationType = operationTypeMap[mutationTypeName];
   const mutationTypeNameLower = mutationTypeName.toLowerCase();

src/augment/types/node/node.js

@@ -11,7 +11,8 @@ import {
   TypeWrappers,
   unwrapNamedType,
   isPropertyTypeField,
-  buildNeo4jSystemIDField
+  buildNeo4jSystemIDField,
+  getTypeFields
 } from '../../fields';
 import {
   FilteringArgument,
@@ -23,7 +24,11 @@ import {
   getRelationName,
   getDirective,
   isIgnoredField,
-  DirectiveDefinition
+  isPrimaryKeyField,
+  isUniqueField,
+  isIndexedField,
+  DirectiveDefinition,
+  validateFieldDirectives
 } from '../../directives';
 import {
   buildName,
@@ -40,7 +45,8 @@ import {
   isObjectTypeExtensionDefinition,
   isInterfaceTypeExtensionDefinition
 } from '../../types/types';
-import { getPrimaryKey } from '../../../utils';
+import { getPrimaryKey } from './selection';
+import { ApolloError } from 'apollo-server-errors';
 
 /**
  * The main export for the augmentation process of a GraphQL
@@ -216,7 +222,8 @@ export const augmentNodeTypeFields = ({
       let fieldType = field.type;
       let fieldArguments = field.arguments;
       const fieldDirectives = field.directives;
-      if (!isIgnoredField({ directives: fieldDirectives })) {
+      const isIgnored = isIgnoredField({ directives: fieldDirectives });
+      if (!isIgnored) {
         isIgnoredType = false;
         const fieldName = field.name.value;
         const unwrappedType = unwrapNamedType({ type: fieldType });
@@ -236,6 +243,10 @@ export const augmentNodeTypeFields = ({
             type: outputType
           })
         ) {
+          validateFieldDirectives({
+            fields,
+            directives: fieldDirectives
+          });
           nodeInputTypeMap = augmentInputTypePropertyFields({
             inputTypeMap: nodeInputTypeMap,
             fieldName,
@@ -361,6 +372,21 @@ const augmentNodeTypeField = ({
   relationshipDirective,
   outputTypeWrappers
 }) => {
+  const isPrimaryKey = isPrimaryKeyField({ directives: fieldDirectives });
+  const isUnique = isUniqueField({ directives: fieldDirectives });
+  const isIndex = isIndexedField({ directives: fieldDirectives });
+  if (isPrimaryKey)
+    throw new ApolloError(
+      `The @id directive cannot be used on @relation fields.`
+    );
+  if (isUnique)
+    throw new ApolloError(
+      `The @unique directive cannot be used on @relation fields.`
+    );
+  if (isIndex)
+    throw new ApolloError(
+      `The @index directive cannot be used on @relation fields.`
+    );
   const isUnionType = isUnionTypeDefinition({ definition: outputDefinition });
   fieldArguments = augmentNodeTypeFieldArguments({
     fieldArguments,
@@ -458,6 +484,7 @@ const augmentNodeTypeAPI = ({
       typeName,
       propertyInputValues,
       generatedTypeMap,
+      typeExtensionDefinitionMap,
       config
     });
   }
@@ -490,12 +517,18 @@ const buildNodeSelectionInputType = ({
   typeName,
   propertyInputValues,
   generatedTypeMap,
+  typeExtensionDefinitionMap,
   config
 }) => {
   const mutationTypeName = OperationType.MUTATION;
   const mutationTypeNameLower = mutationTypeName.toLowerCase();
   if (shouldAugmentType(config, mutationTypeNameLower, typeName)) {
-    const primaryKey = getPrimaryKey(definition);
+    const fields = getTypeFields({
+      typeName,
+      definition,
+      typeExtensionDefinitionMap
+    });
+    const primaryKey = getPrimaryKey({ fields });
     const propertyInputName = `_${typeName}Input`;
     if (primaryKey) {
       const primaryKeyName = primaryKey.name.value;