Comparison

// Define API with standard HTTP
const userController = igniter.controller({
  name: 'Users',
  description: 'Manage user accounts and profiles',
  path: '/users',
  actions: {
    getById: igniter.query({
      name: 'Get User by ID',
      description: 'Retrieve a specific user by their ID',
      path: '/:id' as const,
      handler: async ({ request, response }) => {
        const user = await db.users.findUnique({
          where: { id: request.params.id }
        });
        return response.success({ user });
      }
    }),
    create: igniter.mutation({
      name: 'Create User',
      description: 'Create a new user account',
      path: '/',
      method: 'POST',
      body: z.object({
        name: z.string(),
        email: z.string().email()
      }),
      handler: async ({ request, response }) => {
        const user = await db.users.create({ 
          data: request.body 
        });
        return response.created({ user });
      }
    })
  }
});

// Client usage
const { data } = await client.users.getById.query({ 
  params: { id: '123' } 
});

// ✅ Also works with curl, Postman, etc.
// GET /api/v1/users/123

// Define API with RPC
const userRouter = t.router({
  getById: t.procedure
    .input(z.object({ id: z.string() }))
    .query(async ({ input }) => {
      const user = await db.users.findUnique({ 
        where: { id: input.id } 
      });
      return { user };
    }),
  create: t.procedure
    .input(z.object({
      name: z.string(),
      email: z.string().email()
    }))
    .mutation(async ({ input }) => {
      const user = await db.users.create({ 
        data: input 
      });
      return { user };
    })
});

// Client usage
const data = await trpc.users.getById.query({ id: '123' });

// ⚠️ Only works with TypeScript clients
// Not standard REST

// Server: Type-safe with validation
const createUser = igniter.mutation({
  path: '/users',
  method: 'POST',
  body: z.object({
    name: z.string().min(2),
    email: z.string().email()
  }),
  handler: async ({ request, response }) => {
    // ✅ request.body is fully typed!
    const user = await db.users.create({ 
      data: request.body 
    });
    return response.created({ user });
  }
});

// Client: Fully typed
const { data } = await client.users.create.mutate({
  body: { name: 'John', email: 'john@example.com' }
});
// ✅ data.user is fully typed!

// ✅ Also works with external clients
// POST /api/v1/users

// Server: Manual type casting
'use server'

async function createUser(formData: FormData) {
  // ⚠️ Manual casting and validation
  const name = formData.get('name') as string;
  const email = formData.get('email') as string;
  
  // Manual validation
  if (!name || name.length < 2) {
    throw new Error('Name too short');
  }
  
  const user = await db.users.create({ 
    data: { name, email } 
  });
  return user;
}

// Client: Limited type inference
const user = await createUser(formData);
// ⚠️ Type not automatically inferred

// ❌ Can't call from external clients
// ❌ No REST endpoint

// Route with automatic validation & typing
const createUser = igniter.mutation({
  path: '/users',
  method: 'POST',
  body: z.object({
    name: z.string().min(2),
    email: z.string().email(),
    age: z.number().min(18)
  }),
  handler: async ({ request, response }) => {
    // ✅ request.body is validated and typed
    const { name, email, age } = request.body;
    
    const user = await db.users.create({ 
      data: { name, email, age } 
    });
    
    return response.created({ user });
  }
});

// Client: Automatic type-safe hooks
const { mutate, isLoading } = client.users.create.useMutation();

await mutate({ 
  body: { name: 'John', email: 'john@example.com', age: 25 } 
});

import { body, validationResult } from 'express-validator';

// Route with manual validation
app.post('/users',
  // Manual validation rules
  body('name').isString().isLength({ min: 2 }),
  body('email').isEmail(),
  body('age').isInt({ min: 18 }),
  async (req, res) => {
    // Manual error checking
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
      return res.status(400).json({ errors: errors.array() });
    }
    
    // ⚠️ Manual type casting
    const { name, email, age } = req.body as {
      name: string;
      email: string;
      age: number;
    };
    
    const user = await db.users.create({ 
      data: { name, email, age } 
    });
    
    res.status(201).json({ user });
  }
);

// Client: Manual fetch
const response = await fetch('/users', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({ name: 'John', email: 'john@example.com', age: 25 })
});

const data = await response.json() as { user: User };

// Automatic type inference
const getUser = igniter.query({
  name: 'Get User',
  description: 'Retrieve a specific user by ID',
  path: '/users/:id' as const,
  handler: async ({ request, response }) => {
    // ✅ request.params.id is automatically typed
    const user = await db.users.findUnique({ 
      where: { id: request.params.id } 
    });
    
    if (!user) {
      return response.notFound('User not found');
    }
    
    return response.success({ user });
  }
});

// Client: Automatic hooks
const { data, isLoading } = client.users.getById.useQuery({
  params: { id: '123' }
});

// Manual type definitions
interface GetUserParams {
  id: string;
}

interface GetUserReply {
  user: User;
}

fastify.get<{
  Params: GetUserParams;
  Reply: GetUserReply;
}>('/users/:id', {
  schema: {
    params: {
      type: 'object',
      properties: {
        id: { type: 'string' }
      }
    },
    response: {
      200: {
        type: 'object',
        properties: {
          user: { type: 'object' }
        }
      }
    }
  }
}, async (request, reply) => {
  const user = await db.users.findUnique({ 
    where: { id: request.params.id } 
  });
  
  if (!user) {
    return reply.code(404).send({ error: 'User not found' });
  }
  
  return { user };
});

// Client: Manual fetch
const response = await fetch('/users/123');
const data = await response.json() as GetUserReply;