navis.js 5.4.0 → 5.4.1

package/README.md

@@ -437,6 +437,7 @@ exports.handler = async (event, context) => {
 
 ### GraphQL Support (v5.4)
 
+**JavaScript Example:**
 ```javascript
 const { NavisApp, graphql, createResolver } = require('navis.js');
 
@@ -478,6 +479,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 \
@@ -510,7 +561,8 @@ 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
 - `service-client-demo.js` - ServiceClient usage example
 
 ## Roadmap

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.4.1",
   "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/types/index.d.ts

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