@martel/calyx 1.8.0 → 1.10.0

package/src/graphql/graphql.module.ts

@@ -3,6 +3,10 @@ import { Module } from '../core/decorators.ts';
 import {
   GraphQLSchema,
   GraphQLObjectType,
+  GraphQLInputObjectType,
+  GraphQLScalarType,
+  GraphQLInterfaceType,
+  GraphQLUnionType,
   GraphQLString,
   GraphQLInt,
   GraphQLFloat,
@@ -24,6 +28,66 @@ export class GraphQLModule {
     }
 
     const typeMap = new Map<any, any>();
+    const inputTypeMap = new Map<any, any>();
+
+    function findModuleClass(resolverClass: any): any {
+      for (const [moduleClass, record] of container.getModules().entries()) {
+        if (record.providers.has(resolverClass) || record.controllers.has(resolverClass)) {
+          return moduleClass;
+        }
+      }
+      return null;
+    }
+
+    function compileLifecycleItems(moduleClass: any, items: any[]): any[] {
+      return items.map((item) => {
+        if (typeof item === 'function') {
+          const isClass =
+            item.prototype &&
+            (typeof item.prototype.canActivate === 'function' ||
+              typeof item.prototype.intercept === 'function' ||
+              typeof item.prototype.transform === 'function' ||
+              typeof item.prototype.catch === 'function');
+          if (!isClass) {
+            return { isReqScoped: false, token: item, instance: item };
+          }
+          let instance: any;
+          try {
+            instance = container.resolveTokenInModuleContext(moduleClass, item);
+          } catch {
+            instance = new item();
+          }
+          return { isReqScoped: false, token: item, instance };
+        }
+        return { isReqScoped: false, token: item.constructor, instance: item };
+      });
+    }
+
+    function buildFieldsConfig(typeClass: any, isInput: boolean): any {
+      const fieldsMetadata: { propertyKey: string; typeFunc?: any; options?: any }[] =
+        Reflect.getMetadata('calyx:fields', typeClass) || [];
+
+      const fieldsConfig: any = {};
+      for (const field of fieldsMetadata) {
+        let returnTypeClass = field.typeFunc ? field.typeFunc(null) : undefined;
+        if (!returnTypeClass) {
+          returnTypeClass = Reflect.getMetadata('design:type', typeClass.prototype, field.propertyKey);
+        }
+        if (!returnTypeClass) {
+          returnTypeClass = String;
+        }
+
+        let gqlType = isInput ? getGraphQLInputType(returnTypeClass) : getGraphQLType(returnTypeClass);
+        if (Array.isArray(returnTypeClass)) {
+          gqlType = new GraphQLList(isInput ? getGraphQLInputType(returnTypeClass[0]) : getGraphQLType(returnTypeClass[0]));
+        }
+        if (!field.options?.nullable) {
+          gqlType = new GraphQLNonNull(gqlType);
+        }
+        fieldsConfig[field.propertyKey] = { type: gqlType };
+      }
+      return fieldsConfig;
+    }
 
     function getGraphQLType(typeClass: any): any {
       if (typeClass === String) return GraphQLString;
@@ -31,34 +95,49 @@ export class GraphQLModule {
       if (typeClass === Boolean) return GraphQLBoolean;
       if (typeMap.has(typeClass)) return typeMap.get(typeClass);
 
+      // Custom Scalar
+      if (typeof typeClass === 'function' && Reflect.hasMetadata('calyx:scalar', typeClass)) {
+        const scalarMeta = Reflect.getMetadata('calyx:scalar', typeClass);
+        const inst = container.get(typeClass) || new typeClass();
+        const gqlScalar = new GraphQLScalarType({
+          name: scalarMeta.name,
+          description: Reflect.getMetadata('calyx:description', typeClass),
+          serialize: inst.serialize ? inst.serialize.bind(inst) : (val: any) => val,
+          parseValue: inst.parseValue ? inst.parseValue.bind(inst) : (val: any) => val,
+          parseLiteral: inst.parseLiteral ? inst.parseLiteral.bind(inst) : undefined,
+        });
+        typeMap.set(typeClass, gqlScalar);
+        return gqlScalar;
+      }
+
+      // Interface
+      if (typeof typeClass === 'function' && Reflect.hasMetadata('calyx:interface_type', typeClass)) {
+        const gqlInterfaceType = new GraphQLInterfaceType({
+          name: typeClass.name,
+          description: Reflect.getMetadata('calyx:description', typeClass),
+          fields: () => buildFieldsConfig(typeClass, false),
+        });
+        typeMap.set(typeClass, gqlInterfaceType);
+        return gqlInterfaceType;
+      }
+
+      // Union
+      if (typeClass && (typeClass.__isUnion || (typeof typeClass === 'function' && Reflect.hasMetadata('calyx:union_type', typeClass)))) {
+        const unionMeta = typeClass.__isUnion ? typeClass : Reflect.getMetadata('calyx:union_type', typeClass);
+        const gqlUnionType = new GraphQLUnionType({
+          name: unionMeta.name,
+          types: () => unionMeta.types().map((t: any) => getGraphQLType(t)),
+          resolveType: unionMeta.resolveType,
+        });
+        typeMap.set(typeClass, gqlUnionType);
+        return gqlUnionType;
+      }
+
+      // ObjectType
       if (typeof typeClass === 'function' && Reflect.hasMetadata('calyx:object_type', typeClass)) {
         const gqlObjectType = new GraphQLObjectType({
           name: typeClass.name,
-          fields: () => {
-            const fieldsMetadata: { propertyKey: string; typeFunc?: any; options?: any }[] =
-              Reflect.getMetadata('calyx:fields', typeClass) || [];
-
-            const fieldsConfig: any = {};
-            for (const field of fieldsMetadata) {
-              let returnTypeClass = field.typeFunc ? field.typeFunc(null) : undefined;
-              if (!returnTypeClass) {
-                returnTypeClass = Reflect.getMetadata('design:type', typeClass.prototype, field.propertyKey);
-              }
-              if (!returnTypeClass) {
-                returnTypeClass = String;
-              }
-
-              let gqlType = getGraphQLType(returnTypeClass);
-              if (Array.isArray(returnTypeClass)) {
-                gqlType = new GraphQLList(getGraphQLType(returnTypeClass[0]));
-              }
-              if (!field.options?.nullable) {
-                gqlType = new GraphQLNonNull(gqlType);
-              }
-              fieldsConfig[field.propertyKey] = { type: gqlType };
-            }
-            return fieldsConfig;
-          },
+          fields: () => buildFieldsConfig(typeClass, false),
         });
 
         typeMap.set(typeClass, gqlObjectType);
@@ -68,48 +147,216 @@ export class GraphQLModule {
       return GraphQLString;
     }
 
+    function getGraphQLInputType(typeClass: any): any {
+      if (typeClass === String) return GraphQLString;
+      if (typeClass === Number) return GraphQLFloat;
+      if (typeClass === Boolean) return GraphQLBoolean;
+      if (inputTypeMap.has(typeClass)) return inputTypeMap.get(typeClass);
+
+      if (typeof typeClass === 'function' && Reflect.hasMetadata('calyx:input_type', typeClass)) {
+        const gqlInputObjectType = new GraphQLInputObjectType({
+          name: typeClass.name,
+          fields: () => buildFieldsConfig(typeClass, true),
+        });
+
+        inputTypeMap.set(typeClass, gqlInputObjectType);
+        return gqlInputObjectType;
+      }
+
+      return GraphQLString;
+    }
+
     const queryFields: any = {};
     const mutationFields: any = {};
+    const subscriptionFields: any = {};
 
     for (const resolverInstance of resolverInstances) {
       const resolverClass = resolverInstance.constructor;
+      const moduleClass = findModuleClass(resolverClass);
 
-      // Queries
-      const queries: { propertyKey: string | symbol; typeFunc?: any; options?: any }[] =
-        Reflect.getMetadata('calyx:queries', resolverClass) || [];
-      for (const query of queries) {
-        const returnTypeClass = query.typeFunc ? query.typeFunc(null) : String;
+      // Compile helper for queries, mutations, subscriptions
+      const compileField = (fieldMeta: { propertyKey: string | symbol; typeFunc?: any; options?: any }, list: any) => {
+        const returnTypeClass = fieldMeta.typeFunc ? fieldMeta.typeFunc(null) : String;
         let gqlType = getGraphQLType(returnTypeClass);
         if (Array.isArray(returnTypeClass)) {
           gqlType = new GraphQLList(getGraphQLType(returnTypeClass[0]));
         }
 
         const argsMetadata: { parameterIndex: number; name: string }[] =
-          Reflect.getMetadata('calyx:args', resolverInstance, query.propertyKey) || [];
+          Reflect.getMetadata('calyx:args', resolverInstance, fieldMeta.propertyKey) || [];
         const argsConfig: any = {};
 
-        const paramTypes = Reflect.getMetadata('design:paramtypes', resolverInstance, query.propertyKey) || [];
+        const paramTypes = Reflect.getMetadata('design:paramtypes', resolverInstance, fieldMeta.propertyKey) || [];
         for (const arg of argsMetadata) {
           const paramType = paramTypes[arg.parameterIndex] || String;
-          argsConfig[arg.name] = { type: getGraphQLType(paramType) };
+          if (!arg.name && typeof paramType === 'function' && Reflect.hasMetadata('calyx:args_type', paramType)) {
+            const fieldsMetadata = Reflect.getMetadata('calyx:fields', paramType) || [];
+            for (const f of fieldsMetadata) {
+              let fType = f.typeFunc ? f.typeFunc(null) : undefined;
+              if (!fType) {
+                fType = Reflect.getMetadata('design:type', paramType.prototype, f.propertyKey) || String;
+              }
+              let gqlFType = getGraphQLInputType(fType);
+              if (Array.isArray(fType)) {
+                gqlFType = new GraphQLList(getGraphQLInputType(fType[0]));
+              }
+              if (!f.options?.nullable) {
+                gqlFType = new GraphQLNonNull(gqlFType);
+              }
+              argsConfig[f.propertyKey] = { type: gqlFType };
+            }
+          } else {
+            const argName = arg.name || 'args';
+            argsConfig[argName] = { type: getGraphQLInputType(paramType) };
+          }
         }
 
-        const queryName = query.options?.name || String(query.propertyKey);
+        // Enhancers metadata resolution
+        const classGuards = Reflect.getMetadata('calyx:guards', resolverClass) || [];
+        const methodGuards = Reflect.getMetadata('calyx:guards', resolverClass.prototype, fieldMeta.propertyKey) || [];
+        const compiledGuards = compileLifecycleItems(moduleClass, [...classGuards, ...methodGuards]);
 
-        queryFields[queryName] = {
-          type: gqlType,
-          args: argsConfig,
-          resolve: async (parent: any, args: any, context: any) => {
-            const params: any[] = [];
-            for (const arg of argsMetadata) {
-              params[arg.parameterIndex] = args[arg.name];
+        const classInterceptors = Reflect.getMetadata('calyx:interceptors', resolverClass) || [];
+        const methodInterceptors = Reflect.getMetadata('calyx:interceptors', resolverClass.prototype, fieldMeta.propertyKey) || [];
+        const compiledInterceptors = compileLifecycleItems(moduleClass, [...classInterceptors, ...methodInterceptors]);
+
+        const classFilters = Reflect.getMetadata('calyx:filters', resolverClass) || [];
+        const methodFilters = Reflect.getMetadata('calyx:filters', resolverClass.prototype, fieldMeta.propertyKey) || [];
+        const compiledFilters = compileLifecycleItems(moduleClass, [...classFilters, ...methodFilters]);
+
+        const classPipes = Reflect.getMetadata('calyx:pipes', resolverClass) || [];
+        const methodPipes = Reflect.getMetadata('calyx:pipes', resolverClass.prototype, fieldMeta.propertyKey) || [];
+        const compiledPipes = compileLifecycleItems(moduleClass, [...classPipes, ...methodPipes]);
+
+        const fieldName = fieldMeta.options?.name || String(fieldMeta.propertyKey);
+
+        const resolveFn = async (parent: any, args: any, context: any, info: any) => {
+          const req = context?.req;
+          const { CalyxExecutionContext } = await import('../lifecycle/context.ts');
+          const execContext = new CalyxExecutionContext(req, null, resolverClass, resolverInstance[fieldMeta.propertyKey]);
+          (execContext as any).type = 'graphql';
+          (execContext as any).data = args;
+
+          const gqlArgs = [parent, args, context, info];
+          execContext.getArgs = () => gqlArgs as any;
+          execContext.getArgByIndex = (index: number) => gqlArgs[index];
+
+          try {
+            // 1. Guards
+            for (const guard of compiledGuards) {
+              const canActivate = guard.instance.canActivate(execContext);
+              const resolved = canActivate instanceof Promise ? await canActivate : canActivate;
+              if (!resolved) {
+                const { HttpException } = await import('../http/exceptions.ts');
+                throw new HttpException('Forbidden resource', 403);
+              }
+            }
+
+            // 2. Pipes
+            let processedArgs = args;
+            for (const pipe of compiledPipes) {
+              const transformed = pipe.instance.transform(processedArgs, {
+                type: 'custom',
+                metatype: undefined,
+                data: undefined,
+              });
+              processedArgs = transformed instanceof Promise ? await transformed : transformed;
+            }
+
+            const executeHandler = async () => {
+              const params: any[] = [];
+              for (const arg of argsMetadata) {
+                const paramType = paramTypes[arg.parameterIndex] || String;
+                if (!arg.name && typeof paramType === 'function' && Reflect.hasMetadata('calyx:args_type', paramType)) {
+                  const argInst = new paramType();
+                  const fieldsMetadata = Reflect.getMetadata('calyx:fields', paramType) || [];
+                  for (const f of fieldsMetadata) {
+                    argInst[f.propertyKey] = processedArgs[f.propertyKey];
+                  }
+                  params[arg.parameterIndex] = argInst;
+                } else {
+                  const argName = arg.name || 'args';
+                  params[arg.parameterIndex] = processedArgs[argName];
+                }
+              }
+              const parentParams = Reflect.getMetadata('calyx:parent', resolverInstance, fieldMeta.propertyKey) || [];
+              for (const idx of parentParams) {
+                params[idx] = parent;
+              }
+              return resolverInstance[fieldMeta.propertyKey](...params);
+            };
+
+            // 3. Interceptors
+            if (compiledInterceptors.length > 0) {
+              let interceptorIndex = 0;
+              const nextHandler = async (): Promise<any> => {
+                if (interceptorIndex < compiledInterceptors.length) {
+                  const interceptor = compiledInterceptors[interceptorIndex++];
+                  return interceptor.instance.intercept(execContext, { handle: () => nextHandler() });
+                }
+                return executeHandler();
+              };
+              return await nextHandler();
+            } else {
+              return await executeHandler();
             }
-            const parentParams = Reflect.getMetadata('calyx:parent', resolverInstance, query.propertyKey) || [];
-            for (const idx of parentParams) {
-              params[idx] = parent;
+          } catch (err: any) {
+            // 4. Exception Filters
+            if (compiledFilters.length > 0) {
+              for (const filter of compiledFilters) {
+                const catchException = Reflect.getMetadata('calyx:catch', filter.token) || [];
+                if (catchException.length === 0 || catchException.some((exc: any) => err instanceof exc)) {
+                  const filterResult = filter.instance.catch(err, execContext);
+                  if (filterResult !== undefined) {
+                    return filterResult;
+                  }
+                }
+              }
             }
-            return resolverInstance[query.propertyKey](...params);
-          },
+            throw err;
+          }
+        };
+
+        list[fieldName] = {
+          type: gqlType,
+          args: argsConfig,
+          resolve: resolveFn,
+        };
+
+        return { argsMetadata, paramTypes };
+      };
+
+      // Queries
+      const queries: { propertyKey: string | symbol; typeFunc?: any; options?: any }[] =
+        Reflect.getMetadata('calyx:queries', resolverClass) || [];
+      for (const query of queries) {
+        compileField(query, queryFields);
+      }
+
+      // Mutations
+      const mutations: { propertyKey: string | symbol; typeFunc?: any; options?: any }[] =
+        Reflect.getMetadata('calyx:mutations', resolverClass) || [];
+      for (const mutation of mutations) {
+        compileField(mutation, mutationFields);
+      }
+
+      // Subscriptions
+      const subscriptions: { propertyKey: string | symbol; typeFunc?: any; options?: any }[] =
+        Reflect.getMetadata('calyx:subscriptions', resolverClass) || [];
+      for (const sub of subscriptions) {
+        const { argsMetadata, paramTypes } = compileField(sub, subscriptionFields);
+        const subName = sub.options?.name || String(sub.propertyKey);
+        
+        const originalResolve = subscriptionFields[subName].resolve;
+        subscriptionFields[subName].subscribe = originalResolve;
+        subscriptionFields[subName].resolve = (payload: any) => {
+          if (sub.options?.resolve) {
+            return sub.options.resolve(payload);
+          }
+          if (payload && typeof payload === 'object' && subName in payload) {
+            return payload[subName];
+          }
+          return payload;
         };
       }
 
@@ -125,18 +372,107 @@ export class GraphQLModule {
           for (const fieldRes of fieldResolvers) {
             const fieldName = fieldRes.options?.name || String(fieldRes.propertyKey);
             if (targetFields[fieldName]) {
-              targetFields[fieldName].resolve = async (parent: any, args: any, context: any) => {
-                const argsMetadata: { parameterIndex: number; name: string }[] =
-                  Reflect.getMetadata('calyx:args', resolverInstance, fieldRes.propertyKey) || [];
-                const params: any[] = [];
-                for (const arg of argsMetadata) {
-                  params[arg.parameterIndex] = args[arg.name];
-                }
-                const parentParams = Reflect.getMetadata('calyx:parent', resolverInstance, fieldRes.propertyKey) || [];
-                for (const idx of parentParams) {
-                  params[idx] = parent;
+              // Resolve field enhancers resolution
+              const classGuards = Reflect.getMetadata('calyx:guards', resolverClass) || [];
+              const methodGuards = Reflect.getMetadata('calyx:guards', resolverClass.prototype, fieldRes.propertyKey) || [];
+              const compiledGuards = compileLifecycleItems(moduleClass, [...classGuards, ...methodGuards]);
+
+              const classInterceptors = Reflect.getMetadata('calyx:interceptors', resolverClass) || [];
+              const methodInterceptors = Reflect.getMetadata('calyx:interceptors', resolverClass.prototype, fieldRes.propertyKey) || [];
+              const compiledInterceptors = compileLifecycleItems(moduleClass, [...classInterceptors, ...methodInterceptors]);
+
+              const classFilters = Reflect.getMetadata('calyx:filters', resolverClass) || [];
+              const methodFilters = Reflect.getMetadata('calyx:filters', resolverClass.prototype, fieldRes.propertyKey) || [];
+              const compiledFilters = compileLifecycleItems(moduleClass, [...classFilters, ...methodFilters]);
+
+              const classPipes = Reflect.getMetadata('calyx:pipes', resolverClass) || [];
+              const methodPipes = Reflect.getMetadata('calyx:pipes', resolverClass.prototype, fieldRes.propertyKey) || [];
+              const compiledPipes = compileLifecycleItems(moduleClass, [...classPipes, ...methodPipes]);
+
+              targetFields[fieldName].resolve = async (parent: any, args: any, context: any, info: any) => {
+                const req = context?.req;
+                const { CalyxExecutionContext } = await import('../lifecycle/context.ts');
+                const execContext = new CalyxExecutionContext(req, null, resolverClass, resolverInstance[fieldRes.propertyKey]);
+                (execContext as any).type = 'graphql';
+                (execContext as any).data = args;
+
+                const gqlArgs = [parent, args, context, info];
+                execContext.getArgs = () => gqlArgs as any;
+                execContext.getArgByIndex = (index: number) => gqlArgs[index];
+
+                try {
+                  for (const guard of compiledGuards) {
+                    const canActivate = guard.instance.canActivate(execContext);
+                    const resolved = canActivate instanceof Promise ? await canActivate : canActivate;
+                    if (!resolved) {
+                      const { HttpException } = await import('../http/exceptions.ts');
+                      throw new HttpException('Forbidden resource', 403);
+                    }
+                  }
+
+                  let processedArgs = args;
+                  for (const pipe of compiledPipes) {
+                    const transformed = pipe.instance.transform(processedArgs, {
+                      type: 'custom',
+                      metatype: undefined,
+                      data: undefined,
+                    });
+                    processedArgs = transformed instanceof Promise ? await transformed : transformed;
+                  }
+
+                  const executeHandler = async () => {
+                    const argsMetadata: { parameterIndex: number; name: string }[] =
+                      Reflect.getMetadata('calyx:args', resolverInstance, fieldRes.propertyKey) || [];
+                    const params: any[] = [];
+                    const paramTypes = Reflect.getMetadata('design:paramtypes', resolverInstance, fieldRes.propertyKey) || [];
+                    for (const arg of argsMetadata) {
+                      const paramType = paramTypes[arg.parameterIndex] || String;
+                      if (!arg.name && typeof paramType === 'function' && Reflect.hasMetadata('calyx:args_type', paramType)) {
+                        const argInst = new paramType();
+                        const fieldsMetadata = Reflect.getMetadata('calyx:fields', paramType) || [];
+                        for (const f of fieldsMetadata) {
+                          argInst[f.propertyKey] = processedArgs[f.propertyKey];
+                        }
+                        params[arg.parameterIndex] = argInst;
+                      } else {
+                        const argName = arg.name || 'args';
+                        params[arg.parameterIndex] = processedArgs[argName];
+                      }
+                    }
+                    const parentParams = Reflect.getMetadata('calyx:parent', resolverInstance, fieldRes.propertyKey) || [];
+                    for (const idx of parentParams) {
+                      params[idx] = parent;
+                    }
+                    return resolverInstance[fieldRes.propertyKey](...params);
+                  };
+
+                  if (compiledInterceptors.length > 0) {
+                    let interceptorIndex = 0;
+                    const nextHandler = async (): Promise<any> => {
+                      if (interceptorIndex < compiledInterceptors.length) {
+                        const interceptor = compiledInterceptors[interceptorIndex++];
+                        return interceptor.instance.intercept(execContext, { handle: () => nextHandler() });
+                      }
+                      return executeHandler();
+                    };
+                    return await nextHandler();
+                  } else {
+                    return await executeHandler();
+                  }
+                } catch (err: any) {
+                  if (compiledFilters.length > 0) {
+                    for (const filter of compiledFilters) {
+                      const catchException = Reflect.getMetadata('calyx:catch', filter.token) || [];
+                      if (catchException.length === 0 || catchException.some((exc: any) => err instanceof exc)) {
+                        const filterResult = filter.instance.catch(err, execContext);
+                        if (filterResult !== undefined) {
+                          return filterResult;
+                        }
+                      }
+                    }
+                  }
+                  throw err;
                 }
-                return resolverInstance[fieldRes.propertyKey](...params);
               };
             }
           }
@@ -161,6 +497,14 @@ export class GraphQLModule {
             }),
           }
         : {}),
+      ...(Object.keys(subscriptionFields).length > 0
+        ? {
+            subscription: new GraphQLObjectType({
+              name: 'Subscription',
+              fields: subscriptionFields,
+            }),
+          }
+        : {}),
     });
   }
 }