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

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

import { Query2jz, Query2jzConfig, Query2jzModel } from '../index';

/**
 * AdonisJS Adapter for Query2jz
 */
export class Query2jzAdonisAdapter {
  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;
  }

  /**
   * Register AdonisJS routes
   */
  registerRoutes(Route: any): void {
    // Health check
    Route.get('/health', 'Query2jzController.health');

    // Query endpoint
    Route.get('/api/qryn/:model', 'Query2jzController.query');

    // Mutation endpoint
    Route.post('/api/qryn/:model', 'Query2jzController.mutate');

    // Statistics endpoint
    Route.get('/api/qryn/stats', 'Query2jzController.stats');

    // Type generation endpoint
    Route.post('/api/qryn/generate-types', 'Query2jzController.generateTypes');
  }
}

/**
 * AdonisJS controller
 */
export class Query2jzController {
  private qrynAdapter: Query2jzAdonisAdapter;

  constructor(qrynAdapter: Query2jzAdonisAdapter) {
    this.qrynAdapter = qrynAdapter;
  }

  async health({ response }: any): Promise<void> {
    try {
      const stats = this.qrynAdapter.getQuery2jz().getStats();
      response.json({
        status: 'healthy',
        timestamp: new Date().toISOString(),
        ...stats
      });
    } catch (error) {
      response.status(500).json({
        status: 'unhealthy',
        error: error instanceof Error ? error.message : 'Unknown error'
      });
    }
  }

  async query({ params, request, response }: any): Promise<void> {
    try {
      const model = params.model;
      const query = this.parseQueryParams(request.qs());

      const result = await this.qrynAdapter.getQuery2jz().query(query, model);

      if (result.meta?.etag) {
        response.header('ETag', result.meta.etag);
      }
      if (result.meta?.lastModified) {
        response.header('Last-Modified', result.meta.lastModified);
      }

      response.header('Cache-Control', 'public, max-age=300');
      response.json(result);
    } catch (error) {
      response.status(500).json({
        error: 'Query execution failed',
        message: error instanceof Error ? error.message : 'Unknown error'
      });
    }
  }

  async mutate({ params, request, response }: any): Promise<void> {
    try {
      const model = params.model;
      const mutation = request.body();

      if (!mutation.operation) {
        response.status(400).json({
          error: 'Invalid mutation',
          message: 'Operation is required'
        });
        return;
      }

      const result = await this.qrynAdapter.getQuery2jz().mutate(mutation, model);

      response.header('Cache-Control', 'no-cache');
      response.json(result);
    } catch (error) {
      response.status(500).json({
        error: 'Mutation execution failed',
        message: error instanceof Error ? error.message : 'Unknown error'
      });
    }
  }

  async stats({ response }: any): Promise<void> {
    try {
      const stats = this.qrynAdapter.getQuery2jz().getStats();
      response.json(stats);
    } catch (error) {
      response.status(500).json({
        error: 'Failed to get statistics',
        message: error instanceof Error ? error.message : 'Unknown error'
      });
    }
  }

  async generateTypes({ request, response }: any): Promise<void> {
    try {
      const { outputDir } = request.body();
      this.qrynAdapter.getQuery2jz().generateTypes(outputDir);
      
      response.json({
        message: 'Types generated successfully',
        outputDir: outputDir || './generated'
      });
    } catch (error) {
      response.status(500).json({
        error: 'Type generation failed',
        message: error instanceof Error ? error.message : 'Unknown error'
      });
    }
  }

  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;
  }
}

/**
 * AdonisJS plugin factory
 */
export function createQuery2jzPlugin(config: Query2jzConfig, models: Query2jzModel[] = []) {
  const adapter = new Query2jzAdonisAdapter(config, models);
  
  return {
    adapter,
    controller: Query2jzController,
    registerRoutes: adapter.registerRoutes.bind(adapter),
    initialize: () => adapter.initialize()
  };
}