wip

Author: MacondoExpress

packages/graphql/src/classes/Node.ts

@@ -190,8 +190,8 @@ class Node extends GraphElement {
             ...this.temporalFields,
             ...this.enumFields,
             ...this.objectFields,
-            ...this.scalarFields,
-            ...this.primitiveFields,
+            ...this.scalarFields, // this are just custom scalars
+            ...this.primitiveFields, // this are instead built-in scalars, confirmed By Alexandra
             ...this.interfaceFields,
             ...this.objectFields,
             ...this.unionFields,
@@ -200,6 +200,7 @@ class Node extends GraphElement {
     }
 
     /** Fields you can apply auth allow and bind to */
+    // Maybe we can remove this as they may not be used anymore in the new auth system
     public get authableFields(): AuthableField[] {
         return [
             ...this.primitiveFields,
@@ -254,6 +255,7 @@ class Node extends GraphElement {
         };
     }
 
+
     public get fulltextTypeNames(): FulltextTypeNames {
         return {
             result: `${this.pascalCaseSingular}FulltextResult`,

packages/graphql/src/schema-model/attribute/Attribute.ts

@@ -18,18 +18,29 @@
  */
 
 import { Neo4jGraphQLSchemaValidationError } from "../../classes/Error";
+import { AGGREGATION_COMPARISON_OPERATORS } from "../../constants";
+import type {
+    PrimitiveField,
+    CustomScalarField,
+    CustomEnumField,
+    UnionField,
+    ObjectField,
+    TemporalField,
+    PointField,
+    CypherField,
+} from "../../types";
 import type { Annotation, Annotations } from "../annotation/Annotation";
 import { AnnotationsKey, annotationToKey } from "../annotation/Annotation";
 
-export enum StandardGraphQLScalarType {
+export enum GraphQLBuiltInScalarType {
     Int = "Int",
     Float = "Float",
     String = "String",
     Boolean = "Boolean",
     ID = "ID",
-} 
+}
 
-export enum Neo4jGraphQLPointType {
+export enum Neo4jGraphQLSpatialType {
     CartesianPoint = "CartesianPoint",
     Point = "Point",
 }
@@ -47,24 +58,27 @@ export enum Neo4jGraphQLTemporalType {
     Duration = "Duration",
 }
 
-type Neo4jGraphQLScalarType = Neo4jGraphQLTemporalType | Neo4jGraphQLNumberType | Neo4jGraphQLPointType;
+type Neo4jGraphQLScalarType = Neo4jGraphQLTemporalType | Neo4jGraphQLNumberType | Neo4jGraphQLSpatialType;
 
 export type AttributeType = ScalarType | UserScalarType | ObjectType | ListType | EnumType;
 
+export type ScalarTypeType =
+    | "Neo4jGraphQLTemporalType"
+    | "Neo4jGraphQLNumberType"
+    | "Neo4jGraphQLPointType"
+    | "GraphQLBuiltInScalarType";
 
-export type ScalarTypeType = "Neo4jGraphQLTemporalType" | "Neo4jGraphQLNumberType" | "Neo4jGraphQLPointType" | "StandardGraphQLScalarType";
-export class ScalarType  {
-    name: StandardGraphQLScalarType | Neo4jGraphQLScalarType;
+export class ScalarType {
+    name: GraphQLBuiltInScalarType | Neo4jGraphQLScalarType;
     isRequired: boolean;
     ofType: ScalarTypeType;
-    constructor (name: StandardGraphQLScalarType | Neo4jGraphQLScalarType, isRequired: boolean, ofType: ScalarTypeType) {
+    constructor(name: GraphQLBuiltInScalarType | Neo4jGraphQLScalarType, isRequired: boolean, ofType: ScalarTypeType) {
         this.name = name;
         this.isRequired = isRequired;
         this.ofType = ofType;
     }
 }
 
-
 export class UserScalarType {
     name: string;
     isRequired: boolean;
@@ -74,7 +88,7 @@ export class UserScalarType {
     }
 }
 
-export class ObjectType  {
+export class ObjectType {
     name: string;
     isRequired: boolean;
     constructor(name: string, isRequired: boolean) {
@@ -104,16 +118,9 @@ export class Attribute {
     public readonly annotations: Partial<Annotations> = {};
     public readonly type: AttributeType;
     public isCypherField = false;
+    private _attributeModel: AttributeModel | undefined;
 
-    constructor({
-        name,
-        annotations,
-        type,
-    }: {
-        name: string;
-        annotations: Annotation[];
-        type: AttributeType;
-    }) {
+    constructor({ name, annotations, type }: { name: string; annotations: Annotation[]; type: AttributeType }) {
         this.name = name;
         this.type = type;
 
@@ -130,7 +137,6 @@ export class Attribute {
         });
     }
 
-
     private addAnnotation(annotation: Annotation): void {
         const annotationKey = annotationToKey(annotation);
         if (this.annotations[annotationKey]) {
@@ -144,4 +150,229 @@ export class Attribute {
         // There's no reason to narrow either, since we care more about performance.
         this.annotations[annotationKey] = annotation as any;
     }
+
+    get attributeModel(): AttributeModel {
+        if (!this._attributeModel) {
+            this._attributeModel = new AttributeModel(this);
+        }
+        return this._attributeModel;
+    }
+
+    isInt(): boolean {
+        return false;
+    }
+
+    isBigInt(): boolean {
+        return false;
+    }
+
+    isFloat(): boolean {
+        return false;
+    }
+
+    isList(): boolean {
+        return false;
+    }
+
+    isRequired(): boolean {
+        return true;
+    }
+
+    isScalar(): boolean {
+        return this.type instanceof ScalarType;
+    }
+
+    isCustomScalar(): boolean {
+        return false;
+    }
+
+    isSpatial(): boolean {
+        return false;
+    }
+
+    isTemporal(): boolean {
+        return false;
+    }
+
+    isObject(): boolean {
+        return false;
+    }
+
+    isEnum(): boolean {
+        return false;
+    }
+    // isGraphQLBuiltInScalarType is the same as isPrimitive
+    isGraphQLBuiltInScalar(): boolean {
+        return this.isScalar() && (this.type as ScalarType).ofType === "GraphQLBuiltInScalarType";
+    }
+}
+
+type MutableField =
+    | PrimitiveField
+    | CustomScalarField
+    | CustomEnumField
+    | UnionField
+    | ObjectField
+    | TemporalField
+    | PointField
+    | CypherField;
+
+class AttributeModel {
+    readonly attribute: Attribute;
+    constructor(attribute: Attribute) {
+        this.attribute = attribute;
+    }
+
+    isMutable(): boolean {
+        // this is based on the assumption that interface fields and union fields are object fields
+        return (
+            this.isSpatial() || this.isTemporal() || this.isEnum() || this.isObject() || this.isGraphQLBuiltInScalar()
+        );
+    }
+
+    isUnique(): boolean {
+        //return this.attribute.annotations.unique ? true : false;
+        return false;
+    }
+    // TODO: remember to figure out constrainableFields
+
+    /**
+     * @throws {Error} if the attribute is not a list
+     */
+    getListModel(): ListModel {
+        return new ListModel(this);
+    }
+
+    /**
+     * @throws {Error} if the attribute is not a scalar
+     */
+    getMathModel(): MathModel {
+        return new MathModel(this);
+    }
+
+    /**
+     * The following are just proxy methods to the attribute methods for convenience.
+     * the idea is to improve the ergonomic for the client for case when they want to access information about the Attribute model,
+     * and they are forced to switch between the attribute and the attribute model.
+     *
+     **/
+    /**
+     * START OF PROXY METHODS
+     **/
+    isCustomScalar(): boolean {
+        return this.attribute.isCustomScalar();
+    }
+
+    isInt(): boolean {
+        return this.attribute.isInt();
+    }
+
+    isBigInt(): boolean {
+        return this.attribute.isBigInt();
+    }
+
+    isFloat(): boolean {
+        return this.attribute.isFloat();
+    }
+
+    isList(): boolean {
+        return this.attribute.isList();
+    }
+
+    isRequired(): boolean {
+        return this.attribute.isRequired();
+    }
+
+    isScalar(): boolean {
+        return this.attribute.isScalar();
+    }
+
+    isGraphQLBuiltInScalar(): boolean {
+        return this.attribute.isGraphQLBuiltInScalar();
+    }
+
+    isSpatial(): boolean {
+        return this.attribute.isSpatial();
+    }
+
+    isTemporal(): boolean {
+        return this.attribute.isSpatial();
+    }
+
+    isObject(): boolean {
+        return this.attribute.isObject();
+    }
+
+    isEnum(): boolean {
+        return this.attribute.isEnum();
+    }
+    /**
+     * END OF PROXY METHODS
+     **/
+}
+
+class MathModel {
+    readonly attributeModel: AttributeModel;
+    constructor(attributeModel: AttributeModel) {
+        if (!attributeModel.isScalar()) {
+            throw new Error("Attribute is not a scalar");
+        }
+        this.attributeModel = attributeModel;
+    }
+
+    getMathMethods(): string[] {
+        return [this.getAdd()];
+    }
+
+    getAdd(): string {
+        return this.attributeModel.attribute.isInt() || this.attributeModel.attribute.isBigInt()
+            ? `${this.attributeModel.attribute.name}_ADD`
+            : `${this.attributeModel.attribute.name}_INCREMENT`;
+    }
+}
+
+class AggregationModel {
+    readonly attributeModel: AttributeModel;
+    constructor(attributeModel: AttributeModel) {
+        if (!attributeModel.isScalar()) {
+            throw new Error("Attribute is not a scalar");
+        }
+        this.attributeModel = attributeModel;
+    }
+
+    getAggregationMethods(): string[] {
+        return [...this.getAverageMethods()];
+    }
+
+    getAverageMethods(): string[] {
+        return AGGREGATION_COMPARISON_OPERATORS.map(
+            (operator) => `${this.attributeModel.attribute.name}_AVERAGE_${operator}`
+        );
+    }
+    isAggregate(string): boolean {
+        
+    } 
+}
+
+class ListModel {
+    readonly attributeModel: AttributeModel;
+
+    constructor(attributeModel: AttributeModel) {
+        if (!attributeModel.attribute.isList()) {
+            throw new Error("Attribute is not a list");
+        }
+        this.attributeModel = attributeModel;
+    }
+
+    getArrayMethods(): string[] {
+        return [this.getPush(), this.getPop()];
+    }
+
+    getPush(): string {
+        return `${this.attributeModel.attribute.name}_PUSH`;
+    }
+
+    getPop(): string {
+        return `${this.attributeModel.attribute.name}_POP`;
+    }
 }

packages/graphql/src/schema-model/entity/ConcreteEntity.ts

@@ -31,7 +31,6 @@ export class ConcreteEntity implements Entity {
     public readonly attributes: Map<string, Attribute> = new Map();
     public readonly relationships: Map<string, Relationship> = new Map();
     public readonly annotations: Partial<Annotations> = {};
-    // TODO: 
 
     constructor({
         name,