create-loadout 1.0.0

package/dist/templates/firecrawl.js

@@ -0,0 +1,106 @@
+export const firecrawlTemplates = {
+    scrapeService: `import FirecrawlApp from '@mendable/firecrawl-js';
+import { FIRECRAWL_API_KEY } from '@/lib/config';
+
+export interface ScrapeResult {
+  markdown?: string;
+  html?: string;
+  metadata?: Record<string, unknown>;
+}
+
+export interface CrawlResult {
+  pages: ScrapeResult[];
+  total: number;
+}
+
+export class ScrapeService {
+  private client: FirecrawlApp;
+
+  constructor(apiKey: string) {
+    this.client = new FirecrawlApp({ apiKey });
+  }
+
+  async scrapeUrl(url: string): Promise<ScrapeResult> {
+    const result = await this.client.scrapeUrl(url, {
+      formats: ['markdown', 'html'],
+    });
+
+    if (!result.success) {
+      throw new Error(result.error || 'Failed to scrape URL');
+    }
+
+    return {
+      markdown: result.markdown,
+      html: result.html,
+      metadata: result.metadata,
+    };
+  }
+
+  async crawlSite(url: string, options?: { limit?: number }): Promise<CrawlResult> {
+    const result = await this.client.crawlUrl(url, {
+      limit: options?.limit ?? 10,
+      scrapeOptions: {
+        formats: ['markdown'],
+      },
+    });
+
+    if (!result.success) {
+      throw new Error(result.error || 'Failed to crawl site');
+    }
+
+    return {
+      pages: result.data?.map((page) => ({
+        markdown: page.markdown,
+        metadata: page.metadata,
+      })) ?? [],
+      total: result.data?.length ?? 0,
+    };
+  }
+
+  async extractData<T>(url: string, schema: Record<string, unknown>): Promise<T> {
+    const result = await this.client.scrapeUrl(url, {
+      formats: ['extract'],
+      extract: { schema },
+    });
+
+    if (!result.success) {
+      throw new Error(result.error || 'Failed to extract data');
+    }
+
+    return result.extract as T;
+  }
+}
+
+export const scrapeService = new ScrapeService(FIRECRAWL_API_KEY);
+`,
+    scrapeRoute: `import { NextResponse } from 'next/server';
+import { scrapeService } from '@/services/scrape.service';
+import { z } from 'zod';
+
+const scrapeSchema = z.object({
+  url: z.url(),
+});
+
+export async function POST(req: Request) {
+  try {
+    const body = await req.json();
+    const { url } = scrapeSchema.parse(body);
+
+    const result = await scrapeService.scrapeUrl(url);
+
+    return NextResponse.json(result);
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      return NextResponse.json(
+        { error: 'Invalid request', details: error.errors },
+        { status: 400 }
+      );
+    }
+    return NextResponse.json(
+      { error: error instanceof Error ? error.message : 'Failed to scrape' },
+      { status: 500 }
+    );
+  }
+}
+`,
+};

package/dist/templates/inngest.d.ts

@@ -0,0 +1,6 @@
+export declare const inngestTemplates: {
+    inngestClient: string;
+    jobsService: string;
+    inngestFunctions: string;
+    inngestRoute: string;
+};

package/dist/templates/inngest.js

