@goscribe/server 1.5.0 → 1.7.0

package/dist/src/lib/env.js

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+import dotenv from 'dotenv';
+dotenv.config();
+/**
+ * Environment variable schema
+ */
+const envSchema = z.object({
+    // Database
+    DATABASE_URL: z.string().url(),
+    DIRECT_URL: z.string().url().optional(),
+    // Server
+    PORT: z.string().regex(/^\d+$/).default('3001').transform(Number),
+    NODE_ENV: z.enum(['development', 'production', 'test']).default('development'),
+    // Auth
+    BETTER_AUTH_SECRET: z.string().min(32).optional(),
+    BETTER_AUTH_URL: z.string().url().optional(),
+    // Storage
+    GOOGLE_CLOUD_PROJECT_ID: z.string().optional(),
+    GOOGLE_CLOUD_BUCKET_NAME: z.string().optional(),
+    GOOGLE_APPLICATION_CREDENTIALS: z.string().optional(),
+    // Pusher
+    PUSHER_APP_ID: z.string().optional(),
+    PUSHER_KEY: z.string().optional(),
+    PUSHER_SECRET: z.string().optional(),
+    PUSHER_CLUSTER: z.string().optional(),
+    // Inference
+    INFERENCE_API_URL: z.string().url().optional(),
+    // CORS
+    FRONTEND_URL: z.string().url().default('http://localhost:3000'),
+    // Email (Resend)
+    RESEND_API_KEY: z.string().optional(),
+    EMAIL_FROM: z.string().default('Scribe <hello@scribe.study>'),
+    // Stripe
+    STRIPE_SECRET_KEY: z.string().startsWith('sk_').optional(),
+    STRIPE_SUCCESS_URL: z.string().url().default('http://localhost:3000/payment-success'),
+    STRIPE_CANCEL_URL: z.string().url().default('http://localhost:3000/payment-cancel'),
+    STRIPE_PRICE_SUB_BASIC: z.string().startsWith('price_').optional(),
+    STRIPE_PRICE_SUB_PRO: z.string().startsWith('price_').optional(),
+    STRIPE_PRICE_CREDITS_1000: z.string().startsWith('price_').optional(),
+    STRIPE_WEBHOOK_SECRET: z.string().startsWith('whsec_').optional(),
+});
+/**
+ * Parsed and validated environment variables
+ */
+export const env = envSchema.parse(process.env);
+/**
+ * Check if running in production
+ */
+export const isProduction = env.NODE_ENV === 'production';
+/**
+ * Check if running in development
+ */
+export const isDevelopment = env.NODE_ENV === 'development';
+/**
+ * Check if running in test
+ */
+export const isTest = env.NODE_ENV === 'test';

package/dist/src/lib/errors.d.ts

@@ -0,0 +1,33 @@
+import { TRPCError } from '@trpc/server';
+/**
+ * Custom error classes for better error handling
+ */
+export declare class AppError extends Error {
+    code: string;
+    statusCode: number;
+    isOperational: boolean;
+    constructor(message: string, code: string, statusCode?: number, isOperational?: boolean);
+}
+export declare class ValidationError extends AppError {
+    constructor(message: string);
+}
+export declare class NotFoundError extends AppError {
+    constructor(resource?: string);
+}
+export declare class UnauthorizedError extends AppError {
+    constructor(message?: string);
+}
+export declare class ForbiddenError extends AppError {
+    constructor(message?: string);
+}
+export declare class ConflictError extends AppError {
+    constructor(message: string);
+}
+/**
+ * Convert AppError to TRPCError
+ */
+export declare function toTRPCError(error: unknown): TRPCError;
+/**
+ * Error handler for async functions
+ */
+export declare function asyncHandler<T extends (...args: any[]) => Promise<any>>(fn: T): T;

package/dist/src/lib/errors.js

