create-atsdc-stack 1.0.0

package/app/src/lib/exa-search.ts

@@ -0,0 +1,269 @@
+/**
+ * Exa Search Integration
+ * Provides AI-powered search capabilities using Exa
+ * Documentation: https://docs.exa.ai
+ */
+
+import Exa from 'exa-js';
+
+/**
+ * Initialize Exa client
+ * Requires EXA_API_KEY environment variable
+ */
+function getExaClient(): Exa {
+    const apiKey = import.meta.env.EXA_API_KEY || process.env.EXA_API_KEY;
+
+    if (!apiKey) {
+        throw new Error('EXA_API_KEY environment variable is not set');
+    }
+
+    return new Exa(apiKey);
+}
+
+/**
+ * Search options for Exa
+ */
+export interface ExaSearchOptions {
+    /** Number of results to return (1-10, default: 10) */
+    numResults?: number;
+
+    /** Type of search: 'neural', 'keyword', or 'auto' (default: 'auto') */
+    type?: 'neural' | 'keyword' | 'auto';
+
+    /** Whether to use autoprompt to expand query (default: false) */
+    useAutoprompt?: boolean;
+
+    /** Category of content to search */
+    category?: 'company' | 'research paper' | 'news' | 'github' | 'tweet' | 'movie' | 'song' | 'personal site' | 'pdf';
+
+    /** Start crawl date (YYYY-MM-DD) */
+    startCrawlDate?: string;
+
+    /** End crawl date (YYYY-MM-DD) */
+    endCrawlDate?: string;
+
+    /** Start published date (YYYY-MM-DD) */
+    startPublishedDate?: string;
+
+    /** End published date (YYYY-MM-DD) */
+    endPublishedDate?: string;
+
+    /** Include domains (whitelist) */
+    includeDomains?: string[];
+
+    /** Exclude domains (blacklist) */
+    excludeDomains?: string[];
+
+    /** Whether to include page content */
+    contents?: {
+        text?: boolean | { maxCharacters?: number };
+        highlights?: boolean | { numSentences?: number; highlightsPerUrl?: number };
+        summary?: boolean | { query?: string };
+    };
+}
+
+/**
+ * Exa search result
+ */
+export interface ExaResult {
+    url: string;
+    title: string;
+    publishedDate?: string;
+    author?: string;
+    score?: number;
+    id: string;
+    text?: string;
+    highlights?: string[];
+    summary?: string;
+}
+
+/**
+ * Search the web using Exa
+ * @param query - The search query
+ * @param options - Search options
+ * @returns Array of search results
+ */
+export async function searchWeb(
+    query: string,
+    options: ExaSearchOptions = {}
+): Promise<ExaResult[]> {
+    try {
+        const exa = getExaClient();
+
+        const response = await exa.searchAndContents(query, {
+            numResults: options.numResults || 10,
+            type: options.type || 'auto',
+            useAutoprompt: options.useAutoprompt || false,
+            category: options.category,
+            startCrawlDate: options.startCrawlDate,
+            endCrawlDate: options.endCrawlDate,
+            startPublishedDate: options.startPublishedDate,
+            endPublishedDate: options.endPublishedDate,
+            includeDomains: options.includeDomains,
+            excludeDomains: options.excludeDomains,
+            text: options.contents?.text,
+            highlights: options.contents?.highlights,
+            summary: options.contents?.summary,
+        });
+
+        return response.results.map((result: any) => ({
+            url: result.url,
+            title: result.title,
+            publishedDate: result.publishedDate,
+            author: result.author,
+            score: result.score,
+            id: result.id,
+            text: result.text,
+            highlights: result.highlights,
+            summary: result.summary,
+        }));
+    } catch (error) {
+        console.error('Exa search error:', error);
+        throw new Error('Failed to perform search');
+    }
+}
+
+/**
+ * Find similar content to a given URL
+ * @param url - The URL to find similar content for
+ * @param options - Search options
+ * @returns Array of similar results
+ */
+export async function findSimilar(
+    url: string,
+    options: Omit<ExaSearchOptions, 'type' | 'useAutoprompt'> = {}
+): Promise<ExaResult[]> {
+    try {
+        const exa = getExaClient();
+
+        const response = await exa.findSimilarAndContents(url, {
+            numResults: options.numResults || 10,
+            category: options.category,
+            startCrawlDate: options.startCrawlDate,
+            endCrawlDate: options.endCrawlDate,
+            startPublishedDate: options.startPublishedDate,
+            endPublishedDate: options.endPublishedDate,
+            includeDomains: options.includeDomains,
+            excludeDomains: options.excludeDomains,
+            text: options.contents?.text,
+            highlights: options.contents?.highlights,
+            summary: options.contents?.summary,
+        });
+
+        return response.results.map((result: any) => ({
+            url: result.url,
+            title: result.title,
+            publishedDate: result.publishedDate,
+            author: result.author,
+            score: result.score,
+            id: result.id,
+            text: result.text,
+            highlights: result.highlights,
+            summary: result.summary,
+        }));
+    } catch (error) {
+        console.error('Exa find similar error:', error);
+        throw new Error('Failed to find similar content');
+    }
+}
+
+/**
+ * Get full page content for a list of URLs
+ * @param urls - Array of URLs to get content for
+ * @param options - Content options
+ * @returns Array of results with content
+ */
+export async function getContents(
+    urls: string[],
+    options: ExaSearchOptions['contents'] = {}
+): Promise<ExaResult[]> {
+    try {
+        const exa = getExaClient();
+
+        const response = await exa.getContents(urls, {
+            text: options.text,
+            highlights: options.highlights,
+            summary: options.summary,
+        });
+
+        return response.results.map((result: any) => ({
+            url: result.url,
+            title: result.title,
+            publishedDate: result.publishedDate,
+            author: result.author,
+            id: result.id,
+            text: result.text,
+            highlights: result.highlights,
+            summary: result.summary,
+        }));
+    } catch (error) {
+        console.error('Exa get contents error:', error);
+        throw new Error('Failed to get contents');
+    }
+}
+
+/**
+ * Search for recent news articles
+ * @param query - The search query
+ * @param daysBack - Number of days to look back (default: 7)
+ * @returns Array of news results
+ */
+export async function searchNews(query: string, daysBack: number = 7): Promise<ExaResult[]> {
+    const endDate = new Date();
+    const startDate = new Date();
+    startDate.setDate(startDate.getDate() - daysBack);
+
+    return searchWeb(query, {
+        category: 'news',
+        startPublishedDate: startDate.toISOString().split('T')[0],
+        endPublishedDate: endDate.toISOString().split('T')[0],
+        numResults: 10,
+        contents: {
+            text: { maxCharacters: 1000 },
+            highlights: { numSentences: 3 },
+        },
+    });
+}
+
+/**
+ * Search for research papers
+ * @param query - The search query
+ * @param options - Additional search options
+ * @returns Array of research paper results
+ */
+export async function searchResearch(
+    query: string,
+    options: ExaSearchOptions = {}
+): Promise<ExaResult[]> {
+    return searchWeb(query, {
+        ...options,
+        category: 'research paper',
+        contents: {
+            text: { maxCharacters: 2000 },
+            summary: true,
+            ...options.contents,
+        },
+    });
+}
+
+/**
+ * Search GitHub repositories
+ * @param query - The search query
+ * @param options - Additional search options
+ * @returns Array of GitHub results
+ */
+export async function searchGitHub(
+    query: string,
+    options: ExaSearchOptions = {}
+): Promise<ExaResult[]> {
+    return searchWeb(query, {
+        ...options,
+        category: 'github',
+        includeDomains: ['github.com'],
+        contents: {
+            text: { maxCharacters: 1500 },
+            highlights: { numSentences: 5 },
+            ...options.contents,
+        },
+    });
+}

