wexts 3.0.0 → 3.0.1

package/templates/.env.example

@@ -0,0 +1,17 @@
+# WEXTS Environment Variables
+# Copy this file to .env and update values
+
+# JWT Authentication
+JWT_SECRET=your-super-secret-jwt-key-change-in-production
+JWT_EXPIRES_IN=7d
+
+# Database (Local Development - SQLite)
+DATABASE_URL="file:./apps/api/dev.db"
+
+# Database (Production - PostgreSQL)
+# DATABASE_URL="postgresql://user:password@host:5432/dbname"
+# DIRECT_URL="postgresql://user:password@host:5432/dbname"
+
+# Server
+PORT=3000
+NODE_ENV=development

package/templates/Dockerfile

@@ -0,0 +1,60 @@
+# Stage 1: Build
+FROM node:20-alpine AS builder
+
+# Install pnpm
+RUN npm install -g pnpm
+
+# Set working directory
+WORKDIR /app
+
+# Copy package files
+COPY package.json pnpm-lock.yaml pnpm-workspace.yaml ./
+COPY apps/web/package.json ./apps/web/
+COPY apps/api/package.json ./apps/api/
+
+# Install dependencies
+RUN pnpm install --frozen-lockfile
+
+# Copy source code
+COPY . .
+
+# Generate Prisma Client
+RUN cd apps/api && npx prisma generate
+
+# Build all apps
+RUN pnpm run build
+
+# Stage 2: Production
+FROM node:20-alpine AS runner
+
+# Install pnpm
+RUN npm install -g pnpm
+
+WORKDIR /app
+
+# Copy package files
+COPY package.json pnpm-lock.yaml pnpm-workspace.yaml ./
+COPY apps/web/package.json ./apps/web/
+COPY apps/api/package.json ./apps/api/
+
+# Install production dependencies only
+RUN pnpm install --prod --frozen-lockfile
+
+# Copy built files from builder
+COPY --from=builder /app/dist ./dist
+COPY --from=builder /app/apps/web/.next ./apps/web/.next
+COPY --from=builder /app/apps/web/public ./apps/web/public
+COPY --from=builder /app/apps/api/dist ./apps/api/dist
+COPY --from=builder /app/apps/api/prisma ./apps/api/prisma
+COPY --from=builder /app/node_modules/.prisma ./node_modules/.prisma
+COPY --from=builder /app/server.ts ./server.ts
+
+# Expose port
+EXPOSE 3000
+
+# Set environment
+ENV NODE_ENV=production
+ENV PORT=3000
+
+# Start application
+CMD ["node", "dist/server.js"]

package/templates/Procfile

@@ -0,0 +1 @@
+web: pnpm start

package/templates/README.md

@@ -0,0 +1,58 @@
+# WEXTS Templates
+
+This directory contains all the templates needed to create a WEXTS unified server application.
+
+## 📁 Files Included
+
+### Core Templates
+- `server.ts` - Unified server that runs Next.js + NestJS in one process
+- `api-sdk.ts` - Type-safe SDK for API calls (zero URLs needed!)
+- `root-package.json` - Root package.json with all scripts
+- `tsconfig.json` - TypeScript configuration
+- `.env.example` - Environment variables template
+
+### Deployment Templates
+- `Dockerfile` - Docker multi-stage build
+- `docker-compose.yml` - Docker Compose with PostgreSQL
+- `.dockerignore` - Docker ignore file
+- `nixpacks.toml` - Railway deployment config
+- `Procfile` - Render/Heroku deployment
+
+### App Templates
+- `nestjs-api/` - NestJS backend template
+- `nextjs-web/` - Next.js frontend template
+
+## 🚀 Usage
+
+These templates are used by the WEXTS CLI when creating a new project:
+
+```bash
+npx wexts create my-app
+```
+
+## ✨ Features
+
+✅ **Unified Server** - Single Node.js process for frontend + backend  
+✅ **Zero URLs** - Type-safe SDK without explicit API URLs  
+✅ **Smart Routing** - Automatic routing between Next.js and NestJS  
+✅ **Docker Ready** - Complete Docker setup included  
+✅ **Multi-Platform Deploy** - Railway, Render, Docker, VPS  
+
+## 📦 Template Structure
+
+```
+project/
+├── server.ts              ← Unified server
+├── package.json           ← Root package
+├── tsconfig.json          ← TS config
+├── .env.example           ← Env template
+├── Dockerfile             ← Docker build
+├── docker-compose.yml     ← Docker + DB
+├── apps/
+│   ├── api/              ← From nestjs-api template
+│   └── web/              ← From nextjs-web template
+```
+
+## 🔧 Customization
+
+Templates can be customized before project creation. See CLI documentation for details.

