@martel/calyx 1.9.0 → 1.10.1

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [1.10.1](https://github.com/bmartel/calyx/compare/v1.10.0...v1.10.1) (2026-07-01)
+
+
+### Performance Improvements
+
+* **graphql,openapi:** implement query AST caching and swagger response caching ([8310045](https://github.com/bmartel/calyx/commit/8310045265512553214a0a4040bc02d5085c77fa))
+
+# [1.10.0](https://github.com/bmartel/calyx/compare/v1.9.0...v1.10.0) (2026-07-01)
+
+
+### Features
+
+* **graphql:** integrate context-aware enhancers pipeline and native ws subscriptions ([24e86f2](https://github.com/bmartel/calyx/commit/24e86f2c180a1b3b179e2acb9a198f514b204f82))
+
 # [1.9.0](https://github.com/bmartel/calyx/compare/v1.8.0...v1.9.0) (2026-07-01)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@martel/calyx",
-  "version": "1.9.0",
+  "version": "1.10.1",
   "description": "High-performance Bun-native NestJS-compatible framework",
   "main": "src/index.ts",
   "bin": {

package/src/graphql/graphql.module.ts

@@ -30,6 +30,39 @@ 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) || [];
@@ -139,6 +172,7 @@ export class GraphQLModule {
 
     for (const resolverInstance of resolverInstances) {
       const resolverClass = resolverInstance.constructor;
+      const moduleClass = findModuleClass(resolverClass);
 
       // Compile helper for queries, mutations, subscriptions
       const compileField = (fieldMeta: { propertyKey: string | symbol; typeFunc?: any; options?: any }, list: any) => {
@@ -177,29 +211,110 @@ export class GraphQLModule {
           }
         }
 
+        // 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]);
+
+        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) => {
-          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];
+        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);
               }
-              params[arg.parameterIndex] = argInst;
+            }
+
+            // 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 {
-              const argName = arg.name || 'args';
-              params[arg.parameterIndex] = args[argName];
+              return await executeHandler();
             }
+          } 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;
+                  }
+                }
+              }
+            }
+            throw err;
           }
-          const parentParams = Reflect.getMetadata('calyx:parent', resolverInstance, fieldMeta.propertyKey) || [];
-          for (const idx of parentParams) {
-            params[idx] = parent;
-          }
-          return resolverInstance[fieldMeta.propertyKey](...params);
         };
 
         list[fieldName] = {
@@ -232,13 +347,15 @@ export class GraphQLModule {
         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);
           }
+          if (payload && typeof payload === 'object' && subName in payload) {
+            return payload[subName];
+          }
           return payload;
         };
       }
@@ -255,30 +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[] = [];
-                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] = args[f.propertyKey];
+              // 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);
                     }
-                    params[arg.parameterIndex] = argInst;
+                  }
+
+                  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 {
-                    const argName = arg.name || 'args';
-                    params[arg.parameterIndex] = args[argName];
+                    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;
                 }
-                const parentParams = Reflect.getMetadata('calyx:parent', resolverInstance, fieldRes.propertyKey) || [];
-                for (const idx of parentParams) {
-                  params[idx] = parent;
-                }
-                return resolverInstance[fieldRes.propertyKey](...params);
               };
             }
           }

package/src/http/application.ts