@@ -0,0 +1,91 @@
+export const inngestTemplates = {
+    inngestClient: `import { Inngest } from 'inngest';
+
+export const inngest = new Inngest({ id: 'my-app' });
+`,
+    jobsService: `import { type Inngest } from 'inngest';
+import { inngest } from '@/lib/inngest.client';
+
+export class JobsService {
+  constructor(private client: Inngest) {}
+
+  async sendHelloWorld(name?: string): Promise<void> {
+    await this.client.send({
+      name: 'app/hello.world',
+      data: { name },
+    });
+  }
+
+  async syncUser(userId: string, email: string): Promise<void> {
+    await this.client.send({
+      name: 'app/user.sync',
+      data: { userId, email },
+    });
+  }
+
+  async sendEvent<T extends Record<string, unknown>>(
+    eventName: string,
+    data: T
+  ): Promise<void> {
+    await this.client.send({
+      name: eventName,
+      data,
+    });
+  }
+}
+
+export const jobsService = new JobsService(inngest);
+`,
+    inngestFunctions: `import { inngest } from './inngest.client';
+
+export const helloWorld = inngest.createFunction(
+  { id: 'hello-world' },
+  { event: 'app/hello.world' },
+  async ({ event, step }) => {
+    const greeting = await step.run('create-greeting', async () => {
+      return \`Hello, \${event.data.name ?? 'World'}!\`;
+    });
+
+    await step.sleep('wait-a-moment', '1s');
+
+    return { message: greeting };
+  }
+);
+
+export const syncUser = inngest.createFunction(
+  { id: 'sync-user' },
+  { event: 'app/user.sync' },
+  async ({ event, step }) => {
+    const { userId, email } = event.data;
+
+    const userData = await step.run('fetch-user-data', async () => {
+      console.log('Syncing user:', userId, email);
+      return { synced: true };
+    });
+
+    return userData;
+  }
+);
+
+export const dailyCleanup = inngest.createFunction(
+  { id: 'daily-cleanup' },
+  { cron: '0 0 * * *' },
+  async ({ step }) => {
+    await step.run('cleanup', async () => {
+      console.log('Running daily cleanup');
+    });
+
+    return { success: true };
+  }
+);
+`,
+    inngestRoute: `import { serve } from 'inngest/next';
+import { inngest } from '@/lib/inngest.client';
+import { helloWorld, syncUser, dailyCleanup } from '@/lib/inngest.functions';
+
+export const { GET, POST, PUT } = serve({
+  client: inngest,
+  functions: [helloWorld, syncUser, dailyCleanup],
+});
+`,
+};

package/dist/templates/neon-drizzle.d.ts

@@ -0,0 +1,16 @@
+export declare const neonDrizzleTemplates: {
+    drizzleConfig: string;
+    dbClient: string;
+    schema: string;
+    dbIndex: string;
+    todoDto: string;
+    todoView: string;
+    todoCreateSchema: string;
+    todoCreateState: string;
+    todoUpdateSchema: string;
+    todoUpdateState: string;
+    todoDao: string;
+    todoMapper: string;
+    todoService: string;
+    todoActions: string;
+};

package/dist/templates/neon-drizzle.js