package/app/src/pages/api/chat.ts

@@ -0,0 +1,91 @@
+import type { APIRoute } from 'astro';
+import { streamText } from 'ai';
+import { z } from 'zod';
+
+/**
+ * Vercel AI SDK Chat API Route
+ * Uses AI Gateway pattern - no provider-specific packages needed!
+ * Just pass model strings like 'openai/gpt-4o' or 'anthropic/claude-3-5-sonnet-20241022'
+ *
+ * Environment variables required:
+ * - OPENAI_API_KEY: Your OpenAI API key (or other provider keys)
+ */
+
+// Validate request schema
+const requestSchema = z.object({
+    messages: z.array(
+        z.object({
+            role: z.enum(['user', 'assistant', 'system']),
+            content: z.string(),
+        })
+    ),
+    model: z.string().optional().default('openai/gpt-4o'),
+    temperature: z.number().min(0).max(2).optional().default(0.7),
+    maxTokens: z.number().positive().optional().default(1000),
+});
+
+export const POST: APIRoute = async ({ request }) => {
+    try {
+        // Validate API key
+        if (!import.meta.env.OPENAI_API_KEY && !process.env.OPENAI_API_KEY) {
+            return new Response(
+                JSON.stringify({
+                    error: 'OPENAI_API_KEY is not configured',
+                }),
+                {
+                    status: 500,
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                }
+            );
+        }
+
+        // Parse and validate request body
+        const body = await request.json();
+        const validatedData = requestSchema.parse(body);
+
+        // Stream the response using Vercel AI SDK with AI Gateway
+        const result = streamText({
+            model: validatedData.model, // Use model string directly (e.g., 'openai/gpt-4o')
+            messages: validatedData.messages,
+            temperature: validatedData.temperature,
+            maxTokens: validatedData.maxTokens,
+            apiKey: import.meta.env.OPENAI_API_KEY || process.env.OPENAI_API_KEY,
+        });
+
+        // Return the stream response
+        return result.toDataStreamResponse();
+    } catch (error) {
+        // Handle Zod validation errors
+        if (error instanceof z.ZodError) {
+            return new Response(
+                JSON.stringify({
+                    error: 'Validation error',
+                    details: error.errors,
+                }),
+                {
+                    status: 400,
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                }
+            );
+        }
+
+        // Handle other errors
+        console.error('Chat API error:', error);
+        return new Response(
+            JSON.stringify({
+                error: 'Internal server error',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            }),
+            {
+                status: 500,
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            }
+        );
+    }
+};