package/templates/api-sdk.ts

@@ -0,0 +1,115 @@
+/**
+ * WEXTS Internal SDK
+ * Type-safe API client - ZERO URLs needed!
+ * Works in both Client and Server Components
+ */
+
+// HTTP client - uses relative paths only
+async function request<T>(method: string, path: string, data?: any): Promise<T> {
+    const url = `/api${path}`;
+
+    const options: RequestInit = {
+        method,
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        credentials: 'include',
+    };
+
+    if (data) {
+        options.body = JSON.stringify(data);
+    }
+
+    const response = await fetch(url, options);
+
+    if (!response.ok) {
+        const error = await response.json().catch(() => ({ message: response.statusText }));
+        throw new Error(error.message || 'Request failed');
+    }
+
+    return response.json();
+}
+
+// ==========================================
+// TYPE-SAFE API - NO URLs ANYWHERE!
+// ==========================================
+
+export const api = {
+    /**
+     * Authentication API
+     */
+    auth: {
+        /**
+         * Register new user
+         * @example await api.auth.register({ email, password, name })
+         */
+        register: (data: { email: string; password: string; name?: string }) =>
+            request<{ user: any; access_token: string }>('POST', '/auth/register', data),
+
+        /**
+         * Login user
+         * @example await api.auth.login({ email, password })
+         */
+        login: (data: { email: string; password: string }) =>
+            request<{ user: any; access_token: string }>('POST', '/auth/login', data),
+
+        /**
+         * Get current user
+         * @example const user = await api.auth.me()
+         */
+        me: () => request<any>('GET', '/auth/me'),
+    },
+
+    /**
+     * Users API
+     */
+    users: {
+        /**
+         * Get current user profile
+         * @example const profile = await api.users.me()
+         */
+        me: () => request<any>('GET', '/users/me'),
+    },
+
+    /**
+     * Todos API
+     */
+    todos: {
+        /**
+         * Get all todos
+         * @example const todos = await api.todos.findAll()
+         */
+        findAll: () => request<any[]>('GET', '/todos'),
+
+        /**
+         * Get single todo
+         * @example const todo = await api.todos.findOne('123')
+         */
+        findOne: (id: string) => request<any>('GET', `/todos/${id}`),
+
+        /**
+         * Create new todo
+         * @example await api.todos.create({ title: 'Task', description: 'Do it' })
+         */
+        create: (data: { title: string; description?: string }) =>
+            request<any>('POST', '/todos', data),
+
+        /**
+         * Update todo
+         * @example await api.todos.update('123', { completed: true })
+         */
+        update: (id: string, data: { title?: string; description?: string; completed?: boolean }) =>
+            request<any>('PUT', `/todos/${id}`, data),
+
+        /**
+         * Delete todo
+         * @example await api.todos.delete('123')
+         */
+        delete: (id: string) => request<void>('DELETE', `/todos/${id}`),
+    },
+};
+
+/**
+ * Export type-safe API
+ */
+export type API = typeof api;

package/templates/docker-compose.yml

@@ -0,0 +1,34 @@
+version: '3.8'
+
+services:
+  # WEXTS Application
+  app:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    ports:
+      - "3000:3000"
+    environment:
+      - NODE_ENV=production
+      - DATABASE_URL=postgresql://wexts:wexts_password@postgres:5432/wexts_db
+      - JWT_SECRET=your-super-secret-jwt-key-change-this
+      - PORT=3000
+    depends_on:
+      - postgres
+    restart: unless-stopped
+
+  # PostgreSQL Database
+  postgres:
+    image: postgres:16-alpine
+    ports:
+      - "5432:5432"
+    environment:
+      - POSTGRES_USER=wexts
+      - POSTGRES_PASSWORD=wexts_password
+      - POSTGRES_DB=wexts_db
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+    restart: unless-stopped
+
+volumes:
+  postgres_data:

package/templates/nestjs-api/src/auth/auth.controller.ts

@@ -1,27 +1,24 @@
-import { Controller, Post, Get, Body, UseGuards, Request } from '@nestjs/common';
-import { FusionController as WextsController, FusionPost as WextsPost, FusionGet as WextsGet } from 'wexts/nest';
+import { Controller, Post, Get, Body, UseGuards, Request, Inject } from '@nestjs/common';
 import { AuthService } from './auth.service';
 import { JwtAuthGuard } from './guards/jwt-auth.guard';
 import { RegisterDto, LoginDto } from './dto/auth.dto';
 
