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

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

import { QrynConfig, QrynModel } from '../types';
import { QrynExpressAdapter } from './express';
import { QrynNextAdapter } from './nextjs';
import { QrynFastifyAdapter } from './fastify';
import { QrynKoaAdapter } from './koa';
import { QrynHapiAdapter } from './hapi';
import { QrynNestAdapter } from './nestjs';
import { QrynSailsAdapter } from './sails';
import { QrynLoopBackAdapter } from './loopback';
import { QrynAdonisAdapter } from './adonis';
import { QrynStrapiAdapter } from './strapi';

/**
 * Framework Adapter Factory
 * Creates appropriate adapter based on framework detection or explicit choice
 */
export class QrynAdapterFactory {
  /**
   * Create adapter for Express.js
   */
  static createExpressAdapter(config: QrynConfig, models: QrynModel[] = []) {
    return new QrynExpressAdapter(config, models);
  }

  /**
   * Create adapter for Next.js
   */
  static createNextAdapter(config: QrynConfig, models: QrynModel[] = []) {
    return new QrynNextAdapter(config, models);
  }

  /**
   * Create adapter for Fastify
   */
  static createFastifyAdapter(config: QrynConfig, models: QrynModel[] = []) {
    return new QrynFastifyAdapter(config, models);
  }

  /**
   * Create adapter for Koa
   */
  static createKoaAdapter(config: QrynConfig, models: QrynModel[] = []) {
    return new QrynKoaAdapter(config, models);
  }

  /**
   * Create adapter for Hapi
   */
  static createHapiAdapter(config: QrynConfig, models: QrynModel[] = []) {
    return new QrynHapiAdapter(config, models);
  }

  /**
   * Create adapter for NestJS
   */
  static createNestAdapter(config: QrynConfig, models: QrynModel[] = []) {
    return new QrynNestAdapter(config, models);
  }

  /**
   * Create adapter for Sails.js
   */
  static createSailsAdapter(config: QrynConfig, models: QrynModel[] = []) {
    return new QrynSailsAdapter(config, models);
  }

  /**
   * Create adapter for LoopBack
   */
  static createLoopBackAdapter(config: QrynConfig, models: QrynModel[] = []) {
    return new QrynLoopBackAdapter(config, models);
  }

  /**
   * Create adapter for AdonisJS
   */
  static createAdonisAdapter(config: QrynConfig, models: QrynModel[] = []) {
    return new QrynAdonisAdapter(config, models);
  }

  /**
   * Create adapter for Strapi
   */
  static createStrapiAdapter(config: QrynConfig, models: QrynModel[] = []) {
    return new QrynStrapiAdapter(config, models);
  }

  /**
   * Auto-detect framework and create appropriate adapter
   */
  static createAdapter(config: QrynConfig, models: QrynModel[] = [], framework?: string) {
    if (framework) {
      return this.createAdapterByFramework(framework, config, models);
    }

    // Auto-detect framework
    const detectedFramework = this.detectFramework();
    return this.createAdapterByFramework(detectedFramework, config, models);
  }

  /**
   * Create adapter by framework name
   */
  private static createAdapterByFramework(
    framework: string, 
    config: QrynConfig, 
    models: QrynModel[]
  ) {
    switch (framework.toLowerCase()) {
      case 'express':
        return this.createExpressAdapter(config, models);
      case 'nextjs':
      case 'next':
        return this.createNextAdapter(config, models);
      case 'fastify':
        return this.createFastifyAdapter(config, models);
      case 'koa':
        return this.createKoaAdapter(config, models);
      case 'hapi':
        return this.createHapiAdapter(config, models);
      case 'nestjs':
      case 'nest':
        return this.createNestAdapter(config, models);
      case 'sails':
      case 'sailsjs':
        return this.createSailsAdapter(config, models);
      case 'loopback':
        return this.createLoopBackAdapter(config, models);
      case 'adonis':
      case 'adonisjs':
        return this.createAdonisAdapter(config, models);
      case 'strapi':
        return this.createStrapiAdapter(config, models);
      default:
        throw new Error(`Unsupported framework: ${framework}`);
    }
  }

  /**
   * Detect framework from environment
   */
  private static detectFramework(): string {
    // Check for Next.js
    if (typeof process !== 'undefined' && process.env.NEXT_RUNTIME) {
      return 'nextjs';
    }

    // Check for Express
    if (typeof require !== 'undefined') {
      try {
        require('express');
        return 'express';
      } catch {
        // Express not found
      }
    }

    // Check for Fastify
    if (typeof require !== 'undefined') {
      try {
        require('fastify');
        return 'fastify';
      } catch {
        // Fastify not found
      }
    }

    // Check for Koa
    if (typeof require !== 'undefined') {
      try {
        require('koa');
        return 'koa';
      } catch {
        // Koa not found
      }
    }

    // Check for Hapi
    if (typeof require !== 'undefined') {
      try {
        require('@hapi/hapi');
        return 'hapi';
      } catch {
        // Hapi not found
      }
    }

    // Check for NestJS
    if (typeof require !== 'undefined') {
      try {
        require('@nestjs/core');
        return 'nestjs';
      } catch {
        // NestJS not found
      }
    }

    // Default to Express
    return 'express';
  }
}

/**
 * Generic adapter creator function
 */
export function createQrynAdapter(
  config: QrynConfig, 
  models: QrynModel[] = [], 
  framework?: string
) {
  return QrynAdapterFactory.createAdapter(config, models, framework);
}

/**
 * Framework-specific adapter creators
 */
export const createExpressAdapter = QrynAdapterFactory.createExpressAdapter;
export const createNextAdapter = QrynAdapterFactory.createNextAdapter;
export const createFastifyAdapter = QrynAdapterFactory.createFastifyAdapter;
export const createKoaAdapter = QrynAdapterFactory.createKoaAdapter;
export const createHapiAdapter = QrynAdapterFactory.createHapiAdapter;
export const createNestAdapter = QrynAdapterFactory.createNestAdapter;
export const createSailsAdapter = QrynAdapterFactory.createSailsAdapter;
export const createLoopBackAdapter = QrynAdapterFactory.createLoopBackAdapter;
export const createAdonisAdapter = QrynAdapterFactory.createAdonisAdapter;
export const createStrapiAdapter = QrynAdapterFactory.createStrapiAdapter;