@@ -119,6 +119,7 @@ export class CalyxApplication {
   private hasWebSockets = false;
   private serverPort = 3000;
   private graphqlSchema: any = null;
+  private graphqlQueryCache = new Map<string, any>();
   private isInitialized = false;
   private versioningOptions?: VersioningOptions;
 
@@ -1215,10 +1216,25 @@ export class CalyxApplication {
       const body = await req.json() as any;
       const { query, variables } = body;
 
-      const { graphql } = await import('graphql');
-      const result = await graphql({
+      const { parse, validate, execute } = await import('graphql');
+      
+      let document = this.graphqlQueryCache.get(query);
+      if (!document) {
+        document = parse(query);
+        const errors = validate(this.graphqlSchema, document);
+        if (errors.length > 0) {
+          return new Response(JSON.stringify({ errors }), {
+            status: 200,
+            headers: { 'content-type': 'application/json' },
+          });
+        }
+        this.graphqlQueryCache.set(query, document);
+      }
+
+      const result = await execute({
         schema: this.graphqlSchema,
-        source: query,
+        document,
+        contextValue: { req },
         variableValues: variables,
       });
 
@@ -1242,10 +1258,20 @@ export class CalyxApplication {
     this.buildRoutes();
     await this.init();
 
+    if (this.graphqlSchema) {
+      this.hasWebSockets = true;
+    }
+
     const fetchHandler = (req: Request, server: any) => {
-      if (this.hasWebSockets && req.headers.get('upgrade') === 'websocket') {
-        const success = server.upgrade(req);
-        if (success) return undefined;
+      const url = new URL(req.url);
+      if (req.headers.get('upgrade') === 'websocket') {
+        if (url.pathname === '/graphql' && this.graphqlSchema) {
+          const success = server.upgrade(req, { data: { isGraphQL: true, req } });
+          if (success) return undefined;
+        } else if (this.hasWebSockets) {
+          const success = server.upgrade(req);
+          if (success) return undefined;
+        }
       }
       return this.handleRequest(req);
     };
@@ -1258,16 +1284,34 @@ export class CalyxApplication {
     if (this.hasWebSockets) {
       serveOptions.websocket = {
         open: (ws: any) => {
+          if (ws.data?.isGraphQL) {
+            ws.data.subscriptions = new Map();
+            return;
+          }
           for (const gateway of this.sharedWebSockets) {
             this.dispatchWsConnection(gateway, ws);
           }
         },
-        message: (ws: any, message: any) => {
+        message: async (ws: any, message: any) => {
+          if (ws.data?.isGraphQL) {
+            await this.handleGraphQLWsMessage(ws, message);
+            return;
+          }
           for (const gateway of this.sharedWebSockets) {
             this.dispatchWsMessage(gateway, ws, message);
           }
         },
         close: (ws: any) => {
+          if (ws.data?.isGraphQL) {
+            if (ws.data.subscriptions) {
+              for (const sub of ws.data.subscriptions.values()) {
+                if (typeof sub.return === 'function') {
+                  sub.return();
+                }
+              }
+            }
+            return;
+          }
           for (const gateway of this.sharedWebSockets) {
             this.dispatchWsDisconnect(gateway, ws);
           }
@@ -1279,6 +1323,88 @@ export class CalyxApplication {
     return this.server;
   }
 
+  private async handleGraphQLWsMessage(ws: any, message: any) {
+    try {
+      const data = JSON.parse(typeof message === 'string' ? message : message.toString());
+      
+      switch (data.type) {
+        case 'connection_init': {
+          ws.send(JSON.stringify({ type: 'connection_ack' }));
+          break;
+        }
+        case 'subscribe': {
+          const { id, payload } = data;
+          const { query, variables } = payload;
+          
+          const { subscribe, parse, validate } = await import('graphql');
+          
+          let document = this.graphqlQueryCache.get(query);
+          if (!document) {
+            document = parse(query);
+            const errors = validate(this.graphqlSchema, document);
+            if (errors.length > 0) {
+              ws.send(JSON.stringify({ type: 'error', id, payload: errors }));
+              break;
+            }
+            this.graphqlQueryCache.set(query, document);
+          }
+
+          const subResult = await subscribe({
+            schema: this.graphqlSchema,
+            document,
+            variableValues: variables,
+            contextValue: { req: ws.data?.req },
+          });
+          
+          if (subResult && Symbol.asyncIterator in subResult) {
+            ws.data.subscriptions.set(id, subResult);
+            (async () => {
+              try {
+                for await (const val of subResult) {
+                  ws.send(JSON.stringify({
+                    type: 'next',
+                    id,
+                    payload: val,
+                  }));
+                }
+                ws.send(JSON.stringify({
+                  type: 'complete',
+                  id,
+                }));
+              } catch (err: any) {
+                ws.send(JSON.stringify({
+                  type: 'error',
+                  id,
+                  payload: [{ message: err.message }],
+                }));
+              }
+            })();
+          } else {
+            ws.send(JSON.stringify({
+              type: 'error',
+              id,
+              payload: subResult.errors || [{ message: 'GraphQL validation failed' }],
+            }));
+          }
+          break;
+        }
+        case 'complete': {
+          const { id } = data;
+          const sub = ws.data.subscriptions.get(id);
+          if (sub) {
+            if (typeof sub.return === 'function') {
+              sub.return();
+            }
+            ws.data.subscriptions.delete(id);
+          }
+          break;
+        }
+      }
+    } catch (err: any) {
+      console.error('GraphQL WS error:', err);
+    }
+  }
+
   private cleanupListeners: (() => void)[] = [];
 
   enableShutdownHooks(signals: string[] = ['SIGTERM', 'SIGINT']) {

package/src/openapi/swagger.module.ts

@@ -271,12 +271,14 @@ export class SwaggerModule {
     const jsonPath = `/${path}-json`.replace(/\/\/+/g, '/');
     const uiPath = `/${path}`.replace(/\/\/+/g, '/');
 
+    const jsonString = JSON.stringify(document);
+
     app.use((req: any, res: any, next: any) => {
       const url = new URL(req.url);
       if (url.pathname === jsonPath && req.method === 'GET') {
         res.status(200);
         res.set('content-type', 'application/json');
-        res.send(JSON.stringify(document));
+        res.send(jsonString);
         return;
       }
       next();

package/tests/graphql.test.ts

@@ -1,9 +1,19 @@
 import { describe, test, expect, beforeAll, afterAll } from 'bun:test';
-import { Module, CalyxFactory } from '../src/index.ts';
+import {
+  Module,
+  CalyxFactory,
+  UseGuards,
+  UseInterceptors,
+  CanActivate,
+  NestInterceptor,
+  CallHandler,
+  ExecutionContext,
+} from '../src/index.ts';
 import {
   Resolver,
   Query,
   Mutation,
+  Subscription,
   ResolveField,
   Args,
   Parent,
@@ -14,7 +24,7 @@ import {
   GraphQLModule,
 } from '../src/graphql/index.ts';
 
-// 1. GraphQL Object Type DTOs
+// 1. DTOs
 @ObjectType()
 class Author {
   @Field()
@@ -36,7 +46,6 @@ class PostGql {
   author!: Author;
 }
 
-// 2. GraphQL Input Type DTO
 @InputType()
 class CreatePostInput {
   @Field()
@@ -46,14 +55,33 @@ class CreatePostInput {
   authorId!: number;
 }
 
-// 3. GraphQL Args Type DTO (Flattened Args)
 @ArgsType()
 class GetPostArgs {
   @Field()
   id!: number;
 }
 
-// 4. Resolver Class
+// 2. Enhancers (Guard & Interceptor)
+class GqlGuard implements CanActivate {
+  canActivate(context: ExecutionContext): boolean {
+    const gqlContext = context.getArgByIndex(2);
+    const req = gqlContext?.req;
+    const auth = req?.headers?.get('Authorization');
+    return auth === 'allow';
+  }
+}
+
+class GqlInterceptor implements NestInterceptor {
+  async intercept(context: ExecutionContext, next: CallHandler): Promise<any> {
+    const res = await next.handle();
+    if (res && typeof res === 'object') {
+      return { ...res, title: res.title + ' [intercepted]' };
+    }
+    return res;
+  }
+}
+
+// 3. Resolver Class
 @Resolver(PostGql)
 class PostResolver {
   @Query(() => PostGql)
@@ -61,7 +89,18 @@ class PostResolver {
     return {
       id: args.id,
       title: `Calyx: GraphQL JIT Performance`,
-      authorId: 456, // to be resolved by ResolveField
+      authorId: 456,
+    };
+  }
+
+  @Query(() => PostGql)
+  @UseGuards(GqlGuard)
+  @UseInterceptors(GqlInterceptor)
+  getPostSecured(@Args() args: GetPostArgs) {
+    return {
+      id: args.id,
+      title: `Calyx Secure`,
+      authorId: 111,
     };
   }
 
@@ -74,6 +113,32 @@ class PostResolver {
     };
   }
 
+  @Subscription(() => PostGql)
+  postAdded() {
+    return {
+      [Symbol.asyncIterator]() {
+        let index = 0;
+        return {
+          async next() {
+            if (index < 1) {
+              index++;
+              return {
+                value: {
+                  postAdded: {
+                    id: 777,
+                    title: 'New Post Added',
+                  },
+                },
+                done: false,
+              };
+            }
+            return { value: undefined, done: true };
+          },
+        };
+      },
+    };
+  }
+
   @ResolveField(() => Author)
   author(@Parent() post: any) {
     return {
@@ -173,4 +238,114 @@ describe('Native Code-First GraphQL Module', () => {
       },
     });
   });
+
+  test('should run Guards and deny access if guard denies', async () => {
+    const res = await fetch(`${baseUrl}/graphql`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({
+        query: `
+          query {
+            getPostSecured(id: 456) {
+              id
+              title
+            }
+          }
+        `,
+      }),
+    });
+
+    expect(res.status).toBe(200);
+    const body = await res.json();
+    expect(body.errors).toBeDefined();
+    expect(body.errors[0].message).toContain('Forbidden resource');
+  });
+
+  test('should run Guards and Interceptors successfully if guard approves', async () => {
+    const res = await fetch(`${baseUrl}/graphql`, {
+      method: 'POST',
+      headers: {
+        'content-type': 'application/json',
+        'Authorization': 'allow',
+      },
+      body: JSON.stringify({
+        query: `
+          query {
+            getPostSecured(id: 456) {
+              id
+              title
+            }
+          }
+        `,
+      }),
+    });
+
+    expect(res.status).toBe(200);
+    const body = await res.json();
+    expect(body.errors).toBeUndefined();
+    expect(body.data.getPostSecured).toEqual({
+      id: 456,
+      title: 'Calyx Secure [intercepted]',
+    });
+  });
+
+  test('should execute subscription over WebSocket using graphql-ws protocol', async () => {
+    const ws = new WebSocket(`ws://localhost:${PORT}/graphql`);
+    const messages: any[] = [];
+    ws.onmessage = (event) => {
+      messages.push(JSON.parse(event.data));
+    };
+
+    await new Promise((resolve) => {
+      ws.onopen = resolve;
+    });
+
+    // Send connection_init
+    ws.send(JSON.stringify({ type: 'connection_init' }));
+
+    // Wait for connection_ack
+    await new Promise((resolve) => {
+      const check = setInterval(() => {
+        if (messages.some((m) => m.type === 'connection_ack')) {
+          clearInterval(check);
+          resolve(null);
+        }
+      }, 5);
+    });
+
+    // Send subscribe
+    ws.send(JSON.stringify({
+      type: 'subscribe',
+      id: '1',
+      payload: {
+        query: `
+          subscription {
+            postAdded {
+              id
+              title
+            }
+          }
+        `,
+      },
+    }));
+
+    // Wait for next message
+    await new Promise((resolve) => {
+      const check = setInterval(() => {
+        if (messages.some((m) => m.type === 'next' && m.id === '1')) {
+          clearInterval(check);
+          resolve(null);
+        }
+      }, 5);
+    });
+
+    const nextMsg = messages.find((m) => m.type === 'next' && m.id === '1');
+    expect(nextMsg).toBeDefined();
+    expect(nextMsg.payload.data.postAdded).toEqual({
+      id: 777,
+      title: 'New Post Added',
+    });
+
+    ws.close();
+  });
 });