-@WextsController('auth')
 @Controller('auth')
 export class AuthController {
-    constructor(private authService: AuthService) { }
+    constructor(
+        @Inject(AuthService) private readonly authService: AuthService
+    ) { }
 
-    @WextsPost()
     @Post('register')
     async register(@Body() dto: RegisterDto) {
         return this.authService.register(dto);
     }
 
-    @WextsPost()
     @Post('login')
     async login(@Body() dto: LoginDto) {
         return this.authService.login(dto);
     }
 
-    @WextsGet()
     @Get('me')
     @UseGuards(JwtAuthGuard)
     async getMe(@Request() req) {

package/templates/nestjs-api/src/auth/auth.module.ts

@@ -1,13 +1,16 @@
 import { Module } from '@nestjs/common';
 import { JwtModule } from '@nestjs/jwt';
 import { PassportModule } from '@nestjs/passport';
-import { ConfigService } from '@nestjs/config';
+import { ConfigModule, ConfigService } from '@nestjs/config';
 import { AuthController } from './auth.controller';
 import { AuthService } from './auth.service';
 import { JwtStrategy } from './strategies/jwt.strategy';
+import { PrismaModule } from '../prisma/prisma.module';
 
 @Module({
     imports: [
+        PrismaModule, // ✅ Important: Import PrismaModule
+        ConfigModule,
         PassportModule,
         JwtModule.registerAsync({
             inject: [ConfigService],

package/templates/nestjs-api/src/auth/auth.service.ts

@@ -1,18 +1,17 @@
-import { Injectable, UnauthorizedException } from '@nestjs/common';
+import { Injectable, UnauthorizedException, Inject } from '@nestjs/common';
 import { JwtService } from '@nestjs/jwt';
 import { PrismaService } from '../prisma/prisma.service';
-import * as bcrypt from 'bcrypt';
+import * as bcrypt from 'bcryptjs';
 import { RegisterDto, LoginDto } from './dto/auth.dto';
 
 @Injectable()
 export class AuthService {
     constructor(
-        private prisma: PrismaService,
-        private jwtService: JwtService,
+        @Inject(PrismaService) private readonly prisma: PrismaService,
+        @Inject(JwtService) private readonly jwtService: JwtService,
     ) { }
 
     async register(dto: RegisterDto) {
-        // Check if user exists
         const exists = await this.prisma.user.findUnique({
             where: { email: dto.email },
         });
@@ -21,10 +20,8 @@ export class AuthService {
             throw new UnauthorizedException('Email already registered');
         }
 
-        // Hash password
         const hashedPassword = await bcrypt.hash(dto.password, 10);
 
-        // Create user
         const user = await this.prisma.user.create({
             data: {
                 email: dto.email,
@@ -39,13 +36,12 @@ export class AuthService {
             },
         });
 
-        const token = this.generateToken(user.id, user.email);
+        const access_token = this.generateToken(user.id, user.email);
 
-        return { user, token };
+        return { user, access_token };
     }
 
     async login(dto: LoginDto) {
-        // Find user
         const user = await this.prisma.user.findUnique({
             where: { email: dto.email },
         });
@@ -54,14 +50,13 @@ export class AuthService {
             throw new UnauthorizedException('Invalid credentials');
         }
 
-        // Verify password
         const valid = await bcrypt.compare(dto.password, user.password);
 
         if (!valid) {
             throw new UnauthorizedException('Invalid credentials');
         }
 
-        const token = this.generateToken(user.id, user.email);
+        const access_token = this.generateToken(user.id, user.email);
 
         return {
             user: {
@@ -69,7 +64,7 @@ export class AuthService {
                 email: user.email,
                 name: user.name,
             },
-            token,
+            access_token,
         };
     }
 

package/templates/nestjs-api/src/todos/todos.controller.ts

@@ -1,34 +1,28 @@
 import { Controller, Get, Post, Put, Delete, Body, Param, UseGuards, Request } from '@nestjs/common';
-import { FusionController as WextsController, FusionGet as WextsGet, FusionPost as WextsPost, FusionPut as WextsPut, FusionDelete as WextsDelete } from 'wexts/nest';
 import { JwtAuthGuard } from '../auth/guards/jwt-auth.guard';
 import { TodosService } from './todos.service';
 import { CreateTodoDto, UpdateTodoDto } from './dto/todo.dto';
 
-@WextsController('todos')
 @Controller('todos')
 @UseGuards(JwtAuthGuard)
 export class TodosController {
     constructor(private todosService: TodosService) { }
 
-    @WextsGet()
     @Get()
     async findAll(@Request() req) {
         return this.todosService.findAll(req.user.userId);
     }
 
-    @WextsGet()
     @Get(':id')
     async findOne(@Param('id') id: string, @Request() req) {
         return this.todosService.findOne(id, req.user.userId);
     }
 
-    @WextsPost()
     @Post()
     async create(@Body() dto: CreateTodoDto, @Request() req) {
         return this.todosService.create(dto, req.user.userId);
     }
 
-    @WextsPut()
     @Put(':id')
     async update(
         @Param('id') id: string,
@@ -38,7 +32,6 @@ export class TodosController {
         return this.todosService.update(id, dto, req.user.userId);
     }
 
-    @WextsDelete()
     @Delete(':id')
     async remove(@Param('id') id: string, @Request() req) {
         return this.todosService.remove(id, req.user.userId);

package/templates/nestjs-api/src/todos/todos.module.ts

@@ -1,8 +1,10 @@
 import { Module } from '@nestjs/common';
-import { TodosController } from './todos.controller';
 import { TodosService } from './todos.service';
+import { TodosController } from './todos.controller';
+import { PrismaModule } from '../prisma/prisma.module';
 
 @Module({
+    imports: [PrismaModule], // ✅ Import PrismaModule
     controllers: [TodosController],
     providers: [TodosService],
 })

package/templates/nestjs-api/src/users/users.controller.ts

@@ -1,15 +1,12 @@
 import { Controller, Get, UseGuards, Request } from '@nestjs/common';
-import { FusionController as WextsController, FusionGet as WextsGet } from 'wexts/nest';
 import { JwtAuthGuard } from '../auth/guards/jwt-auth.guard';
 import { UsersService } from './users.service';
 
-@WextsController('users')
 @Controller('users')
 @UseGuards(JwtAuthGuard)
 export class UsersController {
     constructor(private usersService: UsersService) { }
 
-    @WextsGet()
     @Get('me')
     async getMe(@Request() req) {
         return this.usersService.findById(req.user.userId);

package/templates/nestjs-api/src/users/users.module.ts

@@ -1,8 +1,10 @@
 import { Module } from '@nestjs/common';
-import { UsersController } from './users.controller';
 import { UsersService } from './users.service';
+import { UsersController } from './users.controller';
+import { PrismaModule } from '../prisma/prisma.module';
 
 @Module({
+    imports: [PrismaModule], // ✅ Import PrismaModule
     controllers: [UsersController],
     providers: [UsersService],
     exports: [UsersService],

package/templates/nextjs-web/app/actions/auth.ts

@@ -2,8 +2,7 @@
 
 import { cookies } from 'next/headers';
 import { redirect } from 'next/navigation';
-
-const API_URL = process.env.NEXT_PUBLIC_API_URL || 'http://localhost:5050';
+import { api } from '@/lib/api';
 
 export type ActionState = {
     message?: string;
@@ -32,23 +31,10 @@ export async function loginAction(prevState: ActionState, formData: FormData): P
     }
 
     try {
-        const response = await fetch(`${API_URL}/auth/login`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify({ email, password }),
-        });
-
-        const data = await response.json();
-
-        if (!response.ok) {
-            return {
-                message: data.message || 'Invalid credentials',
-            };
-        }
+        // Use SDK - no URLs needed!
+        const data = await api.auth.login({ email, password });
 
-        // Assuming the API returns { access_token: string }
+        // Store JWT token
         if (data.access_token) {
             const cookieStore = await cookies();
             cookieStore.set('wexts_token', data.access_token, {
@@ -62,10 +48,53 @@ export async function loginAction(prevState: ActionState, formData: FormData): P
                 message: 'Login failed: No token received',
             };
         }
-    } catch (error) {
+    } catch (error: any) {
         console.error('Login error:', error);
         return {
-            message: 'Something went wrong. Please try again.',
+            message: error.message || 'Invalid credentials',
+        };
+    }
+
+    redirect('/dashboard');
+}
+
+export async function registerAction(prevState: ActionState, formData: FormData): Promise<ActionState> {
+    const email = formData.get('email') as string;
+    const password = formData.get('password') as string;
+    const name = formData.get('name') as string;
+
+    const errors: { email?: string[]; password?: string[] } = {};
+
+    if (!email || !email.includes('@')) {
+        errors.email = ['Invalid email address'];
+    }
+
+    if (!password || password.length < 6) {
+        errors.password = ['Password must be at least 6 characters'];
+    }
+
+    if (Object.keys(errors).length > 0) {
+        return { errors };
+    }
+
+    try {
+        // Use SDK - no URLs needed!
+        const data = await api.auth.register({ email, password, name });
+
+        // Store JWT token
+        if (data.access_token) {
+            const cookieStore = await cookies();
+            cookieStore.set('wexts_token', data.access_token, {
+                httpOnly: true,
+                secure: process.env.NODE_ENV === 'production',
+                maxAge: 60 * 60 * 24 * 7,
+                path: '/',
+            });
+        }
+    } catch (error: any) {
+        console.error('Register error:', error);
+        return {
+            message: error.message || 'Registration failed',
         };
     }