Feat/relationship-properties-create

packages/graphql/src/classes/Relationship.ts

@@ -31,6 +31,7 @@ export interface RelationshipConstructor {
     name: string;
     type: string;
     description?: string;
+    properties?: string;
     fields: RelationshipField[];
 }
 
@@ -41,12 +42,15 @@ class Relationship {
 
     public description?: string;
 
+    public properties?: string;
+
     public fields: RelationshipField[];
 
     constructor(input: RelationshipConstructor) {
         this.name = input.name;
         this.type = input.type;
         this.description = input.description;
+        this.properties = input.properties;
         this.fields = input.fields;
     }
 }

packages/graphql/src/schema/make-augmented-schema.ts

@@ -275,6 +275,28 @@ function makeAugmentedSchema(
             name: `${relationship.name.value}Where`,
             fields: relationshipWhereFields,
         });
+
+        composer.createInputTC({
+            name: `${relationship.name.value}CreateInput`,
+            // TODO - Duplicated with rel properties
+            fields: relationshipFieldMeta.reduce((res, f) => {
+                if ((f as PrimitiveField)?.autogenerate) {
+                    return res;
+                }
+
+                if ((f as PrimitiveField)?.defaultValue !== undefined) {
+                    const field: InputTypeComposerFieldConfigAsObjectDefinition = {
+                        type: f.typeMeta.input.create.pretty,
+                        defaultValue: (f as PrimitiveField)?.defaultValue,
+                    };
+                    res[f.fieldName] = field;
+                } else {
+                    res[f.fieldName] = f.typeMeta.input.create.pretty;
+                }
+
+                return res;
+            }, {}),
+        });
     });
 
     if (pointInTypeDefs) {
@@ -363,6 +385,7 @@ function makeAugmentedSchema(
             });
         }
 