@@ -0,0 +1,78 @@
+import { TRPCError } from '@trpc/server';
+/**
+ * Custom error classes for better error handling
+ */
+export class AppError extends Error {
+    constructor(message, code, statusCode = 500, isOperational = true) {
+        super(message);
+        this.code = code;
+        this.statusCode = statusCode;
+        this.isOperational = isOperational;
+        this.name = this.constructor.name;
+        Error.captureStackTrace(this, this.constructor);
+    }
+}
+export class ValidationError extends AppError {
+    constructor(message) {
+        super(message, 'VALIDATION_ERROR', 400);
+    }
+}
+export class NotFoundError extends AppError {
+    constructor(resource = 'Resource') {
+        super(`${resource} not found`, 'NOT_FOUND', 404);
+    }
+}
+export class UnauthorizedError extends AppError {
+    constructor(message = 'Unauthorized') {
+        super(message, 'UNAUTHORIZED', 401);
+    }
+}
+export class ForbiddenError extends AppError {
+    constructor(message = 'Forbidden') {
+        super(message, 'FORBIDDEN', 403);
+    }
+}
+export class ConflictError extends AppError {
+    constructor(message) {
+        super(message, 'CONFLICT', 409);
+    }
+}
+/**
+ * Convert AppError to TRPCError
+ */
+export function toTRPCError(error) {
+    if (error instanceof AppError) {
+        const codeMap = {
+            400: 'BAD_REQUEST',
+            401: 'UNAUTHORIZED',
+            403: 'FORBIDDEN',
+            404: 'NOT_FOUND',
+            409: 'CONFLICT',
+            500: 'INTERNAL_SERVER_ERROR',
+        };
+        return new TRPCError({
+            code: codeMap[error.statusCode] || 'INTERNAL_SERVER_ERROR',
+            message: error.message,
+            cause: error,
+        });
+    }
+    if (error instanceof TRPCError) {
+        return error;
+    }
+    // Default error
+    return new TRPCError({
+        code: 'INTERNAL_SERVER_ERROR',
+        message: error instanceof Error ? error.message : 'An unexpected error occurred',
+        cause: error,
+    });
+}
+/**
+ * Error handler for async functions
+ */
+export function asyncHandler(fn) {
+    return ((...args) => {
+        return Promise.resolve(fn(...args)).catch((error) => {
+            throw toTRPCError(error);
+        });
+    });
+}

package/dist/src/lib/file.js

@@ -0,0 +1 @@
+"use strict";

package/dist/src/lib/inference.d.ts

@@ -0,0 +1 @@
+export { complete as default, complete, completeText } from './ai/llm-client.js';

package/dist/src/lib/inference.js

@@ -0,0 +1 @@
+export { complete as default, complete, completeText } from './ai/llm-client.js';

package/dist/src/lib/kb-meta.d.ts

@@ -0,0 +1,8 @@
+export type KbMetaRecord = {
+    slug?: string;
+    category?: string;
+    subject?: string;
+    kind?: string;
+};
+/** Build catalog meta for new KBs so clients can assign icons and banner colors. */
+export declare function buildKbMetaFromName(name: string, existing?: KbMetaRecord | null): KbMetaRecord;

package/dist/src/lib/kb-meta.js

