navis.js 5.4.0 → 5.5.0

package/README.md

@@ -171,20 +171,25 @@ navis metrics
 
 - ✅ **WebSocket support** - Real-time bidirectional communication
 - ✅ **Server-Sent Events** - One-way real-time streaming
-- ✅ **Database integration** - Connection pooling for PostgreSQL, MySQL, MongoDB
+- ✅ **Database integration** - Connection pooling for PostgreSQL, MySQL, MongoDB, SQLite, SQL Server
 
 ### v5.3 ✅
 - ✅ **TypeScript support** - Full type definitions for all features
 - ✅ **Type-safe API** - Complete IntelliSense and type checking
 - ✅ **TypeScript examples** - Ready-to-use TypeScript examples
 
-### v5.4 (Current)
+### v5.4 ✅
 - ✅ **GraphQL support** - Lightweight GraphQL server implementation
 - ✅ **GraphQL queries & mutations** - Full query and mutation support
 - ✅ **GraphQL resolvers** - Flexible resolver system with utilities
 - ✅ **GraphQL schema builder** - Schema definition helpers
 - ✅ **GraphQL middleware** - Easy integration with Navis.js routes
 
+### v5.5 (Current)
+- ✅ **Extended database adapters** - SQLite and SQL Server support
+- ✅ **Enhanced database pool** - Support for 5 database types (PostgreSQL, MySQL, MongoDB, SQLite, SQL Server)
+- ✅ **Improved connection handling** - Better error handling and connection management
+
 ## API Reference
 
 ### NavisApp
