navis.js 5.3.2 → 5.4.1

package/src/graphql/schema.js

@@ -0,0 +1,188 @@
+/**
+ * GraphQL Schema Utilities
+ * Lightweight schema definition helpers
+ */
+
+/**
+ * GraphQL Schema Builder
+ */
+class GraphQLSchema {
+  constructor() {
+    this.types = {};
+    this.queries = {};
+    this.mutations = {};
+    this.subscriptions = {};
+  }
+
+  /**
+   * Define a type
+   */
+  type(name, definition) {
+    this.types[name] = definition;
+    return this;
+  }
+
+  /**
+   * Define a query
+   */
+  query(name, definition) {
+    this.queries[name] = definition;
+    return this;
+  }
+
+  /**
+   * Define a mutation
+   */
+  mutation(name, definition) {
+    this.mutations[name] = definition;
+    return this;
+  }
+
+  /**
+   * Build schema string (GraphQL SDL format)
+   */
+  build() {
+    let schema = '';
+
+    // Build type definitions
+    Object.keys(this.types).forEach(name => {
+      schema += this._buildType(name, this.types[name]);
+    });
+
+    // Build Query type
+    if (Object.keys(this.queries).length > 0) {
+      schema += '\ntype Query {\n';
+      Object.keys(this.queries).forEach(name => {
+        schema += `  ${name}${this._buildFieldDefinition(this.queries[name])}\n`;
+      });
+      schema += '}\n';
+    }
+
+    // Build Mutation type
+    if (Object.keys(this.mutations).length > 0) {
+      schema += '\ntype Mutation {\n';
+      Object.keys(this.mutations).forEach(name => {
+        schema += `  ${name}${this._buildFieldDefinition(this.mutations[name])}\n`;
+      });
+      schema += '}\n';
+    }
+
+    return schema;
+  }
+
+  /**
+   * Build type definition
+   * @private
+   */
+  _buildType(name, definition) {
+    if (typeof definition === 'string') {
+      return `type ${name} ${definition}\n`;
+    }
+
+    let typeDef = `type ${name} {\n`;
+    if (typeof definition === 'object') {
+      Object.keys(definition).forEach(field => {
+        typeDef += `  ${field}: ${definition[field]}\n`;
+      });
+    }
+    typeDef += '}\n';
+    return typeDef;
+  }
+
+  /**
+   * Build field definition
+   * @private
+   */
+  _buildFieldDefinition(definition) {
+    if (typeof definition === 'string') {
+      return `: ${definition}`;
+    }
+
+    if (typeof definition === 'object' && definition.type) {
+      let def = '(';
+      if (definition.args && Object.keys(definition.args).length > 0) {
+        const args = Object.keys(definition.args).map(arg => {
+          return `${arg}: ${definition.args[arg]}`;
+        }).join(', ');
+        def += args;
+      }
+      def += `): ${definition.type}`;
+      return def;
+    }
+
+    return ': String';
+  }
+}
+
+/**
+ * Create schema builder
+ */
+function createSchema() {
+  return new GraphQLSchema();
+}
+
+/**
+ * Define GraphQL type
+ */
+function type(name, definition) {
+  const schema = new GraphQLSchema();
+  return schema.type(name, definition);
+}
+
+/**
+ * Common GraphQL scalar types
+ */
+const scalars = {
+  String: 'String',
+  Int: 'Int',
+  Float: 'Float',
+  Boolean: 'Boolean',
+  ID: 'ID',
+};
+
+/**
+ * Common GraphQL type helpers
+ */
+const types = {
+  /**
+   * Create input type definition
+   */
+  input(name, fields) {
+    let input = `input ${name} {\n`;
+    Object.keys(fields).forEach(field => {
+      input += `  ${field}: ${fields[field]}\n`;
+    });
+    input += '}';
+    return input;
+  },
+
+  /**
+   * Create list type
+   */
+  list(type) {
+    return `[${type}]`;
+  },
+
+  /**
+   * Create non-null type
+   */
+  required(type) {
+    return `${type}!`;
+  },
+
+  /**
+   * Create list of non-null items
+   */
+  requiredList(type) {
+    return `[${type}!]`;
+  },
+};
+
+module.exports = {
+  GraphQLSchema,
+  createSchema,
+  type,
+  scalars,
+  types,
+};
+

package/src/index.js

@@ -68,6 +68,17 @@ const WebSocketServer = require('./websocket/websocket-server');
 const { SSEServer, createSSEServer, sse } = require('./sse/server-sent-events');
 const { DatabasePool, createPool } = require('./db/db-pool');
 