+        // TODO - use getWhereFields
         const queryFields = {
             OR: `[${node.name}Where!]`,
             AND: `[${node.name}Where!]`,
@@ -434,6 +457,7 @@ function makeAugmentedSchema(
 
         const nodeInput = composer.createInputTC({
             name: `${node.name}CreateInput`,
+            // TODO - Duplicated with rel properties
             fields: [
                 ...node.primitiveFields,
                 ...node.scalarFields,
@@ -550,7 +574,9 @@ function makeAugmentedSchema(
 
                 refNodes.forEach((n) => {
                     const concatFieldName = `${rel.fieldName}_${n.name}`;
-                    const createField = rel.typeMeta.array ? `[${n.name}CreateInput!]` : `${n.name}CreateInput`;
+                    const createFieldInputName = rel.typeMeta.array
+                        ? `[${node.name}${upperFirstLetter(rel.fieldName)}CreateFieldInput!]`
+                        : `${node.name}${upperFirstLetter(rel.fieldName)}CreateFieldInput`;
                     const updateField = `${n.name}UpdateInput`;
                     const nodeFieldInputName = `${node.name}${upperFirstLetter(rel.fieldName)}${n.name}FieldInput`;
                     const nodeFieldUpdateInputName = `${node.name}${upperFirstLetter(rel.fieldName)}${
@@ -574,22 +600,32 @@ function makeAugmentedSchema(
                         [n.name]: `${n.name}Where`,
                     });
 
+                    if (!composer.has(`${node.name}${upperFirstLetter(rel.fieldName)}CreateFieldInput`)) {
+                        composer.createInputTC({
+                            name: `${node.name}${upperFirstLetter(rel.fieldName)}CreateFieldInput`,
+                            fields: {
+                                node: `${n.name}CreateInput!`,
+                                ...(rel.properties ? { properties: `${rel.properties}CreateInput!` } : {}),
+                            },
+                        });
+                    }
+
                     composer.createInputTC({
                         name: nodeFieldUpdateInputName,
                         fields: {
                             where: `${n.name}Where`,
                             update: updateField,
                             connect: connectField,
                             disconnect: disconnectField,
-                            create: createField,
+                            create: createFieldInputName,
                             delete: deleteField,
                         },
                     });
 
                     composer.createInputTC({
                         name: nodeFieldInputName,
                         fields: {
-                            create: createField,
+                            create: createFieldInputName,
                             connect: connectField,
                         },
                     });
@@ -607,7 +643,7 @@ function makeAugmentedSchema(
                     });
 
                     nodeRelationInput.addFields({
-                        [concatFieldName]: createField,
+                        [concatFieldName]: createFieldInputName,
                     });
 
                     nodeInput.addFields({
@@ -639,9 +675,11 @@ function makeAugmentedSchema(
             }
 
             const n = nodes.find((x) => x.name === rel.typeMeta.name) as Node;
-            const createField = rel.typeMeta.array ? `[${n.name}CreateInput!]` : `${n.name}CreateInput`;
             const updateField = `${n.name}UpdateInput`;
             const nodeFieldInputName = `${node.name}${upperFirstLetter(rel.fieldName)}FieldInput`;
+            const createFieldInputName = rel.typeMeta.array
+                ? `[${node.name}${upperFirstLetter(rel.fieldName)}CreateFieldInput!]`
+                : `${node.name}${upperFirstLetter(rel.fieldName)}CreateFieldInput`;
             const nodeFieldUpdateInputName = `${node.name}${upperFirstLetter(rel.fieldName)}UpdateFieldInput`;
             const nodeFieldDeleteInputName = `${node.name}${upperFirstLetter(rel.fieldName)}DeleteFieldInput`;
             const connectField = rel.typeMeta.array ? `[${n.name}ConnectFieldInput!]` : `${n.name}ConnectFieldInput`;
@@ -660,6 +698,16 @@ function makeAugmentedSchema(
                       }),
             });
 
+            if (!composer.has(`${node.name}${upperFirstLetter(rel.fieldName)}CreateFieldInput`)) {
+                composer.createInputTC({
+                    name: `${node.name}${upperFirstLetter(rel.fieldName)}CreateFieldInput`,
+                    fields: {
+                        node: `${n.name}CreateInput!`,
+                        ...(rel.properties ? { properties: `${rel.properties}CreateInput!` } : {}),
+                    },
+                });
+            }
+
             composeNode.addFields({
                 [rel.fieldName]: {
                     type: rel.typeMeta.pretty,
@@ -677,15 +725,15 @@ function makeAugmentedSchema(
                     update: updateField,
                     connect: connectField,
                     disconnect: disconnectField,
-                    create: createField,
+                    create: createFieldInputName,
                     delete: deleteField,
                 },
             });
 
             composer.createInputTC({
                 name: nodeFieldInputName,
                 fields: {
-                    create: createField,
+                    create: createFieldInputName,
                     connect: connectField,
                 },
             });
@@ -705,7 +753,7 @@ function makeAugmentedSchema(
             }
 
             nodeRelationInput.addFields({
-                [rel.fieldName]: createField,
+                [rel.fieldName]: createFieldInputName,
             });
 
             nodeInput.addFields({
@@ -823,6 +871,7 @@ function makeAugmentedSchema(
                 fields: connectionField.relationship.properties
                     ? (relationshipFields.get(connectionField.relationship.properties) as RelationshipField[])
                     : [],
+                properties: connectionField.relationship.properties,
             });
             relationships.push(r);
         });

packages/graphql/src/translate/create-create-and-params.ts

@@ -17,11 +17,12 @@
  * limitations under the License.
  */
 
-import { Node } from "../classes";
+import { Node, Relationship } from "../classes";
 import { Context } from "../types";
 import createConnectAndParams from "./create-connect-and-params";
 import createAuthAndParams from "./create-auth-and-params";
 import { AUTH_FORBIDDEN_ERROR } from "../constants";
+import createSetRelationshipProperties from "./create-set-relationship-properties";
 
 interface Res {
     creates: string[];
@@ -68,23 +69,41 @@ function createCreateAndParams({
             if (value.create) {
                 const creates = relationField.typeMeta.array ? value.create : [value.create];
                 creates.forEach((create, index) => {
-                    const innerVarName = `${_varName}${index}`;
                     res.creates.push(`\nWITH ${withVars.join(", ")}`);
 
+                    const baseName = `${_varName}${index}`;
+                    const nodeName = `${baseName}_node`;
+                    const propertiesName = `${baseName}_relationship`;
+
                     const recurse = createCreateAndParams({
-                        input: create,
+                        input: create.node,
                         context,
                         node: refNode,
-                        varName: innerVarName,
-                        withVars: [...withVars, innerVarName],
+                        varName: nodeName,
+                        withVars: [...withVars, nodeName],
                     });
                     res.creates.push(recurse[0]);
                     res.params = { ...res.params, ...recurse[1] };
 
                     const inStr = relationField.direction === "IN" ? "<-" : "-";
                     const outStr = relationField.direction === "OUT" ? "->" : "-";
-                    const relTypeStr = `[:${relationField.type}]`;
-                    res.creates.push(`MERGE (${varName})${inStr}${relTypeStr}${outStr}(${innerVarName})`);
+                    const relTypeStr = `[${create.properties ? propertiesName : ""}:${relationField.type}]`;
+                    res.creates.push(`MERGE (${varName})${inStr}${relTypeStr}${outStr}(${nodeName})`);
+
+                    if (create.properties) {
+                        const relationship = (context.neoSchema.relationships.find(
+                            (x) => x.properties === relationField.properties
+                        ) as unknown) as Relationship;
+
+                        const setA = createSetRelationshipProperties({
+                            properties: create.properties,
+                            varName: propertiesName,
+                            relationship,
+                            operation: "CREATE",
+                        });
+                        res.creates.push(setA[0]);
+                        res.params = { ...res.params, ...setA[1] };
+                    }
                 });
             }
 
@@ -132,10 +151,13 @@ function createCreateAndParams({
             } else {
                 res.creates.push(`SET ${varName}.${key} = point($${_varName})`);
             }
-        } else {
-            res.creates.push(`SET ${varName}.${key} = $${_varName}`);
+
+            res.params[_varName] = value;
+
+            return res;
         }
 
+        res.creates.push(`SET ${varName}.${key} = $${_varName}`);
         res.params[_varName] = value;
 
         return res;

packages/graphql/src/translate/create-set-relationship-properties.ts

@@ -0,0 +1,68 @@
+/* eslint-disable prefer-destructuring */
+import { Relationship } from "../classes";
+import { BaseField, DateTimeField, PrimitiveField } from "../types";
+
+/*
+    TODO - lets reuse this function for setting either node or rel properties.
+           This was not reused due to the large differences between node fields
+           - and relationship fields. 
+*/
+function createSetRelationshipProperties({
+    properties,
+    varName,
+    relationship,
+    operation,
+}: {
+    properties: Record<string, unknown>;
+    varName: string;
+    relationship: Relationship;
+    operation: "CREATE" | "UPDATE";
+}): [string, any] {
+    const strs: string[] = [];
+    const params = {};
+
+    Object.entries(properties).forEach((entry) => {
+        const paramName = `${varName}_${entry[0]}`;
+        const field = (relationship.fields.find((x) => x.fieldName === entry[0]) as unknown) as BaseField;
+
+        if ("timestamps" in field) {
+            const f = field as DateTimeField;
+            (f.timestamps || []).forEach((ts) => {
+                if (ts.includes(operation)) {
+                    strs.push(`SET ${varName}.${f.fieldName} = datetime()`);
+                }
+            });
+
+            return;
+        }
+
+        if ("autogenerate" in field) {
+            const f = field as PrimitiveField;
+
+            strs.push(`SET ${varName}.${f.fieldName} = randomUUID()`);
+
+            return;
+        }
+
+        if (["Point", "CartesianPoint"].includes(field.typeMeta.name)) {
+            if (field.typeMeta.array) {
+                strs.push(`SET ${varName}.${field.fieldName} = [p in $${paramName} | point(p)]`);
+            } else {
+                strs.push(`SET ${varName}.${field.fieldName} = point($${paramName})`);
+            }
+
+            params[paramName] = entry[1];
+
+            return;
+        }
+
+        strs.push(`SET ${varName}.${field.fieldName} = $${paramName}`);
+        params[paramName] = entry[1];
+    });
+
+    return [strs.join("\n"), params];
+}
+
+export default createSetRelationshipProperties;
+
+/* eslint-enable prefer-destructuring */