@@ -437,6 +442,7 @@ exports.handler = async (event, context) => {
 
 ### GraphQL Support (v5.4)
 
+**JavaScript Example:**
 ```javascript
 const { NavisApp, graphql, createResolver } = require('navis.js');
 
@@ -478,6 +484,56 @@ app.use(graphql({
 app.listen(3000);
 ```
 
+**TypeScript Example:**
+```typescript
+import {
+  NavisApp,
+  graphql,
+  createResolver,
+  GraphQLContext,
+} from 'navis.js';
+
+interface User {
+  id: string;
+  name: string;
+  email: string;
+}
+
+const app = new NavisApp();
+
+// Define resolvers with TypeScript types
+const resolvers = {
+  Query: {
+    users: createResolver<User[]>(async (variables, context: GraphQLContext) => {
+      return [{ id: '1', name: 'Alice', email: 'alice@example.com' }];
+    }),
+
+    user: createResolver<User | null>(async (variables, context: GraphQLContext) => {
+      const { id } = variables as { id: string };
+      return { id, name: 'Alice', email: 'alice@example.com' };
+    }),
+  },
+
+  Mutation: {
+    createUser: createResolver<User>(async (variables, context: GraphQLContext) => {
+      const { name, email } = variables as { name: string; email: string };
+      return { id: '3', name, email };
+    }),
+  },
+};
+
+// Add GraphQL middleware
+app.use(graphql({
+  path: '/graphql',
+  resolvers,
+  context: (req) => ({
+    userId: (req.headers['x-user-id'] as string) || null,
+  }),
+}));
+
+app.listen(3000);
+```
+
 **GraphQL Query Example:**
 ```bash
 curl -X POST http://localhost:3000/graphql \
@@ -494,6 +550,73 @@ curl -X POST http://localhost:3000/graphql \
 
 See `examples/graphql-demo.js` for a complete GraphQL example.
 
+### Extended Database Adapters (v5.5)
+
+**JavaScript Example:**
+```javascript
+const { NavisApp, createPool, response } = require('navis.js');
+
+const app = new NavisApp();
+
+// SQLite Database
+app.get('/sqlite/users', async (req, res) => {
+  const db = createPool({
+    type: 'sqlite',
+    connectionString: ':memory:', // or path to .db file
+  });
+  
+  await db.connect();
+  const users = await db.query('SELECT * FROM users');
+  await db.close();
+  
+  response.success(res, { users });
+});
+
+// SQL Server Database
+app.get('/sqlserver/users', async (req, res) => {
+  const db = createPool({
+    type: 'mssql',
+    connectionString: 'Server=localhost;Database=testdb;User Id=sa;Password=pass',
+  });
+  
+  await db.connect();
+  const users = await db.query('SELECT TOP 10 * FROM users');
+  await db.close();
+  
+  response.success(res, { users });
+});
+```
+
+**TypeScript Example:**
+```typescript
+import { NavisApp, createPool, response, DatabasePool } from 'navis.js';
+
+const app = new NavisApp();
+
+// SQLite with TypeScript
+app.get('/sqlite/users', async (req, res) => {
+  const db: DatabasePool = createPool({
+    type: 'sqlite',
+    connectionString: ':memory:',
+  });
+  
+  await db.connect();
+  const users = await db.query('SELECT * FROM users') as User[];
+  await db.close();
+  
+  response.success(res, { users });
+});
+```
+
+**Supported Databases:**
+- ✅ PostgreSQL (`postgres` or `postgresql`)
+- ✅ MySQL/MariaDB (`mysql` or `mariadb`)
+- ✅ MongoDB (`mongodb`)
+- ✅ SQLite (`sqlite` or `sqlite3`) - **NEW in v5.5**
+- ✅ SQL Server (`mssql` or `sqlserver`) - **NEW in v5.5**
+
+See `examples/database-adapters-demo.js` and `examples/database-adapters-demo.ts` for complete examples.
+
 ## Examples
 
 See the `examples/` directory:
@@ -510,7 +633,10 @@ See the `examples/` directory:
 - `v5-features-demo.js` - v5 features demonstration (caching, CORS, security, compression, health checks, etc.)
 - `v5.1-features-demo.js` - v5.1 features demonstration (Swagger, versioning, upload, testing)
 - `v5.2-features-demo.js` - v5.2 features demonstration (WebSocket, SSE, database)
-- `graphql-demo.js` - GraphQL server example with queries and mutations (v5.4)
+- `graphql-demo.js` - GraphQL server example with queries and mutations (v5.4) - JavaScript
+- `graphql-demo.ts` - GraphQL server example with TypeScript types (v5.4) - TypeScript
+- `database-adapters-demo.js` - Extended database adapters example (v5.5) - JavaScript
+- `database-adapters-demo.ts` - Extended database adapters example (v5.5) - TypeScript
 - `service-client-demo.js` - ServiceClient usage example
 
 ## Roadmap
@@ -539,15 +665,18 @@ Real-time features: WebSocket, Server-Sent Events, database integration
 ### v5.3 ✅
 TypeScript support: Full type definitions, type-safe API, IntelliSense
 
-### v5.4 ✅ (Current)
+### v5.4 ✅
 GraphQL support: Lightweight GraphQL server, queries, mutations, resolvers, schema builder
 
+### v5.5 ✅ (Current)
+Extended database adapters: SQLite and SQL Server support, enhanced connection pooling
+
 ## What's Next?
 
 Future versions may include:
 - gRPC integration
 - Advanced caching strategies
-- More database adapters
+- Advanced query builders
 - Enhanced monitoring and alerting
 
 ## Documentation

package/examples/database-adapters-demo.js

@@ -0,0 +1,138 @@
+/**
+ * Database Adapters Demo - Navis.js
+ * Demonstrates extended database adapter support (SQLite, SQL Server)
+ */
+
+const { NavisApp, createPool, response } = require('../src/index');
+
+const app = new NavisApp();
+
+// Example: SQLite Database
+app.get('/sqlite/users', async (req, res) => {
+  try {
+    const db = createPool({
+      type: 'sqlite',
+      connectionString: ':memory:', // In-memory database for demo
+    });
+
+    await db.connect();
+
+    // Create table (if not exists)
+    await db.query(`
+      CREATE TABLE IF NOT EXISTS users (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        name TEXT NOT NULL,
+        email TEXT NOT NULL
+      )
+    `);
+
+    // Insert sample data
+    await db.query('INSERT INTO users (name, email) VALUES (?, ?)', ['Alice', 'alice@example.com']);
+    await db.query('INSERT INTO users (name, email) VALUES (?, ?)', ['Bob', 'bob@example.com']);
+
+    // Query users
+    const users = await db.query('SELECT * FROM users');
+
+    await db.close();
+
+    response.success(res, {
+      database: 'SQLite',
+      users,
+    });
+  } catch (error) {
+    response.error(res, `SQLite error: ${error.message}`, 500);
+  }
+});
+
+// Example: SQL Server Database
+app.get('/sqlserver/users', async (req, res) => {
+  try {
+    const db = createPool({
+      type: 'mssql',
+      connectionString: process.env.SQL_SERVER_CONNECTION_STRING || 'Server=localhost;Database=testdb;User Id=sa;Password=YourPassword123',
+    });
+
+    await db.connect();
+
+    // Query users (assuming table exists)
+    const users = await db.query('SELECT TOP 10 * FROM users');
+
+    await db.close();
+
+    response.success(res, {
+      database: 'SQL Server',
+      users,
+    });
+  } catch (error) {
+    response.error(res, `SQL Server error: ${error.message}`, 500);
+  }
+});
+
+// Example: PostgreSQL (existing)
+app.get('/postgres/users', async (req, res) => {
+  try {
+    const db = createPool({
+      type: 'postgres',
+      connectionString: process.env.DATABASE_URL || 'postgresql://user:password@localhost:5432/mydb',
+    });
+
+    await db.connect();
+    const users = await db.query('SELECT * FROM users LIMIT 10');
+    await db.close();
+
+    response.success(res, {
+      database: 'PostgreSQL',
+      users,
+    });
+  } catch (error) {
+    response.error(res, `PostgreSQL error: ${error.message}`, 500);
+  }
+});
+
+// Example: MySQL (existing)
+app.get('/mysql/users', async (req, res) => {
+  try {
+    const db = createPool({
+      type: 'mysql',
+      connectionString: process.env.MYSQL_URL || 'mysql://user:password@localhost:3306/mydb',
+    });
+
+    await db.connect();
+    const users = await db.query('SELECT * FROM users LIMIT 10');
+    await db.close();
+
+    response.success(res, {
+      database: 'MySQL',
+      users,
+    });
+  } catch (error) {
+    response.error(res, `MySQL error: ${error.message}`, 500);
+  }
+});
+
+// Health check
+app.get('/health', (req, res) => {
+  response.success(res, {
+    status: 'ok',
+    databases: ['PostgreSQL', 'MySQL', 'MongoDB', 'SQLite', 'SQL Server'],
+  });
+});
+
+// Start server
+const PORT = process.env.PORT || 3000;
+app.listen(PORT, () => {
+  console.log(`🚀 Navis.js Database Adapters Demo running on http://localhost:${PORT}`);
+  console.log('\n📊 Available endpoints:');
+  console.log(`  GET http://localhost:${PORT}/sqlite/users - SQLite example`);
+  console.log(`  GET http://localhost:${PORT}/sqlserver/users - SQL Server example`);
+  console.log(`  GET http://localhost:${PORT}/postgres/users - PostgreSQL example`);
+  console.log(`  GET http://localhost:${PORT}/mysql/users - MySQL example`);
+  console.log(`  GET http://localhost:${PORT}/health - Health check`);
+  console.log('\n💡 Note: Make sure to install the required database drivers:');
+  console.log('  - SQLite: npm install better-sqlite3 (or sqlite3 sqlite)');
+  console.log('  - SQL Server: npm install mssql');
+  console.log('  - PostgreSQL: npm install pg');
+  console.log('  - MySQL: npm install mysql2');
+  console.log('  - MongoDB: npm install mongodb');
+});
+