package/app/src/pages/api/posts.ts

@@ -0,0 +1,350 @@
+import type { APIRoute } from 'astro';
+import { db } from '@/db/initialize';
+import { posts } from '@/db/schema';
+import {
+    createPostSchema,
+    updatePostSchema,
+    postQuerySchema,
+    type CreatePostInput,
+    type UpdatePostInput,
+} from '@/db/validations';
+import { eq, desc, and, ilike, or } from 'drizzle-orm';
+import { z } from 'zod';
+
+/**
+ * Posts API Routes
+ * Demonstrates CRUD operations with Drizzle ORM, Zod validation, and NanoID
+ */
+
+// GET /api/posts - List posts with pagination and filtering
+export const GET: APIRoute = async ({ request, url }) => {
+    try {
+        // Parse and validate query parameters
+        const queryParams = {
+            page: url.searchParams.get('page'),
+            limit: url.searchParams.get('limit'),
+            published: url.searchParams.get('published'),
+            featured: url.searchParams.get('featured'),
+            authorId: url.searchParams.get('authorId'),
+            search: url.searchParams.get('search'),
+        };
+
+        const validated = postQuerySchema.parse(queryParams);
+        const offset = (validated.page - 1) * validated.limit;
+
+        // Build query conditions
+        const conditions = [];
+
+        if (validated.published !== undefined) {
+            conditions.push(eq(posts.published, validated.published));
+        }
+
+        if (validated.featured !== undefined) {
+            conditions.push(eq(posts.featured, validated.featured));
+        }
+
+        if (validated.authorId) {
+            conditions.push(eq(posts.authorId, validated.authorId));
+        }
+
+        if (validated.search) {
+            conditions.push(
+                or(
+                    ilike(posts.title, `%${validated.search}%`),
+                    ilike(posts.content, `%${validated.search}%`)
+                )!
+            );
+        }
+
+        // Fetch posts with filtering and pagination
+        const results = await db
+            .select()
+            .from(posts)
+            .where(conditions.length > 0 ? and(...conditions) : undefined)
+            .orderBy(desc(posts.createdAt))
+            .limit(validated.limit)
+            .offset(offset);
+
+        return new Response(
+            JSON.stringify({
+                data: results,
+                meta: {
+                    page: validated.page,
+                    limit: validated.limit,
+                    total: results.length,
+                },
+            }),
+            {
+                status: 200,
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            }
+        );
+    } catch (error) {
+        if (error instanceof z.ZodError) {
+            return new Response(
+                JSON.stringify({
+                    error: 'Validation error',
+                    details: error.errors,
+                }),
+                {
+                    status: 400,
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                }
+            );
+        }
+
+        console.error('GET /api/posts error:', error);
+        return new Response(
+            JSON.stringify({
+                error: 'Internal server error',
+            }),
+            {
+                status: 500,
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            }
+        );
+    }
+};
+
+// POST /api/posts - Create a new post
+export const POST: APIRoute = async ({ request }) => {
+    try {
+        const body = await request.json();
+
+        // Validate request body with Zod
+        const validated: CreatePostInput = createPostSchema.parse(body);
+
+        // Insert post into database (NanoID is auto-generated)
+        const [newPost] = await db
+            .insert(posts)
+            .values({
+                ...validated,
+                publishedAt: validated.published ? new Date() : null,
+            })
+            .returning();
+
+        return new Response(
+            JSON.stringify({
+                data: newPost,
+                message: 'Post created successfully',
+            }),
+            {
+                status: 201,
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            }
+        );
+    } catch (error) {
+        if (error instanceof z.ZodError) {
+            return new Response(
+                JSON.stringify({
+                    error: 'Validation error',
+                    details: error.errors,
+                }),
+                {
+                    status: 400,
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                }
+            );
+        }
+
+        console.error('POST /api/posts error:', error);
+        return new Response(
+            JSON.stringify({
+                error: 'Internal server error',
+            }),
+            {
+                status: 500,
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            }
+        );
+    }
+};
+
+// PUT /api/posts - Update an existing post
+export const PUT: APIRoute = async ({ request }) => {
+    try {
+        const body = await request.json();
+
+        // Validate request body with Zod
+        const validated: UpdatePostInput = updatePostSchema.parse(body);
+        const { id, ...updateData } = validated;
+
+        if (!id) {
+            return new Response(
+                JSON.stringify({
+                    error: 'Post ID is required',
+                }),
+                {
+                    status: 400,
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                }
+            );
+        }
+
+        // Update post in database
+        const [updatedPost] = await db
+            .update(posts)
+            .set({
+                ...updateData,
+                updatedAt: new Date(),
+                publishedAt:
+                    updateData.published !== undefined
+                        ? updateData.published
+                            ? new Date()
+                            : null
+                        : undefined,
+            })
+            .where(eq(posts.id, id))
+            .returning();
+
+        if (!updatedPost) {
+            return new Response(
+                JSON.stringify({
+                    error: 'Post not found',
+                }),
+                {
+                    status: 404,
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                }
+            );
+        }
+
+        return new Response(
+            JSON.stringify({
+                data: updatedPost,
+                message: 'Post updated successfully',
+            }),
+            {
+                status: 200,
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            }
+        );
+    } catch (error) {
+        if (error instanceof z.ZodError) {
+            return new Response(
+                JSON.stringify({
+                    error: 'Validation error',
+                    details: error.errors,
+                }),
+                {
+                    status: 400,
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                }
+            );
+        }
+
+        console.error('PUT /api/posts error:', error);
+        return new Response(
+            JSON.stringify({
+                error: 'Internal server error',
+            }),
+            {
+                status: 500,
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            }
+        );
+    }
+};
+
+// DELETE /api/posts - Delete a post
+export const DELETE: APIRoute = async ({ request, url }) => {
+    try {
+        const id = url.searchParams.get('id');
+
+        if (!id) {
+            return new Response(
+                JSON.stringify({
+                    error: 'Post ID is required',
+                }),
+                {
+                    status: 400,
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                }
+            );
+        }
+
+        // Validate ID format (NanoID is 21 characters)
+        if (id.length !== 21) {
+            return new Response(
+                JSON.stringify({
+                    error: 'Invalid post ID format',
+                }),
+                {
+                    status: 400,
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                }
+            );
+        }
+
+        // Delete post from database
+        const [deletedPost] = await db
+            .delete(posts)
+            .where(eq(posts.id, id))
+            .returning();
+
+        if (!deletedPost) {
+            return new Response(
+                JSON.stringify({
+                    error: 'Post not found',
+                }),
+                {
+                    status: 404,
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                }
+            );
+        }
+
+        return new Response(
+            JSON.stringify({
+                message: 'Post deleted successfully',
+            }),
+            {
+                status: 200,
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            }
+        );
+    } catch (error) {
+        console.error('DELETE /api/posts error:', error);
+        return new Response(
+            JSON.stringify({
+                error: 'Internal server error',
+            }),
+            {
+                status: 500,
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            }
+        );
+    }
+};