@@ -0,0 +1,77 @@
+import { CURATED_KB_SEEDS } from './curated-kb-seed.js';
+const CURATED_BY_NAME = new Map(CURATED_KB_SEEDS.map((seed) => [seed.name.trim().toLowerCase(), seed]));
+function inferSubject(name) {
+    const lower = name.toLowerCase();
+    if (lower.includes('biology') || /\bbio\b/.test(lower))
+        return 'biology';
+    if (lower.includes('chemistry') || /\bchem\b/.test(lower))
+        return 'chemistry';
+    if (lower.includes('physics'))
+        return 'physics';
+    if (lower.includes('calculus'))
+        return 'calculus';
+    if (lower.includes('statistics') || lower.includes('stats'))
+        return 'math';
+    if (lower.includes('math') || lower.includes('algebra') || lower.includes('geometry')) {
+        return 'math';
+    }
+    if (lower.includes('literature') || lower.includes('literary'))
+        return 'literature';
+    if (lower.includes('english') || lower.includes('writing') || lower.includes('rhetoric')) {
+        return 'english';
+    }
+    if (lower.includes('history') || lower.includes('historical'))
+        return 'history';
+    if (lower.includes('psychology') || lower.includes('psych'))
+        return 'psychology';
+    if (lower.includes('economics') || lower.includes('econ'))
+        return 'economics';
+    if (lower.includes('environmental') || lower.includes('ecology'))
+        return 'environmental';
+    if (lower.includes('computer') || lower.includes('programming') || lower.includes('cs ')) {
+        return 'science';
+    }
+    if (lower.includes('government') || lower.includes('politics'))
+        return 'history';
+    return undefined;
+}
+function inferCategory(name, category) {
+    if (category === 'AP' || category === 'IB')
+        return category;
+    const lower = name.toLowerCase();
+    if (lower.startsWith('ap ') || lower.includes(' ap ') || lower.includes('advanced placement')) {
+        return 'AP';
+    }
+    if (lower.startsWith('ib ') || lower.includes(' ib ') || lower.includes('baccalaureate')) {
+        return 'IB';
+    }
+    return 'General';
+}
+function slugify(name) {
+    return name
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, 80);
+}
+/** Build catalog meta for new KBs so clients can assign icons and banner colors. */
+export function buildKbMetaFromName(name, existing) {
+    const trimmed = name.trim();
+    const curated = CURATED_BY_NAME.get(trimmed.toLowerCase());
+    if (curated) {
+        return {
+            slug: curated.slug,
+            category: curated.category,
+            subject: curated.subject,
+        };
+    }
+    const subject = existing?.subject ?? inferSubject(trimmed);
+    const category = inferCategory(trimmed, existing?.category);
+    const slug = existing?.slug ?? (subject ? `${slugify(trimmed)}-${subject}` : slugify(trimmed));
+    return {
+        slug: slug || undefined,
+        category: category === 'General' ? undefined : category,
+        subject,
+        ...(existing?.kind ? { kind: existing.kind } : {}),
+    };
+}

package/dist/src/lib/logger.d.ts

@@ -0,0 +1,62 @@
+export declare enum LogLevel {
+    ERROR = 0,
+    WARN = 1,
+    INFO = 2,
+    DEBUG = 3,
+    TRACE = 4
+}
+export interface LogEntry {
+    timestamp: string;
+    level: string;
+    message: string;
+    context?: string;
+    metadata?: Record<string, any>;
+    error?: {
+        name: string;
+        message: string;
+        stack?: string;
+    };
+}
+export interface LoggerConfig {
+    level: LogLevel;
+    enableConsole: boolean;
+    enableFile: boolean;
+    logDir?: string;
+    maxFileSize?: number;
+    maxFiles?: number;
+    format?: 'json' | 'pretty';
+}
+declare class Logger {
+    private config;
+    private logStream?;
+    constructor(config?: Partial<LoggerConfig>);
+    private setupFileLogging;
+    private shouldLog;
+    private formatLogEntry;
+    private formatLevel;
+    private formatTimestamp;
+    private formatContext;
+    private formatMetadata;
+    private formatValue;
+    private formatError;
+    private log;
+    error(message: string, contextOrError?: string | Error | unknown, metadata?: Record<string, any>, error?: Error): void;
+    warn(message: string, contextOrMeta?: string | Record<string, any>, metadata?: Record<string, any>): void;
+    info(message: string, contextOrMeta?: string | Record<string, any>, metadata?: Record<string, any>): void;
+    debug(message: string, contextOrMeta?: string | Record<string, any>, metadata?: Record<string, any>): void;
+    trace(message: string, context?: string, metadata?: Record<string, any>): void;
+    http(method: string, url: string, statusCode: number, responseTime?: number, context?: string): void;
+    private getHttpStatusIcon;
+    database(operation: string, table: string, duration?: number, context?: string): void;
+    private getDatabaseOperationIcon;
+    auth(action: string, userId?: string, context?: string): void;
+    trpc(procedure: string, input?: any, output?: any, duration?: number, context?: string): void;
+    updateConfig(newConfig: Partial<LoggerConfig>): void;
+    progress(message: string, current: number, total: number, context?: string): void;
+    private createProgressBar;
+    success(message: string, context?: string, metadata?: Record<string, any>): void;
+    failure(message: string, context?: string, metadata?: Record<string, any>, error?: Error): void;
+    close(): void;
+}
+export declare const logger: Logger;
+export { Logger };