+// v5.4: GraphQL Support
+const { GraphQLServer, GraphQLError, createGraphQLServer, graphql } = require('./graphql/graphql-server');
+const { GraphQLSchema, createSchema, type, scalars, types } = require('./graphql/schema');
+const {
+  createResolver,
+  fieldResolver,
+  combineResolvers,
+  createAsyncResolver,
+  createBatchResolver,
+} = require('./graphql/resolver');
+
 module.exports = {
   // Core
   NavisApp,
@@ -151,6 +162,22 @@ module.exports = {
   DatabasePool,
   createPool,
   
+  // v5.4: GraphQL Support
+  GraphQLServer,
+  GraphQLError,
+  createGraphQLServer,
+  graphql,
+  GraphQLSchema,
+  createSchema,
+  type,
+  scalars,
+  types,
+  createResolver,
+  fieldResolver,
+  combineResolvers,
+  createAsyncResolver,
+  createBatchResolver,
+  
   // Utilities
   response: {
     success,

package/types/index.d.ts

@@ -656,6 +656,123 @@ export const DatabasePool: {
   new (options?: DatabasePoolOptions): DatabasePool;
 };
 
+// ============================================
+// GraphQL Types (v5.4)
+// ============================================
+
+export interface GraphQLRequest {
+  query: string;
+  variables?: Record<string, any>;
+  operationName?: string;
+}
+
+export interface GraphQLResponse {
+  data?: any;
+  errors?: GraphQLError[];
+}
+
+export interface GraphQLError {
+  message: string;
+  code?: string;
+  extensions?: Record<string, any>;
+  locations?: Array<{ line: number; column: number }>;
+  path?: Array<string | number>;
+}
+
+export interface GraphQLContext {
+  req: NavisRequest;
+  headers: Record<string, string>;
+  query: Record<string, string>;
+  params: Record<string, string>;
+  [key: string]: any;
+}
+
+export type GraphQLResolver = (
+  variables: Record<string, any>,
+  context: GraphQLContext,
+  fields?: string[]
+) => Promise<any> | any;
+
+export interface GraphQLResolverOptions {
+  validate?: (variables: Record<string, any>) => Promise<{ valid: boolean; errors?: string[] }>;
+  authorize?: (context: GraphQLContext) => Promise<boolean>;
+  cache?: {
+    get: (key: string) => Promise<any>;
+    set: (key: string, value: any, ttl?: number) => Promise<void>;
+    key?: (variables: Record<string, any>, context: GraphQLContext) => string;
+    ttl?: number;
+  };
+  errorHandler?: (error: Error, variables: Record<string, any>, context: GraphQLContext) => Promise<any>;
+}
+
+export interface GraphQLServerOptions {
+  schema?: any;
+  resolvers?: {
+    Query?: Record<string, GraphQLResolver | { resolve: GraphQLResolver }>;
+    Mutation?: Record<string, GraphQLResolver | { resolve: GraphQLResolver }>;
+    [key: string]: any;
+  };
+  context?: (req: NavisRequest) => Promise<Record<string, any>> | Record<string, any>;
+  formatError?: (error: Error) => GraphQLError;
+  introspection?: boolean;
+}
+
+export interface GraphQLHandlerOptions {
+  path?: string;
+  method?: string;
+  enableGET?: boolean;
+}
+
+export interface GraphQLSchema {
+  type(name: string, definition: any): GraphQLSchema;
+  query(name: string, definition: any): GraphQLSchema;
+  mutation(name: string, definition: any): GraphQLSchema;
+  build(): string;
+}
+
+export interface GraphQLTypes {
+  input(name: string, fields: Record<string, string>): string;
+  list(type: string): string;
+  required(type: string): string;
+  requiredList(type: string): string;
+}
+
+export interface GraphQLScalars {
+  String: string;
+  Int: string;
+  Float: string;
+  Boolean: string;
+  ID: string;
+}
+
+export interface GraphQLAsyncResolverOptions {
+  maxRetries?: number;
+  retryDelay?: number;
+  retryCondition?: (error: Error) => boolean;
+}
+
+export interface GraphQLBatchResolverOptions {
+  batchKey?: (variables: Record<string, any>) => string;
+  batchSize?: number;
+  waitTime?: number;
+}
+
+export const GraphQLServer: {
+  new (options?: GraphQLServerOptions): GraphQLServer;
+};
+
+export interface GraphQLServer {
+  handler(options?: GraphQLHandlerOptions): Middleware;
+}
+
+export const GraphQLSchema: {
+  new (): GraphQLSchema;
+};
+
+export const GraphQLError: {
+  new (message: string, code?: string, extensions?: Record<string, any>): Error;
+};
+
 // Functions
 export function retry<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T>;
 export function shouldRetryHttpStatus(statusCode: number): boolean;
@@ -686,6 +803,19 @@ export function gracefulShutdown(server: any, options?: GracefulShutdownOptions)
 export function getPool(): ServiceClientPool;
 export function createLazyInit(initFn: () => Promise<any>, options?: LazyInitOptions): LazyInit;
 export function coldStartTracker(): Middleware;
+export function createGraphQLServer(options?: GraphQLServerOptions): GraphQLServer;
+export function graphql(options?: GraphQLServerOptions): Middleware;
+export function createSchema(): GraphQLSchema;
+export function type(name: string, definition: any): GraphQLSchema;
+export function createResolver<T = any>(resolverFn: GraphQLResolver, options?: GraphQLResolverOptions): GraphQLResolver;
+export function fieldResolver(fieldName: string, resolverFn: GraphQLResolver): Record<string, GraphQLResolver>;
+export function combineResolvers(...resolvers: any[]): any;
+export function createAsyncResolver(resolverFn: GraphQLResolver, options?: GraphQLAsyncResolverOptions): GraphQLResolver;
+export function createBatchResolver(resolverFn: GraphQLResolver, options?: GraphQLBatchResolverOptions): GraphQLResolver;
+
+// GraphQL Constants
+export const scalars: GraphQLScalars;
+export const types: GraphQLTypes;
 
 // Error Classes
 export class ValidationError extends Error {