@martel/calyx 1.6.0 → 1.8.0

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+# [1.8.0](https://github.com/bmartel/calyx/compare/v1.7.0...v1.8.0) (2026-07-01)
+
+
+### Features
+
+* **graphql,openapi:** implement native code-first GraphQLModule and SwaggerModule spec/UI serving ([705c0c0](https://github.com/bmartel/calyx/commit/705c0c0a821cb9e7133d2ad1f1b2103f3aa57572))
+
+# [1.7.0](https://github.com/bmartel/calyx/compare/v1.6.0...v1.7.0) (2026-07-01)
+
+
+### Features
+
+* **cache,validation:** implement SQLite CacheModule, JIT ValidationPipe, and JIT Response Serializer ([1d37b68](https://github.com/bmartel/calyx/commit/1d37b68c2a7ba52e7878810b63f75ee31becc433))
+
 # [1.6.0](https://github.com/bmartel/calyx/compare/v1.5.0...v1.6.0) (2026-07-01)
 
 

package/bun.lock

@@ -5,6 +5,7 @@
     "": {
       "name": "@martel/calyx",
       "dependencies": {
+        "graphql": "^17.0.1",
         "reflect-metadata": "^0.2.2",
       },
       "devDependencies": {
@@ -322,6 +323,8 @@
 
     "graceful-fs": ["graceful-fs@4.2.11", "", {}, "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ=="],
 
+    "graphql": ["graphql@17.0.1", "", {}, "sha512-8eWbg5Zcv/8o20nzEjHUGPTj20MLFJjc5kagbIPxbaeGxvFwpitJhemEC/k17n5+UD4M/9ea5rTuce78mELujQ=="],
+
     "handlebars": ["handlebars@4.7.9", "", { "dependencies": { "minimist": "^1.2.5", "neo-async": "^2.6.2", "source-map": "^0.6.1", "wordwrap": "^1.0.0" }, "optionalDependencies": { "uglify-js": "^3.1.4" }, "bin": { "handlebars": "bin/handlebars" } }, "sha512-4E71E0rpOaQuJR2A3xDZ+GM1HyWYv1clR58tC8emQNeQe3RH7MAzSbat+V0wG78LQBo6m6bzSG/L4pBuCsgnUQ=="],
 
     "has-async-hooks": ["has-async-hooks@1.0.0", "", {}, "sha512-YF0VPGjkxr7AyyQQNykX8zK4PvtEDsUJAPqwu06UFz1lb6EvI53sPh5H1kWxg8NXI5LsfRCZ8uX9NkYDZBb/mw=="],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@martel/calyx",
-  "version": "1.6.0",
+  "version": "1.8.0",
   "description": "High-performance Bun-native NestJS-compatible framework",
   "main": "src/index.ts",
   "bin": {
@@ -12,6 +12,7 @@
     "benchmark": "bun run benchmarks/index.ts"
   },
   "dependencies": {
+    "graphql": "^17.0.1",
     "reflect-metadata": "^0.2.2"
   },
   "devDependencies": {

package/src/cache/cache.interceptor.ts

@@ -0,0 +1,32 @@
+import { NestInterceptor, ExecutionContext, CallHandler } from '../lifecycle/interfaces.ts';
+import { Injectable } from '../core/decorators.ts';
+import { CacheService } from './cache.service.ts';
+
+@Injectable()
+export class CacheInterceptor implements NestInterceptor {
+  constructor(private readonly cacheService: CacheService) {}
+
+  async intercept(context: ExecutionContext, next: CallHandler): Promise<any> {
+    const type = context.getType();
+    if (type !== 'http') {
+      return next.handle();
+    }
+
+    const req = context.switchToHttp().getRequest<Request>();
+    if (req.method !== 'GET') {
+      return next.handle();
+    }
+
+    const url = new URL(req.url);
+    const key = `http_cache::${url.pathname}${url.search}`;
+
+    const cached = await this.cacheService.get(key);
+    if (cached !== undefined) {
+      return cached;
+    }
+
+    const result = await next.handle();
+    await this.cacheService.set(key, result);
+    return result;
+  }
+}

package/src/cache/cache.module.ts

@@ -0,0 +1,31 @@
+import { Module, DynamicModule } from '../core/decorators.ts';
+import { CacheService } from './cache.service.ts';
+import { CacheInterceptor } from './cache.interceptor.ts';
+
+export interface CacheModuleOptions {
+  dbPath?: string;
+  defaultTtl?: number;
+  isGlobal?: boolean;
+}
+
+@Module({
+  providers: [CacheService, CacheInterceptor],
+  exports: [CacheService, CacheInterceptor],
+})
+export class CacheModule {
+  static register(options: CacheModuleOptions = {}): DynamicModule {
+    const cacheServiceInstance = new CacheService(options);
+
+    const cacheServiceProvider = {
+      provide: CacheService,
+      useValue: cacheServiceInstance,
+    };
+
+    return {
+      module: CacheModule,
+      providers: [cacheServiceProvider, CacheInterceptor],
+      exports: [CacheService, CacheInterceptor],
+      global: options.isGlobal ?? false,
+    };
+  }
+}

package/src/cache/cache.service.ts

@@ -0,0 +1,86 @@
+import { Database } from 'bun:sqlite';
+import { Injectable } from '../core/decorators.ts';
+
+@Injectable()
+export class CacheService {
+  private db!: Database;
+  private pruneTimer: any;
+  private readonly dbPath: string;
+  private readonly defaultTtl: number;
+
+  constructor(options: { dbPath?: string; defaultTtl?: number } = {}) {
+    this.dbPath = options.dbPath ?? ':memory:';
+    this.defaultTtl = options.defaultTtl ?? 5;
+  }
+
+  onModuleInit() {
+    this.db = new Database(this.dbPath);
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS cache (
+        key TEXT PRIMARY KEY,
+        value TEXT,
+        expires_at INTEGER
+      )
+    `);
+    this.db.run(`CREATE INDEX IF NOT EXISTS idx_expires_at ON cache (expires_at)`);
+
+    this.pruneTimer = setInterval(() => this.prune(), 30000);
+  }
+
+  onModuleDestroy() {
+    if (this.pruneTimer) {
+      clearInterval(this.pruneTimer);
+    }
+    if (this.db) {
+      this.db.close();
+    }
+  }
+
+  async get<T = any>(key: string): Promise<T | undefined> {
+    const row = this.db.query('SELECT value, expires_at FROM cache WHERE key = $key').get({ $key: key }) as any;
+    if (!row) return undefined;
+
+    if (row.expires_at !== null && row.expires_at < Date.now()) {
+      this.db.query('DELETE FROM cache WHERE key = $key').run({ $key: key });
+      return undefined;
+    }
+
+    try {
+      return JSON.parse(row.value) as T;
+    } catch {
+      return row.value as unknown as T;
+    }
+  }
+
+  async set<T = any>(key: string, value: T, ttl?: number): Promise<void> {
+    const ttlSeconds = ttl !== undefined ? ttl : this.defaultTtl;
+    const expiresAt = ttlSeconds > 0 ? Date.now() + ttlSeconds * 1000 : null;
+    const valStr = JSON.stringify(value);
+
+    this.db.query(`
+      INSERT INTO cache (key, value, expires_at)
+      VALUES ($key, $val, $expiresAt)
+      ON CONFLICT(key) DO UPDATE SET value = $val, expires_at = $expiresAt
+    `).run({
+      $key: key,
+      $val: valStr,
+      $expiresAt: expiresAt,
+    });
+  }
+
+  async del(key: string): Promise<void> {
+    this.db.query('DELETE FROM cache WHERE key = $key').run({ $key: key });
+  }
+
+  async reset(): Promise<void> {
+    this.db.run('DELETE FROM cache');
+  }
+
+  private prune() {
+    try {
+      this.db.query('DELETE FROM cache WHERE expires_at IS NOT NULL AND expires_at < $now').run({ $now: Date.now() });
+    } catch {
+      // ignore
+    }
+  }
+}

package/src/cache/index.ts

@@ -0,0 +1,3 @@
+export * from './cache.service.ts';
+export * from './cache.interceptor.ts';
+export * from './cache.module.ts';

package/src/graphql/decorators.ts

@@ -0,0 +1,62 @@
+import { METADATA_KEYS } from '../core/metadata.ts';
+
+export function Resolver(nameOrClass?: any): ClassDecorator {
+  return (target) => {
+    Reflect.defineMetadata('calyx:resolver', nameOrClass || target, target);
+    Reflect.defineMetadata(METADATA_KEYS.INJECTABLE, true, target);
+  };
+}
+
+export function Query(typeFunc?: (returns: any) => any, options?: { name?: string }): MethodDecorator {
+  return (target, propertyKey) => {
+    const queries = Reflect.getOwnMetadata('calyx:queries', target.constructor) || [];
+    queries.push({ propertyKey, typeFunc, options });
+    Reflect.defineMetadata('calyx:queries', queries, target.constructor);
+  };
+}
+
+export function Mutation(typeFunc?: (returns: any) => any, options?: { name?: string }): MethodDecorator {
+  return (target, propertyKey) => {
+    const mutations = Reflect.getOwnMetadata('calyx:mutations', target.constructor) || [];
+    mutations.push({ propertyKey, typeFunc, options });
+    Reflect.defineMetadata('calyx:mutations', mutations, target.constructor);
+  };
+}
+
+export function ResolveField(typeFunc?: (returns: any) => any, options?: { name?: string }): MethodDecorator {
+  return (target, propertyKey) => {
+    const fields = Reflect.getOwnMetadata('calyx:resolve_fields', target.constructor) || [];
+    fields.push({ propertyKey, typeFunc, options });
+    Reflect.defineMetadata('calyx:resolve_fields', fields, target.constructor);
+  };
+}
+
+export function Args(name?: string): ParameterDecorator {
+  return (target, propertyKey, parameterIndex) => {
+    const args = Reflect.getOwnMetadata('calyx:args', target, propertyKey!) || [];
+    args.push({ parameterIndex, name });
+    Reflect.defineMetadata('calyx:args', args, target, propertyKey!);
+  };
+}
+
+export function Parent(): ParameterDecorator {
+  return (target, propertyKey, parameterIndex) => {
+    const parentParams = Reflect.getOwnMetadata('calyx:parent', target, propertyKey!) || [];
+    parentParams.push(parameterIndex);
+    Reflect.defineMetadata('calyx:parent', parentParams, target, propertyKey!);
+  };
+}
+
+export function ObjectType(): ClassDecorator {
+  return (target) => {
+    Reflect.defineMetadata('calyx:object_type', true, target);
+  };
+}
+
+export function Field(typeFunc?: (returns: any) => any, options?: { nullable?: boolean }): PropertyDecorator {
+  return (target, propertyKey) => {
+    const fields = Reflect.getOwnMetadata('calyx:fields', target.constructor) || [];
+    fields.push({ propertyKey: String(propertyKey), typeFunc, options });
+    Reflect.defineMetadata('calyx:fields', fields, target.constructor);
+  };
+}

package/src/graphql/graphql.module.ts

@@ -0,0 +1,166 @@
+import { CalyxContainer } from '../core/container.ts';
+import { Module } from '../core/decorators.ts';
+import {
+  GraphQLSchema,
+  GraphQLObjectType,
+  GraphQLString,
+  GraphQLInt,
+  GraphQLFloat,
+  GraphQLBoolean,
+  GraphQLList,
+  GraphQLNonNull,
+} from 'graphql';
+
+@Module({})
+export class GraphQLModule {
+  static buildSchema(container: CalyxContainer): GraphQLSchema | null {
+    const instances = container.getProviderAndControllerInstances();
+    const resolverInstances = instances.filter(
+      (inst) => inst && inst.constructor && Reflect.hasMetadata('calyx:resolver', inst.constructor)
+    );
+
+    if (resolverInstances.length === 0) {
+      return null;
+    }
+
+    const typeMap = new Map<any, any>();
+
+    function getGraphQLType(typeClass: any): any {
+      if (typeClass === String) return GraphQLString;
+      if (typeClass === Number) return GraphQLFloat;
+      if (typeClass === Boolean) return GraphQLBoolean;
+      if (typeMap.has(typeClass)) return typeMap.get(typeClass);
+
+      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;
+          },
+        });
+
+        typeMap.set(typeClass, gqlObjectType);
+        return gqlObjectType;
+      }
+
+      return GraphQLString;
+    }
+
+    const queryFields: any = {};
+    const mutationFields: 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;
+        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) || [];
+        const argsConfig: any = {};
+
+        const paramTypes = Reflect.getMetadata('design:paramtypes', resolverInstance, query.propertyKey) || [];
+        for (const arg of argsMetadata) {
+          const paramType = paramTypes[arg.parameterIndex] || String;
+          argsConfig[arg.name] = { type: getGraphQLType(paramType) };
+        }
+
+        const queryName = query.options?.name || String(query.propertyKey);
+
+        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 parentParams = Reflect.getMetadata('calyx:parent', resolverInstance, query.propertyKey) || [];
+            for (const idx of parentParams) {
+              params[idx] = parent;
+            }
+            return resolverInstance[query.propertyKey](...params);
+          },
+        };
+      }
+
+      // Resolve fields mapping
+      const resolvedType = Reflect.getMetadata('calyx:resolver', resolverClass);
+      const fieldResolvers: { propertyKey: string | symbol; typeFunc?: any; options?: any }[] =
+        Reflect.getMetadata('calyx:resolve_fields', resolverClass) || [];
+
+      if (resolvedType && fieldResolvers.length > 0) {
+        const targetGqlType = getGraphQLType(resolvedType);
+        if (targetGqlType && typeof targetGqlType.getFields === 'function') {
+          const targetFields = targetGqlType.getFields();
+          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;
+                }
+                return resolverInstance[fieldRes.propertyKey](...params);
+              };
+            }
+          }
+        }
+      }
+    }
+
+    if (Object.keys(queryFields).length === 0) {
+      return null;
+    }
+
+    return new GraphQLSchema({
+      query: new GraphQLObjectType({
+        name: 'Query',
+        fields: queryFields,
+      }),
+      ...(Object.keys(mutationFields).length > 0
+        ? {
+            mutation: new GraphQLObjectType({
+              name: 'Mutation',
+              fields: mutationFields,
+            }),
+          }
+        : {}),
+    });
+  }
+}

package/src/graphql/index.ts

@@ -0,0 +1,2 @@
+export * from './decorators.ts';
+export * from './graphql.module.ts';

package/src/http/application.ts

@@ -10,6 +10,7 @@ import { EventEmitter } from '../event-emitter/event-emitter.ts';
 import { cors, CorsOptions } from '../security/cors.middleware.ts';
 import { helmet, HelmetOptions } from '../security/helmet.middleware.ts';
 import { CronMatcher } from '../schedule/cron.matcher.ts';
+import { SerializationCompiler } from '../validation/compiler.ts';
 
 class ObjectPool<T> {
   private pool: T[] = [];
@@ -102,6 +103,8 @@ export class CalyxApplication {
   private sharedWebSockets: any[] = [];
   private hasWebSockets = false;
   private serverPort = 3000;
+  private graphqlSchema: any = null;
+  private isInitialized = false;
 
   use(...middlewares: any[]) {
     this.globalMiddlewares.push(...middlewares);
@@ -137,6 +140,9 @@ export class CalyxApplication {
   constructor(private rootModule: any) {}
 
   async init() {
+    if (this.isInitialized) return;
+    this.isInitialized = true;
+
     // Bootstrap the dependency injection container
     this.container.bootstrap(this.rootModule);
 
@@ -160,9 +166,18 @@ export class CalyxApplication {
 
     // Call OnApplicationBootstrap hooks
     await this.runOnApplicationBootstrap();
+
+    // Build GraphQL Schema if GraphQLModule is loaded
+    try {
+      const { GraphQLModule } = await import('../graphql/graphql.module.ts');
+      this.graphqlSchema = GraphQLModule.buildSchema(this.container);
+    } catch {
+      // ignore
+    }
   }
 
   private buildRoutes() {
+    this.router.clear();
     const modules = this.container.getModules();
     for (const [moduleClass, record] of modules.entries()) {
       for (const controllerClass of record.controllers) {
@@ -397,6 +412,10 @@ export class CalyxApplication {
         pathname = pathname.substring(0, queryIdx);
       }
 
+      if (this.graphqlSchema && pathname === '/graphql' && req.method === 'POST') {
+        return this.handleGraphQLRequest(req);
+      }
+
       const matched = this.router.match(req.method, pathname);
       if (!matched) {
         if (this.globalMiddlewares.length > 0) {
@@ -888,6 +907,15 @@ export class CalyxApplication {
 
     if (typeof result === 'object') {
       responseHeaders['content-type'] = 'application/json';
+      const constructor = result.constructor;
+      if (constructor) {
+        const hasRules = Reflect.hasMetadata('calyx:validation_rules', constructor);
+        const hasExpose = Reflect.hasMetadata('calyx:expose_properties', constructor);
+        if (hasRules || hasExpose) {
+          const serialize = SerializationCompiler.compile(constructor);
+          return new Response(serialize(result), { status, headers: responseHeaders });
+        }
+      }
       return new Response(JSON.stringify(result), { status, headers: responseHeaders });
     }
 
@@ -933,8 +961,36 @@ export class CalyxApplication {
     );
   }
 
+  private async handleGraphQLRequest(req: Request): Promise<Response> {
+    try {
+      const body = await req.json() as any;
+      const { query, variables } = body;
+
+      const { graphql } = await import('graphql');
+      const result = await graphql({
+        schema: this.graphqlSchema,
+        source: query,
+        variableValues: variables,
+      });
+
+      return new Response(JSON.stringify(result), {
+        status: 200,
+        headers: { 'content-type': 'application/json' },
+      });
+    } catch (err: any) {
+      return new Response(
+        JSON.stringify({ errors: [{ message: err.message }] }),
+        {
+          status: 200,
+          headers: { 'content-type': 'application/json' },
+        }
+      );
+    }
+  }
+
   async listen(port: number): Promise<any> {
     this.serverPort = port;
+    this.buildRoutes();
     await this.init();
 
     const fetchHandler = (req: Request, server: any) => {
@@ -1320,6 +1376,10 @@ export class CalyxApplication {
       // ignore non-json
     }
   }
+
+  getRoutes() {
+    return this.router.getRoutes();
+  }
 }
 
 

package/src/http/factory.ts

@@ -5,6 +5,7 @@ import { MicroserviceOptions } from '../microservices/interfaces.ts';
 export class CalyxFactory {
   static async create(rootModule: any): Promise<CalyxApplication> {
     const app = new CalyxApplication(rootModule);
+    await app.init();
     return app;
   }
 

package/src/http/router.ts

@@ -16,8 +16,21 @@ export class RadixRouter<T> {
   private staticRoutes = new Map<string, T>();
   private handlersArray: T[] = [];
   private compiledMatch: ((method: string, path: string) => RouteMatch<T> | null) | null = null;
+  private routesList: { method: string; path: string; handler: T }[] = [];
+
+  getRoutes() {
+    return this.routesList;
+  }
+
+  clear() {
+    this.root = new RouterNode<T>();
+    this.staticRoutes.clear();
+    this.routesList = [];
+    this.compiledMatch = null;
+  }
 
   insert(method: string, path: string, handler: T) {
+    this.routesList.push({ method, path, handler });
     const hasParams = path.includes(':') || path.includes('*');
     if (!hasParams) {
       this.staticRoutes.set(method.toUpperCase() + ' ' + path, handler);

package/src/index.ts

@@ -8,3 +8,6 @@ export * from './security/index.ts';
 export * from './schedule/index.ts';
 export * from './websockets/index.ts';
 export * from './microservices/index.ts';
+export * from './cache/index.ts';
+export * from './validation/index.ts';
+export * from './openapi/index.ts';

package/src/openapi/decorators.ts

@@ -0,0 +1,49 @@
+import 'reflect-metadata';
+
+export function ApiTags(...tags: string[]): ClassDecorator & MethodDecorator {
+  return (target: any, propertyKey?: string | symbol) => {
+    const key = 'calyx:api_tags';
+    if (propertyKey) {
+      Reflect.defineMetadata(key, tags, target, propertyKey);
+    } else {
+      Reflect.defineMetadata(key, tags, target);
+    }
+  };
+}
+
+export function ApiOperation(options: { summary?: string; description?: string }): MethodDecorator {
+  return (target, propertyKey) => {
+    Reflect.defineMetadata('calyx:api_operation', options, target, propertyKey);
+  };
+}
+
+export function ApiResponse(options: {
+  status: number;
+  description: string;
+  type?: any;
+}): MethodDecorator & ClassDecorator {
+  return (target: any, propertyKey?: string | symbol) => {
+    const key = 'calyx:api_responses';
+    if (propertyKey) {
+      const existing = Reflect.getOwnMetadata(key, target, propertyKey) || [];
+      existing.push(options);
+      Reflect.defineMetadata(key, existing, target, propertyKey);
+    } else {
+      const existing = Reflect.getOwnMetadata(key, target) || [];
+      existing.push(options);
+      Reflect.defineMetadata(key, existing, target);
+    }
+  };
+}
+
+export function ApiProperty(options: {
+  description?: string;
+  type?: any;
+  required?: boolean;
+} = {}): PropertyDecorator {
+  return (target, propertyKey) => {
+    const properties = Reflect.getOwnMetadata('calyx:api_properties', target.constructor) || [];
+    properties.push({ propertyKey: String(propertyKey), ...options });
+    Reflect.defineMetadata('calyx:api_properties', properties, target.constructor);
+  };
+}

package/src/openapi/index.ts

@@ -0,0 +1,2 @@
+export * from './decorators.ts';
+export * from './swagger.module.ts';