Decorators/methods

src/modules/user/CreateUser.ts

@@ -1,51 +1,128 @@
-import {
-  Resolver,
-  Mutation,
-  Arg,
-  ClassType,
-  InputType,
-  Field,
-  UseMiddleware
-} from "type-graphql";
-import { RegisterInput } from "./register/RegisterInput";
+import { Arg, ClassType, Mutation, Query, Resolver } from "type-graphql";
 import { User } from "../../entity/User";
-import { Product } from "../../entity/Product";
-import { Middleware } from "type-graphql/interfaces/Middleware";
+import { RegisterInput } from "./register/RegisterInput";
+
+const methodList = {
+  query: {
+    genre: Query,
+    list: {
+      findAll: (data: any) => {
+        console.log("query findAll data: ", data);
+      },
+      findOne: (data: any) => {
+        console.log("query findOne data: ", data);
+      }
+    }
+  },
+  mutation: {
+    genre: Mutation,
+    list: {
+      createM: (data: any) => {
+        console.log("mutation create data: ", data);
+      },
+      deleteM: (data: any) => {
+        console.log("mutation delete data: ", data);
+      }
+    }
+  }
+};
+
+// @ts-ignore
+interface BaseResolver {
+  // @ts-ignore
+  createM?: typeof methodList.createM;
+  // @ts-ignore
+  deleteM?: typeof methodList.deleteM;
+  [key: string]: any;
+}
 
+// @ts-ignore
 function createResolver<T extends ClassType, X extends ClassType>(
   suffix: string,
   returnType: T,
   inputType: X,
   entity: any,
-  middleware?: Middleware<any>[]
-) {
+  operations: any[]
+): any {
+  function classDecorator(): any {
+    return function(
+      target: any,
+      propertyKey: string,
+      descriptor: PropertyDescriptor
+    ) {
+      operations.forEach(oper => {
+        // @ts-ignore
+        const deco = methodList[oper.genre].genre;
+        // @ts-ignore
+        oper.meth.forEach(method => {
+          // @ts-ignore
+          target.prototype[method] = methodList[oper.genre].list[method];
+          //const targetMethod = target.prototype[method];
+          const targetPrototype = target.prototype;
+          const methodKey = method;
+          // @ts-ignore
+          deco(() => returnType, {
+            name: `${method}${suffix}`,
+            nullable: true
+          })(
+            targetPrototype,
+            // @ts-ignore
+            methodKey
+          );
+        });
+      });
+      console.log("target: ", target);
+      console.log("propertyKey: ", propertyKey);
+      console.log("descriptor: ", descriptor);
+    };
+  }
+
+  @classDecorator()
   @Resolver()
   class BaseResolver {
     @Mutation(() => returnType, { name: `create${suffix}` })
-    @UseMiddleware(...(middleware || []))
-    async create(@Arg("data", () => inputType) data: any) {
+    create(
+      @Arg("data", () => inputType)
+      data: any
+    ) {
       return entity.create(data).save();
     }
+
+    /* constructor() {
+      methods.forEach(method => {
+        BaseResolver.prototype[method] = createM;
+      });
+    } */
   }
 
   return BaseResolver;
 }
 
-@InputType()
-class ProductInput {
-  @Field()
-  name: string;
-}
-
 export const CreateUserResolver = createResolver(
   "User",
   User,
   RegisterInput,
-  User
-);
-export const CreateProductResolver = createResolver(
-  "Product",
-  Product,
-  ProductInput,
-  Product
+  User,
+  [{ genre: "query", meth: ["findAll", "findOne"] }]
 );
+
+/*
+ *  List of type-graphql decorators and their needed parameters:
+ *    ParameterDecorator: prototype, propertyKey, parameterIndex
+ *      Arg, Args, Ctx, Info, PubSub, Root,
+ *
+ *    ClassDecorator: target
+ *      ArgsType, InputType, InterfaceType, ObjectType, Resolver,
+ *
+ *    MethodAndPropDecorator: prototype, propertyKey, descriptor
+ *      Authorized, Field,
+ *
+ *    MethodDecorator: prototype, propertyKey/methodName
+ *      FieldResolver, Mutation, Query, Subscription,
+ *
+ *    UseMiddleware can be: MethodAndPropDecorator, MethodDecorator , PropertyDecorator
+ *
+ *    registerEnumType accepts enumObj and EnumConfig
+ *    createUnionType to be seen better
+ *
+ */

src/modules/user/Login.ts

@@ -1,6 +1,5 @@
-import { Resolver, Mutation, Arg, Ctx } from "type-graphql";
 import bcrypt from "bcryptjs";
-
+import { Arg, Ctx, Mutation, Resolver } from "type-graphql";
 import { User } from "../../entity/User";
 import { MyContext } from "../../types/MyContext";
 
@@ -15,16 +14,19 @@ export class LoginResolver {
     const user = await User.findOne({ where: { email } });
 
     if (!user) {
+      console.log("LOGIN: no user");
       return null;
     }
 
     const valid = await bcrypt.compare(password, user.password);
 
     if (!valid) {
+      console.log("LOGIN: invalid password");
       return null;
     }
 
     if (!user.confirmed) {
+      console.log("LOGIN: user not confirmed");
       return null;
     }
 

src/utils/createSchema.ts

@@ -7,8 +7,8 @@ import { LogoutResolver } from "../modules/user/Logout";
 import { MeResolver } from "../modules/user/Me";
 import { RegisterResolver } from "../modules/user/Register";
 import {
-  CreateUserResolver,
-  CreateProductResolver
+  CreateUserResolver
+  //CreateProductResolver
 } from "../modules/user/CreateUser";
 
 export const createSchema = () =>
@@ -21,8 +21,8 @@ export const createSchema = () =>
       LogoutResolver,
       MeResolver,
       RegisterResolver,
-      CreateUserResolver,
-      CreateProductResolver
+      CreateUserResolver
+      //CreateProductResolver
     ],
     authChecker: ({ context: { req } }) => {
       return !!req.session.userId;