package/examples/database-adapters-demo.ts

@@ -0,0 +1,145 @@
+/**
+ * Database Adapters Demo - Navis.js (TypeScript)
+ * Demonstrates extended database adapter support with TypeScript types
+ */
+
+import { NavisApp, createPool, response, DatabasePool } from '../src/index';
+
+const app = new NavisApp();
+
+interface User {
+  id: number;
+  name: string;
+  email: string;
+}
+
+// Example: SQLite Database
+app.get('/sqlite/users', async (req, res) => {
+  try {
+    const db: DatabasePool = createPool({
+      type: 'sqlite',
+      connectionString: ':memory:', // In-memory database for demo
+    });
+
+    await db.connect();
+
+    // Create table (if not exists)
+    await db.query(`
+      CREATE TABLE IF NOT EXISTS users (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        name TEXT NOT NULL,
+        email TEXT NOT NULL
+      )
+    `);
+
+    // Insert sample data
+    await db.query('INSERT INTO users (name, email) VALUES (?, ?)', ['Alice', 'alice@example.com']);
+    await db.query('INSERT INTO users (name, email) VALUES (?, ?)', ['Bob', 'bob@example.com']);
+
+    // Query users
+    const users = await db.query('SELECT * FROM users') as User[];
+
+    await db.close();
+
+    response.success(res, {
+      database: 'SQLite',
+      users,
+    });
+  } catch (error) {
+    response.error(res, `SQLite error: ${(error as Error).message}`, 500);
+  }
+});
+
+// Example: SQL Server Database
+app.get('/sqlserver/users', async (req, res) => {
+  try {
+    const db: DatabasePool = createPool({
+      type: 'mssql',
+      connectionString: process.env.SQL_SERVER_CONNECTION_STRING || 'Server=localhost;Database=testdb;User Id=sa;Password=YourPassword123',
+    });
+
+    await db.connect();
+
+    // Query users (assuming table exists)
+    const users = await db.query('SELECT TOP 10 * FROM users') as User[];
+
+    await db.close();
+
+    response.success(res, {
+      database: 'SQL Server',
+      users,
+    });
+  } catch (error) {
+    response.error(res, `SQL Server error: ${(error as Error).message}`, 500);
+  }
+});
+
+// Example: PostgreSQL (existing)
+app.get('/postgres/users', async (req, res) => {
+  try {
+    const db: DatabasePool = createPool({
+      type: 'postgres',
+      connectionString: process.env.DATABASE_URL || 'postgresql://user:password@localhost:5432/mydb',
+    });
+
+    await db.connect();
+    const users = await db.query('SELECT * FROM users LIMIT 10') as User[];
+    await db.close();
+
+    response.success(res, {
+      database: 'PostgreSQL',
+      users,
+    });
+  } catch (error) {
+    response.error(res, `PostgreSQL error: ${(error as Error).message}`, 500);
+  }
+});
+
+// Example: MySQL (existing)
+app.get('/mysql/users', async (req, res) => {
+  try {
+    const db: DatabasePool = createPool({
+      type: 'mysql',
+      connectionString: process.env.MYSQL_URL || 'mysql://user:password@localhost:3306/mydb',
+    });
+
+    await db.connect();
+    const users = await db.query('SELECT * FROM users LIMIT 10') as User[];
+    await db.close();
+
+    response.success(res, {
+      database: 'MySQL',
+      users,
+    });
+  } catch (error) {
+    response.error(res, `MySQL error: ${(error as Error).message}`, 500);
+  }
+});
+
+// Health check
+app.get('/health', (req, res) => {
+  response.success(res, {
+    status: 'ok',
+    databases: ['PostgreSQL', 'MySQL', 'MongoDB', 'SQLite', 'SQL Server'],
+    typescript: true,
+  });
+});
+
+// Start server
+const PORT = process.env.PORT || 3000;
+app.listen(PORT, () => {
+  console.log(`🚀 Navis.js Database Adapters Demo (TypeScript) running on http://localhost:${PORT}`);
+  console.log('\n📊 Available endpoints:');
+  console.log(`  GET http://localhost:${PORT}/sqlite/users - SQLite example`);
+  console.log(`  GET http://localhost:${PORT}/sqlserver/users - SQL Server example`);
+  console.log(`  GET http://localhost:${PORT}/postgres/users - PostgreSQL example`);
+  console.log(`  GET http://localhost:${PORT}/mysql/users - MySQL example`);
+  console.log(`  GET http://localhost:${PORT}/health - Health check`);
+  console.log('\n💡 Note: Make sure to install the required database drivers:');
+  console.log('  - SQLite: npm install better-sqlite3 (or sqlite3 sqlite)');
+  console.log('  - SQL Server: npm install mssql');
+  console.log('  - PostgreSQL: npm install pg');
+  console.log('  - MySQL: npm install mysql2');
+  console.log('  - MongoDB: npm install mongodb');
+});
+

