Quick Start

import { Igniter } from '@igniter-js/core';

// Define your application context type
export interface AppContext {
  db: {
    users: Array<{ id: string; name: string; email: string }>;
  };
}

// Create context factory function
export function createIgniterAppContext(): AppContext {
  return {
    db: {
      users: [] // In a real app, this would be your database connection
    }
  };
}

// Create and configure your Igniter instance
export const igniter = Igniter
  .context(createIgniterAppContext())
  .config({
    baseURL: 'http://localhost:3000',
    basePATH: '/api/v1'
  })
  .create();

import { igniter } from '@/igniter';
import { z } from 'zod';

// Define validation schemas
const UserSchema = z.object({
  id: z.string(),
  name: z.string().min(2),
  email: z.string().email()
});

const CreateUserSchema = z.object({
  name: z.string().min(2),
  email: z.string().email()
});

// Create the controller
export const userController = igniter.controller({
  name: 'Users',
  description: 'Manage user accounts and profiles',
  path: '/users',
  actions: {
    // We'll add actions in the next step
  }
});

export const userController = igniter.controller({
  path: '/users',
  actions: {
    list: igniter.query({
      name: 'List Users',
      description: 'Retrieve a list of all users',
      path: '/',
      handler: async ({ context, response }) => {
        // Access your context (typed automatically!)
        const users = context.db.users;

        // Return a success response
        return response.success({ users });
      }
    }),
  }
});

export const userController = igniter.controller({
  path: '/users',
  actions: {
    list: igniter.query({
      path: '/',
      handler: async ({ context, response }) => {
        const users = context.db.users;
        return response.success({ users });
      }
    }),
    
    create: igniter.mutation({
      name: 'Create User',
      description: 'Create a new user account',
      path: '/',
      method: 'POST',
      body: CreateUserSchema, // ← Validation schema
      handler: async ({ request, context, response }) => {
        // request.body is automatically validated and typed!
        const newUser = {
          id: crypto.randomUUID(),
          name: request.body.name,
          email: request.body.email
        };
        
        context.db.users.push(newUser);
        
        // Return created status with the new user
        return response.created({ user: newUser });
      }
    }),
  }
});

getById: igniter.query({
  name: 'Get User by ID',
  description: 'Retrieve a specific user by their ID',
  path: '/:id' as const, // ← Path parameter with 'as const' for proper type inference
  handler: async ({ request, context, response }) => {
    // request.params.id is automatically typed as string
    const user = context.db.users.find(u => u.id === request.params.id);
    
    if (!user) {
      return response.notFound({ message: 'User not found' });
    }
    
    return response.success({ user });
  }
}),

search: igniter.query({
  name: 'Search Users',
  description: 'Search users by name with optional limit',
  path: '/search',
  query: z.object({
    q: z.string().min(1),
    limit: z.number().optional()
  }),
  handler: async ({ request, context, response }) => {
    // request.query is validated and typed!
    const { q, limit = 10 } = request.query;
    
    const results = context.db.users
      .filter(u => u.name.toLowerCase().includes(q.toLowerCase()))
      .slice(0, limit);
    
    return response.success({ users: results, query: q });
  }
}),

import { createIgniterClient } from '@igniter-js/core/client';
import { AppRouter } from '@/igniter.router';

export const client = createIgniterClient<typeof AppRouter>({
  baseURL: 'http://localhost:3000',
  basePATH: '/api/v1',
  router: AppRouter
});

// In a Next.js Server Component or API route
import { AppRouter } from '@/igniter.router';

export async function UsersList() {
  // Direct server-side call - no HTTP!
  const { data } = await AppRouter.caller.users.list.query();
  
  return (
    <ul>
      {data.users.map(user => (
        <li key={user.id}>{user.name}</li>
      ))}
    </ul>
  );
}

'use client';

import { client } from '@/lib/api-client';

export function UsersListClient() {
  // Fully typed hook with loading states
  const { data, isLoading, error } = client.users.list.useQuery();
  
  if (isLoading) return <div>Loading...</div>;
  if (error) return <div>Error: {error.message}</div>;
  
  return (
    <ul>
      {data.users.map(user => (
        <li key={user.id}>{user.name}</li>
      ))}
    </ul>
  );
}

'use client';

import { client } from '@/lib/api-client';
import { useState } from 'react';

export function CreateUserForm() {
  const [name, setName] = useState('');
  const [email, setEmail] = useState('');
  
  const { mutate, isPending } = client.users.create.useMutation({
    onSuccess: (data) => {
      console.log('User created:', data.user);
      // Reset form
      setName('');
      setEmail('');
    }
  });
  
  const handleSubmit = (e: React.FormEvent) => {
    e.preventDefault();
    // Fully typed mutation!
    mutate({ body: { name, email } });
  };
  
  return (
    <form onSubmit={handleSubmit}>
      <input 
        value={name} 
        onChange={e => setName(e.target.value)}
        placeholder="Name"
      />
      <input 
        value={email} 
        onChange={e => setEmail(e.target.value)}
        placeholder="Email"
        type="email"
      />
      <button type="submit" disabled={isPending}>
        {isPending ? 'Creating...' : 'Create User'}
      </button>
    </form>
  );
}