@martel/calyx 1.8.0 → 1.9.0

package/src/file-upload/file-upload.interceptor.ts

@@ -0,0 +1,93 @@
+import { NestInterceptor, ExecutionContext, CallHandler } from '../lifecycle/interfaces.ts';
+import { createParamDecorator } from '../http/decorators.ts';
+import { Injectable } from '../core/decorators.ts';
+
+export interface MulterFile {
+  fieldname: string;
+  originalname: string;
+  encoding: string;
+  mimetype: string;
+  size: number;
+  buffer: Buffer;
+}
+
+@Injectable()
+export class FileInterceptor implements NestInterceptor {
+  constructor(private readonly fieldName: string) {}
+
+  async intercept(context: ExecutionContext, next: CallHandler) {
+    const ctx = context.switchToHttp();
+    const req = ctx.getRequest();
+    const contentType = req.headers.get('content-type') || '';
+
+    if (contentType.includes('multipart/form-data')) {
+      try {
+        const formData = await req.clone().formData();
+        const file = formData.get(this.fieldName);
+        if (file && typeof file !== 'string') {
+          const buffer = Buffer.from(await file.arrayBuffer());
+          (req as any).file = {
+            fieldname: this.fieldName,
+            originalname: file.name,
+            encoding: '7bit',
+            mimetype: file.type,
+            size: file.size,
+            buffer,
+          };
+        }
+      } catch (err) {
+        console.error('FileInterceptor parsing error:', err);
+      }
+    }
+
+    return next.handle();
+  }
+}
+
+@Injectable()
+export class FilesInterceptor implements NestInterceptor {
+  constructor(private readonly fieldName: string) {}
+
+  async intercept(context: ExecutionContext, next: CallHandler) {
+    const ctx = context.switchToHttp();
+    const req = ctx.getRequest();
+    const contentType = req.headers.get('content-type') || '';
+
+    if (contentType.includes('multipart/form-data')) {
+      try {
+        const formData = await req.clone().formData();
+        const files = formData.getAll(this.fieldName);
+        const multerFiles: MulterFile[] = [];
+
+        for (const file of files) {
+          if (file && typeof file !== 'string') {
+            const buffer = Buffer.from(await file.arrayBuffer());
+            multerFiles.push({
+              fieldname: this.fieldName,
+              originalname: file.name,
+              encoding: '7bit',
+              mimetype: file.type,
+              size: file.size,
+              buffer,
+            });
+          }
+        }
+        (req as any).files = multerFiles;
+      } catch {
+        // ignore
+      }
+    }
+
+    return next.handle();
+  }
+}
+
+export const UploadedFile = createParamDecorator((data, ctx) => {
+  const req = ctx.switchToHttp().getRequest();
+  return (req as any).file;
+});
+
+export const UploadedFiles = createParamDecorator((data, ctx) => {
+  const req = ctx.switchToHttp().getRequest();
+  return (req as any).files;
+});

package/src/file-upload/index.ts

@@ -0,0 +1 @@
+export * from './file-upload.interceptor.ts';

package/src/graphql/decorators.ts

@@ -60,3 +60,73 @@ export function Field(typeFunc?: (returns: any) => any, options?: { nullable?: b
     Reflect.defineMetadata('calyx:fields', fields, target.constructor);
   };
 }