package/examples/graphql-demo.ts

@@ -0,0 +1,158 @@
+/**
+ * GraphQL Demo - Navis.js (TypeScript)
+ * Demonstrates GraphQL query and mutation support with TypeScript
+ */
+
+import {
+  NavisApp,
+  graphql,
+  createResolver,
+  GraphQLResolver,
+  GraphQLContext,
+  response,
+} from '../src/index';
+
+interface User {
+  id: string;
+  name: string;
+  email: string;
+  age?: number;
+}
+
+interface Post {
+  id: string;
+  title: string;
+  content: string;
+  authorId: string;
+}
+
+// Sample data store
+const users: User[] = [
+  { id: '1', name: 'Alice', email: 'alice@example.com', age: 30 },
+  { id: '2', name: 'Bob', email: 'bob@example.com', age: 25 },
+  { id: '3', name: 'Charlie', email: 'charlie@example.com', age: 35 },
+];
+
+const posts: Post[] = [
+  { id: '1', title: 'First Post', content: 'Content 1', authorId: '1' },
+  { id: '2', title: 'Second Post', content: 'Content 2', authorId: '2' },
+  { id: '3', title: 'Third Post', content: 'Content 3', authorId: '1' },
+];
+
+// Define resolvers with TypeScript types
+const resolvers = {
+  Query: {
+    // Get all users
+    users: createResolver(async (variables, context: GraphQLContext): Promise<User[]> => {
+      return users;
+    }),
+
+    // Get user by ID
+    user: createResolver(async (variables, context: GraphQLContext): Promise<User | null> => {
+      const { id } = variables as { id: string };
+      const user = users.find(u => u.id === id);
+      if (!user) {
+        throw new Error(`User with id ${id} not found`);
+      }
+      return user;
+    }),
+
+    // Get all posts
+    posts: createResolver(async (variables, context: GraphQLContext): Promise<Post[]> => {
+      return posts;
+    }),
+
+    // Get posts by author
+    postsByAuthor: createResolver(async (variables, context: GraphQLContext): Promise<Post[]> => {
+      const { authorId } = variables as { authorId: string };
+      return posts.filter(p => p.authorId === authorId);
+    }),
+  },
+
+  Mutation: {
+    // Create user
+    createUser: createResolver(async (variables, context: GraphQLContext): Promise<User> => {
+      const { name, email, age } = variables as { name: string; email: string; age?: number };
+      const newUser: User = {
+        id: String(users.length + 1),
+        name,
+        email,
+        age: age || 0,
+      };
+      users.push(newUser);
+      return newUser;
+    }),
+
+    // Update user
+    updateUser: createResolver(async (variables, context: GraphQLContext): Promise<User> => {
+      const { id, name, email, age } = variables as {
+        id: string;
+        name?: string;
+        email?: string;
+        age?: number;
+      };
+      const user = users.find(u => u.id === id);
+      if (!user) {
+        throw new Error(`User with id ${id} not found`);
+      }
+      if (name) user.name = name;
+      if (email) user.email = email;
+      if (age !== undefined) user.age = age;
+      return user;
+    }),
+
+    // Delete user
+    deleteUser: createResolver(async (variables, context: GraphQLContext): Promise<User> => {
+      const { id } = variables as { id: string };
+      const index = users.findIndex(u => u.id === id);
+      if (index === -1) {
+        throw new Error(`User with id ${id} not found`);
+      }
+      const deleted = users.splice(index, 1)[0];
+      return deleted;
+    }),
+  },
+};
+
+const app = new NavisApp();
+
+// Add GraphQL middleware with TypeScript types
+app.use(
+  graphql({
+    path: '/graphql',
+    resolvers,
+    context: (req) => {
+      // Add custom context with TypeScript types
+      return {
+        userId: (req.headers['x-user-id'] as string) || null,
+        timestamp: new Date().toISOString(),
+      };
+    },
+  })
+);
+
+// Health check endpoint
+app.get('/health', (req, res) => {
+  response.success(res, { status: 'ok', graphql: true, typescript: true });
+});
+
+// Start server
+const PORT = process.env.PORT || 3000;
+app.listen(PORT, () => {
+  console.log(`🚀 Navis.js GraphQL server (TypeScript) running on http://localhost:${PORT}`);
+  console.log(`📊 GraphQL endpoint: http://localhost:${PORT}/graphql`);
+  console.log('\n📝 Example queries:');
+  console.log('\n1. Get all users:');
+  console.log(`curl -X POST http://localhost:${PORT}/graphql \\`);
+  console.log(`  -H "Content-Type: application/json" \\`);
+  console.log(`  -d '{"query": "query { users { id name email age } }"}'`);
+  console.log('\n2. Get user by ID:');
+  console.log(`curl -X POST http://localhost:${PORT}/graphql \\`);
+  console.log(`  -H "Content-Type: application/json" \\`);
+  console.log(`  -d '{"query": "query { user(id: \\"1\\") { id name email } }"}'`);
+  console.log('\n3. Create user:');
+  console.log(`curl -X POST http://localhost:${PORT}/graphql \\`);
+  console.log(`  -H "Content-Type: application/json" \\`);
+  console.log(`  -d '{"query": "mutation { createUser(name: \\"Dave\\", email: \\"dave@example.com\\", age: 28) { id name email } }"}'`);
+});
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "navis.js",
-  "version": "5.4.0",
+  "version": "5.5.0",
   "description": "A lightweight, serverless-first, microservice API framework designed for AWS Lambda and Node.js",
   "main": "src/index.js",
   "types": "types/index.d.ts",

