query-2jz/src/adapters/nestjs.ts

Query-2jz: A GraphQL alternative with faster performance and simpler use

import { Injectable, Controller, Get, Post, Param, Body, Query } from '@nestjs/common';
import { Query2jz, Query2jzConfig, Query2jzModel } from '../index';

/**
 * NestJS Adapter for Query2jz
 */
@Injectable()
export class Query2jzNestAdapter {
  private qryn: Query2jz;

  constructor(config: Query2jzConfig, models: Query2jzModel[] = []) {
    this.qryn = new Query2jz(config, models);
  }

  /**
   * Initialize the adapter
   */
  async initialize(): Promise<void> {
    await this.qryn.initialize();
  }

  /**
   * Get Query2jz instance
   */
  getQuery2jz(): Query2jz {
    return this.qryn;
  }
}

/**
 * NestJS Controller for Query2jz
 */
@Controller('api/qryn')
export class Query2jzController {
  constructor(private readonly qrynAdapter: Query2jzNestAdapter) {}

  @Get('health')
  async healthCheck() {
    const stats = this.qrynAdapter.getQuery2jz().getStats();
    return {
      status: 'healthy',
      timestamp: new Date().toISOString(),
      ...stats
    };
  }

  @Get('stats')
  async getStats() {
    return this.qrynAdapter.getQuery2jz().getStats();
  }

  @Get(':model')
  async query(
    @Param('model') model: string,
    @Query('select') select?: string,
    @Query('where') where?: string,
    @Query('orderBy') orderBy?: string,
    @Query('limit') limit?: string,
    @Query('offset') offset?: string,
    @Query('live') live?: string
  ) {
    const query = this.parseQueryParams({
      select,
      where,
      orderBy,
      limit,
      offset,
      live
    });

    return await this.qrynAdapter.getQuery2jz().query(query, model);
  }

  @Post(':model')
  async mutate(
    @Param('model') model: string,
    @Body() mutation: any
  ) {
    if (!mutation.operation) {
      throw new Error('Operation is required');
    }

    return await this.qrynAdapter.getQuery2jz().mutate(mutation, model);
  }

  @Post('generate-types')
  async generateTypes(@Body() body: { outputDir?: string }) {
    this.qrynAdapter.getQuery2jz().generateTypes(body.outputDir);
    return {
      message: 'Types generated successfully',
      outputDir: body.outputDir || './generated'
    };
  }

  private parseQueryParams(queryParams: any): any {
    const query: any = {};

    if (queryParams.select) {
      try {
        query.select = JSON.parse(queryParams.select);
      } catch {
        query.select = {};
      }
    }

    if (queryParams.where) {
      try {
        query.where = JSON.parse(queryParams.where);
      } catch {
        query.where = {};
      }
    }

    if (queryParams.orderBy) {
      try {
        query.orderBy = JSON.parse(queryParams.orderBy);
      } catch {
        query.orderBy = {};
      }
    }

    if (queryParams.limit) {
      query.limit = parseInt(queryParams.limit);
    }

    if (queryParams.offset) {
      query.offset = parseInt(queryParams.offset);
    }

    if (queryParams.live === 'true') {
      query.live = true;
    }

    return query;
  }
}

/**
 * NestJS module factory
 */
export function createQuery2jzModule(config: Query2jzConfig, models: Query2jzModel[] = []) {
  const adapter = new Query2jzNestAdapter(config, models);
  
  return {
    adapter,
    controller: Query2jzController,
    initialize: () => adapter.initialize()
  };
}