@@ -0,0 +1,343 @@
+export const neonDrizzleTemplates = {
+    drizzleConfig: `import { defineConfig } from 'drizzle-kit';
+import { DATABASE_URL } from './lib/config';
+
+export default defineConfig({
+  schema: './lib/db/schema.ts',
+  out: './drizzle',
+  dialect: 'postgresql',
+  dbCredentials: {
+    url: DATABASE_URL,
+  },
+});
+`,
+    dbClient: `import { neon } from '@neondatabase/serverless';
+import { drizzle } from 'drizzle-orm/neon-http';
+import * as schema from './schema';
+import { DATABASE_URL } from '@/lib/config';
+
+const sql = neon(DATABASE_URL);
+
+export const db = drizzle({ client: sql, schema });
+
+export { sql };
+`,
+    schema: `import { boolean, pgTable, text, timestamp, uuid } from 'drizzle-orm/pg-core';
+
+export const todos = pgTable('todos', {
+  id: uuid('id').primaryKey().defaultRandom(),
+  title: text('title').notNull(),
+  description: text('description'),
+  completed: boolean('completed').notNull().default(false),
+  createdAt: timestamp('created_at').defaultNow().notNull(),
+  updatedAt: timestamp('updated_at').defaultNow().notNull(),
+});
+`,
+    dbIndex: `export { db, sql } from './client';
+export * from './schema';
+`,
+    todoDto: `import { todos } from '@/lib/db/schema';
+import { InferInsertModel, InferSelectModel } from 'drizzle-orm';
+
+export type TodoInsertDto = InferInsertModel<typeof todos>;
+export type TodoDto = InferSelectModel<typeof todos>;
+`,
+    todoView: `export type TodoView = {
+  id: string;
+  title: string;
+  description: string | null;
+  completed: boolean;
+  createdAt: Date;
+};
+`,
+    todoCreateSchema: `import { z } from 'zod';
+
+export const TodoCreateFormSchema = z.object({
+  title: z.string().min(1, 'Title is required'),
+  description: z.string().optional(),
+});
+
+export type TodoCreateFormPayload = z.infer<typeof TodoCreateFormSchema>;
+
+export type TodoCreateServiceRequest = TodoCreateFormPayload;
+
+export type TodoCreateServiceResult = {
+  todoId: string;
+};
+`,
+    todoCreateState: `export type TodoCreateState = {
+  success: boolean;
+  error: string | null;
+  data: { todoId: string } | null;
+};
+
+export const initialTodoCreateState: TodoCreateState = {
+  success: false,
+  error: null,
+  data: null,
+};
+`,
+    todoUpdateSchema: `import { z } from 'zod';
+
+export const TodoUpdateFormSchema = z.object({
+  id: z.string().uuid(),
+  title: z.string().min(1, 'Title is required').optional(),
+  description: z.string().optional(),
+  completed: z
+    .string()
+    .transform((val) => val === 'true')
+    .optional(),
+});
+
+export type TodoUpdateFormPayload = z.infer<typeof TodoUpdateFormSchema>;
+
+export type TodoUpdateServiceRequest = {
+  id: string;
+  title?: string;
+  description?: string;
+  completed?: boolean;
+};
+
+export type TodoUpdateServiceResult = {
+  todoId: string;
+};
+`,
+    todoUpdateState: `export type TodoUpdateState = {
+  success: boolean;
+  error: string | null;
+  data: { todoId: string } | null;
+};
+
+export const initialTodoUpdateState: TodoUpdateState = {
+  success: false,
+  error: null,
+  data: null,
+};
+`,
+    todoDao: `import { eq } from 'drizzle-orm';
+import { db } from '@/lib/db/client';
+import { todos } from '@/lib/db/schema';
+import type { TodoDto, TodoInsertDto } from '@/models/todo.dto';
+
+export class TodoDAO {
+  async create(dto: TodoInsertDto): Promise<TodoDto | undefined> {
+    const [created] = await db.insert(todos).values(dto).returning();
+    return created;
+  }
+
+  async getById(id: string): Promise<TodoDto | undefined> {
+    return await db.query.todos.findFirst({
+      where: eq(todos.id, id),
+    });
+  }
+
+  async getAll(): Promise<TodoDto[]> {
+    return await db.query.todos.findMany({
+      orderBy: (todos, { desc }) => [desc(todos.createdAt)],
+    });
+  }
+
+  async update(id: string, dto: Partial<TodoInsertDto>): Promise<TodoDto | undefined> {
+    const [updated] = await db
+      .update(todos)
+      .set({ ...dto, updatedAt: new Date() })
+      .where(eq(todos.id, id))
+      .returning();
+    return updated;
+  }
+
+  async delete(id: string): Promise<void> {
+    await db.delete(todos).where(eq(todos.id, id));
+  }
+}
+
+export const todoDAO = new TodoDAO();
+`,
+    todoMapper: `import type { TodoDto, TodoInsertDto } from '@/models/todo.dto';
+import type { TodoView } from '@/models/todo.view';
+import type { TodoCreateServiceRequest } from '@/models/todoCreate.schema';
+
+export class TodoMapper {
+  toInsertDto(request: TodoCreateServiceRequest): TodoInsertDto {
+    return {
+      title: request.title,
+      description: request.description ?? null,
+    };
+  }
+
+  toView(dto: TodoDto): TodoView {
+    return {
+      id: dto.id,
+      title: dto.title,
+      description: dto.description,
+      completed: dto.completed,
+      createdAt: dto.createdAt,
+    };
+  }
+
+  toViewList(dtos: TodoDto[]): TodoView[] {
+    return dtos.map((dto) => this.toView(dto));
+  }
+}
+
+export const todoMapper = new TodoMapper();
+`,
+    todoService: `import { todoDAO, type TodoDAO } from '@/dao/todo.dao';
+import { todoMapper, type TodoMapper } from '@/mappers/todo.mapper';
+import type { TodoView } from '@/models/todo.view';
+import type { TodoCreateServiceRequest, TodoCreateServiceResult } from '@/models/todoCreate.schema';
+import type { TodoUpdateServiceRequest, TodoUpdateServiceResult } from '@/models/todoUpdate.schema';
+
+export class TodoService {
+  constructor(
+    private dao: TodoDAO,
+    private mapper: TodoMapper
+  ) {}
+
+  async createTodo(request: TodoCreateServiceRequest): Promise<TodoCreateServiceResult> {
+    const insertDto = this.mapper.toInsertDto(request);
+    const created = await this.dao.create(insertDto);
+
+    if (!created) {
+      throw new Error('Failed to create todo');
+    }
+
+    return { todoId: created.id };
+  }
+
+  async getTodoById(id: string): Promise<TodoView | null> {
+    const todo = await this.dao.getById(id);
+    return todo ? this.mapper.toView(todo) : null;
+  }
+
+  async getAllTodos(): Promise<TodoView[]> {
+    const todos = await this.dao.getAll();
+    return this.mapper.toViewList(todos);
+  }
+
+  async updateTodo(request: TodoUpdateServiceRequest): Promise<TodoUpdateServiceResult> {
+    const updated = await this.dao.update(request.id, {
+      title: request.title,
+      description: request.description,
+      completed: request.completed,
+    });
+
+    if (!updated) {
+      throw new Error('Todo not found');
+    }
+
+    return { todoId: updated.id };
+  }
+
+  async toggleTodo(id: string): Promise<TodoView> {
+    const existing = await this.dao.getById(id);
+
+    if (!existing) {
+      throw new Error('Todo not found');
+    }
+
+    const updated = await this.dao.update(id, {
+      completed: !existing.completed,
+    });
+
+    return this.mapper.toView(updated!);
+  }
+
+  async deleteTodo(id: string): Promise<void> {
+    await this.dao.delete(id);
+  }
+}
+
+export const todoService = new TodoService(todoDAO, todoMapper);
+`,
+    todoActions: `'use server';
+
+import { revalidatePath } from 'next/cache';
+import { z } from 'zod';
+import { todoService } from '@/services/todo.service';
+import { TodoCreateFormSchema } from '@/models/todoCreate.schema';
+import { TodoUpdateFormSchema } from '@/models/todoUpdate.schema';
+import type { TodoCreateState } from '@/models/todoCreate.state';
+import type { TodoUpdateState } from '@/models/todoUpdate.state';
+
+export async function createTodo(
+  state: TodoCreateState,
+  formData: FormData
+): Promise<TodoCreateState> {
+  const rawData = Object.fromEntries(formData);
+  const validated = TodoCreateFormSchema.safeParse(rawData);
+
+  if (!validated.success) {
+    return {
+      success: false,
+      error: z.prettifyError(validated.error),
+      data: null,
+    };
+  }
+
+  try {
+    const result = await todoService.createTodo(validated.data);
+
+    revalidatePath('/todos');
+
+    return {
+      success: true,
+      error: null,
+      data: result,
+    };
+  } catch (error) {
+    console.error('Error creating todo:', error);
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Failed to create todo',
+      data: null,
+    };
+  }
+}
+
+export async function updateTodo(
+  state: TodoUpdateState,
+  formData: FormData
+): Promise<TodoUpdateState> {
+  const rawData = Object.fromEntries(formData);
+  const validated = TodoUpdateFormSchema.safeParse(rawData);
+
+  if (!validated.success) {
+    return {
+      success: false,
+      error: z.prettifyError(validated.error),
+      data: null,
+    };
+  }
+
+  try {
+    const result = await todoService.updateTodo(validated.data);
+
+    revalidatePath('/todos');
+
+    return {
+      success: true,
+      error: null,
+      data: result,
+    };
+  } catch (error) {
+    console.error('Error updating todo:', error);
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Failed to update todo',
+      data: null,
+    };
+  }
+}
+
+export async function toggleTodo(id: string): Promise<void> {
+  await todoService.toggleTodo(id);
+  revalidatePath('/todos');
+}
+
+export async function deleteTodo(id: string): Promise<void> {
+  await todoService.deleteTodo(id);
+  revalidatePath('/todos');
+}
+`,
+};