package/src/db/db-pool.js

@@ -33,6 +33,14 @@ class DatabasePool {
       case 'mongodb':
         await this._connectMongoDB();
         break;
+      case 'sqlite':
+      case 'sqlite3':
+        await this._connectSQLite();
+        break;
+      case 'mssql':
+      case 'sqlserver':
+        await this._connectSQLServer();
+        break;
       default:
         throw new Error(`Unsupported database type: ${this.type}`);
     }
@@ -90,6 +98,111 @@ class DatabasePool {
     }
   }
 
+  /**
+   * Connect to SQLite
+   * @private
+   */
+  async _connectSQLite() {
+    try {
+      const sqlite3 = require('better-sqlite3');
+      // SQLite connection string is a file path
+      const dbPath = this.connectionString || ':memory:';
+      this.pool = sqlite3(dbPath, {
+        timeout: this.idleTimeout,
+      });
+      // SQLite doesn't use connection pooling, but we store the db instance
+      this.db = this.pool;
+    } catch (error) {
+      // Fallback to sqlite3 if better-sqlite3 is not available
+      try {
+        const sqlite3 = require('sqlite3');
+        const { open } = require('sqlite');
+        const dbPath = this.connectionString || ':memory:';
+        this.pool = await open({
+          filename: dbPath,
+          driver: sqlite3.Database,
+        });
+        this.db = this.pool;
+      } catch (fallbackError) {
+        throw new Error('SQLite package not installed. Install with: npm install better-sqlite3 or npm install sqlite3 sqlite');
+      }
+    }
+  }
+
+  /**
+   * Connect to SQL Server
+   * @private
+   */
+  async _connectSQLServer() {
+    try {
+      const sql = require('mssql');
+      const config = this._parseSQLServerConfig(this.connectionString);
+      this.pool = await sql.connect(config);
+      this.db = this.pool;
+    } catch (error) {
+      throw new Error('mssql package not installed. Install with: npm install mssql');
+    }
+  }
+
+  /**
+   * Parse SQL Server connection string to config object
+   * @private
+   */
+  _parseSQLServerConfig(connectionString) {
+    if (!connectionString) {
+      throw new Error('SQL Server connection string is required');
+    }
+
+    // If it's already an object, return it
+    if (typeof connectionString === 'object') {
+      return {
+        ...connectionString,
+        pool: {
+          max: this.maxConnections,
+          min: this.minConnections,
+          idleTimeoutMillis: this.idleTimeout,
+        },
+      };
+    }
+
+    // Parse connection string format: Server=host;Database=db;User Id=user;Password=pass
+    const config = {};
+    connectionString.split(';').forEach(part => {
+      const [key, value] = part.split('=');
+      if (key && value) {
+        const normalizedKey = key.trim().toLowerCase();
+        switch (normalizedKey) {
+          case 'server':
+            config.server = value.trim();
+            break;
+          case 'database':
+            config.database = value.trim();
+            break;
+          case 'user id':
+          case 'userid':
+          case 'uid':
+            config.user = value.trim();
+            break;
+          case 'password':
+          case 'pwd':
+            config.password = value.trim();
+            break;
+          case 'port':
+            config.port = parseInt(value.trim(), 10);
+            break;
+        }
+      }
+    });
+
+    config.pool = {
+      max: this.maxConnections,
+      min: this.minConnections,
+      idleTimeoutMillis: this.idleTimeout,
+    };
+
+    return config;
+  }
+
   /**
    * Execute a query
    * @param {string} query - SQL query or MongoDB operation
@@ -113,6 +226,36 @@ class DatabasePool {
         // MongoDB uses different query syntax
         // This is a placeholder - implement based on your needs
         return await this.db.collection(query).find(params[0] || {}).toArray();
+      case 'sqlite':
+      case 'sqlite3':
+        // SQLite with better-sqlite3 (synchronous) or sqlite (async)
+        if (this.pool.prepare) {
+          // better-sqlite3
+          const stmt = this.pool.prepare(query);
+          return stmt.all(...params);
+        } else {
+          // sqlite (async)
+          return await this.pool.all(query, params);
+        }
+      case 'mssql':
+      case 'sqlserver':
+        const sql = require('mssql');
+        const request = this.pool.request();
+        // For parameterized queries, use proper SQL Server parameter syntax
+        // If params is an array, bind them as @p0, @p1, etc.
+        if (Array.isArray(params) && params.length > 0) {
+          params.forEach((param, index) => {
+            request.input(`p${index}`, param);
+          });
+          // Replace ? with @p0, @p1, etc. in query
+          let paramIndex = 0;
+          const modifiedQuery = query.replace(/\?/g, () => `@p${paramIndex++}`);
+          const result = await request.query(modifiedQuery);
+          return result.recordset;
+        } else {
+          const result = await request.query(query);
+          return result.recordset;
+        }
       default:
         throw new Error(`Unsupported database type: ${this.type}`);
     }
@@ -127,7 +270,11 @@ class DatabasePool {
       await this.connect();
     }
 
-    if (this.type === 'mongodb') {
+    if (this.type === 'mongodb' || this.type === 'sqlite' || this.type === 'sqlite3') {
+      return this.pool;
+    }
+
+    if (this.type === 'mssql' || this.type === 'sqlserver') {
       return this.pool;
     }
 
@@ -143,6 +290,9 @@ class DatabasePool {
         await this.pool.end();
       } else if (this.pool.close) {
         await this.pool.close();
+      } else if (typeof this.pool.close === 'function') {
+        // SQLite better-sqlite3
+        this.pool.close();
       }
       this.pool = null;
     }
@@ -170,6 +320,19 @@ class DatabasePool {
         case 'mongodb':
           await this.db.admin().ping();
           return true;
+        case 'sqlite':
+        case 'sqlite3':
+          // SQLite ping - just check if database is accessible
+          if (this.pool.prepare) {
+            this.pool.prepare('SELECT 1').get();
+          } else {
+            await this.pool.get('SELECT 1');
+          }
+          return true;
+        case 'mssql':
+        case 'sqlserver':
+          await this.pool.request().query('SELECT 1');
+          return true;
         default:
           return false;
       }

package/types/index.d.ts

@@ -537,7 +537,7 @@ export interface SSEServer {
 }
 
 export interface DatabasePoolOptions {
-  type?: 'postgres' | 'postgresql' | 'mysql' | 'mariadb' | 'mongodb';
+  type?: 'postgres' | 'postgresql' | 'mysql' | 'mariadb' | 'mongodb' | 'sqlite' | 'sqlite3' | 'mssql' | 'sqlserver';
   connectionString?: string;
   maxConnections?: number;
   minConnections?: number;
@@ -807,7 +807,7 @@ export function createGraphQLServer(options?: GraphQLServerOptions): GraphQLServ
 export function graphql(options?: GraphQLServerOptions): Middleware;
 export function createSchema(): GraphQLSchema;
 export function type(name: string, definition: any): GraphQLSchema;
-export function createResolver(resolverFn: GraphQLResolver, options?: GraphQLResolverOptions): GraphQLResolver;
+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;