+
+export function InputType(options?: { description?: string }): ClassDecorator {
+  return (target) => {
+    Reflect.defineMetadata('calyx:input_type', true, target);
+    if (options?.description) {
+      Reflect.defineMetadata('calyx:description', options.description, target);
+    }
+  };
+}
+
+export function ArgsType(): ClassDecorator {
+  return (target) => {
+    Reflect.defineMetadata('calyx:args_type', true, target);
+  };
+}
+
+export function InterfaceType(options?: { description?: string }): ClassDecorator {
+  return (target) => {
+    Reflect.defineMetadata('calyx:interface_type', true, target);
+    if (options?.description) {
+      Reflect.defineMetadata('calyx:description', options.description, target);
+    }
+  };
+}
+
+export function UnionType(options: { name: string; types: () => any[] }): ClassDecorator {
+  return (target) => {
+    Reflect.defineMetadata('calyx:union_type', options, target);
+  };
+}
+
+export function createUnionType(options: { name: string; types: () => any[]; resolveType?: any }) {
+  return {
+    name: options.name,
+    types: options.types,
+    resolveType: options.resolveType,
+    __isUnion: true,
+  };
+}
+
+export function Subscription(typeFunc?: (returns: any) => any, options?: { name?: string; filter?: any; resolve?: any }): MethodDecorator {
+  return (target, propertyKey) => {
+    const subscriptions = Reflect.getOwnMetadata('calyx:subscriptions', target.constructor) || [];
+    subscriptions.push({ propertyKey, typeFunc, options });
+    Reflect.defineMetadata('calyx:subscriptions', subscriptions, target.constructor);
+  };
+}
+
+export function Scalar(name: string, typeFunc?: any): ClassDecorator {
+  return (target) => {
+    Reflect.defineMetadata('calyx:scalar', { name, typeFunc }, target);
+    Reflect.defineMetadata(METADATA_KEYS.INJECTABLE, true, target);
+  };
+}
+
+export function Directive(sdl: string): ClassDecorator & MethodDecorator & PropertyDecorator {
+  return (target: any, propertyKey?: string | symbol) => {
+    const key = 'calyx:directives';
+    if (propertyKey) {
+      const existing = Reflect.getOwnMetadata(key, target, propertyKey) || [];
+      existing.push(sdl);
+      Reflect.defineMetadata(key, existing, target, propertyKey);
+    } else {
+      const existing = Reflect.getOwnMetadata(key, target) || [];
+      existing.push(sdl);
+      Reflect.defineMetadata(key, existing, target);
+    }
+  };
+}
+

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,33 @@ export class GraphQLModule {
     }
 
     const typeMap = new Map<any, any>();
+    const inputTypeMap = new Map<any, any>();
+
+    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 +62,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 +114,132 @@ 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;
 
-      // 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);
+        const fieldName = fieldMeta.options?.name || String(fieldMeta.propertyKey);
 
-        queryFields[queryName] = {
+        const resolveFn = async (parent: any, args: any, context: any) => {
+          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] = args[f.propertyKey];
+              }
+              params[arg.parameterIndex] = argInst;
+            } else {
+              const argName = arg.name || 'args';
+              params[arg.parameterIndex] = args[argName];
+            }
+          }
+          const parentParams = Reflect.getMetadata('calyx:parent', resolverInstance, fieldMeta.propertyKey) || [];
+          for (const idx of parentParams) {
+            params[idx] = parent;
+          }
+          return resolverInstance[fieldMeta.propertyKey](...params);
+        };
+
+        list[fieldName] = {
           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 parentParams = Reflect.getMetadata('calyx:parent', resolverInstance, query.propertyKey) || [];
-            for (const idx of parentParams) {
-              params[idx] = parent;
-            }
-            return resolverInstance[query.propertyKey](...params);
-          },
+          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);
+        
+        // Wrap with standard GraphQL subscribe / resolve
+        const originalResolve = subscriptionFields[subName].resolve;
+        subscriptionFields[subName].subscribe = originalResolve;
+        subscriptionFields[subName].resolve = (payload: any) => {
+          if (sub.options?.resolve) {
+            return sub.options.resolve(payload);
+          }
+          return payload;
         };
       }
 
@@ -129,8 +259,20 @@ export class GraphQLModule {
                 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) {
-                  params[arg.parameterIndex] = args[arg.name];
+                  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] = args[f.propertyKey];
+                    }
+                    params[arg.parameterIndex] = argInst;
+                  } else {
+                    const argName = arg.name || 'args';
+                    params[arg.parameterIndex] = args[argName];
+                  }
                 }
                 const parentParams = Reflect.getMetadata('calyx:parent', resolverInstance, fieldRes.propertyKey) || [];
                 for (const idx of parentParams) {
@@ -161,6 +303,14 @@ export class GraphQLModule {
             }),
           }
         : {}),
+      ...(Object.keys(subscriptionFields).length > 0
+        ? {
+            subscription: new GraphQLObjectType({
+              name: 'Subscription',
+              fields: subscriptionFields,
+            }),
+          }
+        : {}),
     });
   }
 }