package/dist/templates/posthog.d.ts

@@ -0,0 +1,3 @@
+export declare const posthogTemplates: {
+    instrumentationClient: string;
+};

package/dist/templates/posthog.js

@@ -0,0 +1,10 @@
+export const posthogTemplates = {
+    instrumentationClient: `import posthog from 'posthog-js';
+import { POSTHOG_KEY, POSTHOG_HOST } from '@/lib/config';
+
+posthog.init(POSTHOG_KEY, {
+  api_host: POSTHOG_HOST,
+  defaults: '2025-11-30',
+});
+`,
+};

package/dist/templates/resend.d.ts

@@ -0,0 +1,5 @@
+export declare const resendTemplates: {
+    emailService: string;
+    welcomeEmail: string;
+    sendRoute: string;
+};

package/dist/templates/resend.js

@@ -0,0 +1,102 @@
+export const resendTemplates = {
+    emailService: `import { Resend } from 'resend';
+import type { ReactElement } from 'react';
+import { RESEND_API_KEY, RESEND_FROM_EMAIL } from '@/lib/config';
+
+export interface SendEmailOptions {
+  to: string | string[];
+  subject: string;
+  react: ReactElement;
+  from?: string;
+  replyTo?: string;
+}
+
+export class EmailService {
+  private resend: Resend;
+  private defaultFrom: string;
+
+  constructor(apiKey: string, defaultFrom: string) {
+    this.resend = new Resend(apiKey);
+    this.defaultFrom = defaultFrom;
+  }
+
+  async send(options: SendEmailOptions) {
+    const { data, error } = await this.resend.emails.send({
+      from: options.from || this.defaultFrom,
+      to: options.to,
+      subject: options.subject,
+      react: options.react,
+      replyTo: options.replyTo,
+    });
+
+    if (error) {
+      throw new Error(error.message);
+    }
+
+    return data;
+  }
+
+  async sendWelcome(to: string, name: string) {
+    const { WelcomeEmail } = await import('@/components/emails/welcome');
+    return this.send({
+      to,
+      subject: 'Welcome!',
+      react: WelcomeEmail({ name }),
+    });
+  }
+}
+
+export const emailService = new EmailService(RESEND_API_KEY, RESEND_FROM_EMAIL);
+`,
+    welcomeEmail: `import * as React from 'react';
+
+interface WelcomeEmailProps {
+  name: string;
+}
+
+export function WelcomeEmail({ name }: WelcomeEmailProps) {
+  return (
+    <div style={{ fontFamily: 'sans-serif', padding: '20px' }}>
+      <h1 style={{ color: '#333' }}>Welcome, {name}!</h1>
+      <p style={{ color: '#666', lineHeight: 1.6 }}>
+        Thanks for signing up. We're excited to have you on board.
+      </p>
+      <p style={{ color: '#666', lineHeight: 1.6 }}>
+        If you have any questions, feel free to reply to this email.
+      </p>
+    </div>
+  );
+}
+`,
+    sendRoute: `import { NextResponse } from 'next/server';
+import { emailService } from '@/services/email.service';
+import { z } from 'zod';
+
+const sendEmailSchema = z.object({
+  to: z.email(),
+  name: z.string().min(1),
+});
+
+export async function POST(req: Request) {
+  try {
+    const body = await req.json();
+    const { to, name } = sendEmailSchema.parse(body);
+
+    const data = await emailService.sendWelcome(to, name);
+
+    return NextResponse.json(data);
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      return NextResponse.json(
+        { error: 'Invalid request', details: error.errors },
+        { status: 400 }
+      );
+    }
+    return NextResponse.json(
+      { error: error instanceof Error ? error.message : 'Failed to send email' },
+      { status: 500 }
+    );
+  }
+}
+`,
+};

package/dist/templates/sentry.d.ts

@@ -0,0 +1,8 @@
+export declare const sentryTemplates: {
+    instrumentation: string;
+    instrumentationClient: string;
+    serverConfig: string;
+    edgeConfig: string;
+    globalError: string;
+    nextConfig: string;
+};