wexts 2.0.9 → 3.0.1

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',
         };
     }
 

package/templates/nextjs-web/lib/api.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/nextjs-web/next-env.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="next" />
 /// <reference types="next/image-types/global" />
-import "./.next/dev/types/routes.d.ts";
+import "./.next/dev/types/routes.js";
 
 // NOTE: This file should not be edited
 // see https://nextjs.org/docs/app/api-reference/config/typescript for more information.

package/templates/nixpacks.toml

@@ -0,0 +1,11 @@
+[phases.setup]
+nixPacks = ["nodejs-20", "pnpm"]
+
+[phases.install]
+cmds = ["pnpm install"]
+
+[phases.build]
+cmds = ["pnpm run build"]
+
+[start]
+cmd = "pnpm start"

package/templates/root-package.json

@@ -0,0 +1,32 @@
+{
+    "name": "wexts-app",
+    "version": "1.0.0",
+    "private": true,
+    "scripts": {
+        "dev": "tsx server.ts",
+        "build": "pnpm run build:api && pnpm run build:web && pnpm run build:server",
+        "build:api": "cd apps/api && npm run build",
+        "build:web": "cd apps/web && npm run build",
+        "build:server": "tsc",
+        "start": "node dist/server.js",
+        "postinstall": "cd apps/api && npx prisma generate"
+    },
+    "dependencies": {
+        "@nestjs/common": "^11.0.0",
+        "@nestjs/core": "^11.0.0",
+        "@nestjs/platform-express": "^11.1.9",
+        "express": "^5.1.0",
+        "next": "16.0.0",
+        "react": "^19.0.0",
+        "react-dom": "^19.0.0"
+    },
+    "devDependencies": {
+        "@types/express": "^4.17.21",
+        "@types/node": "^20.0.0",
+        "tsx": "^4.7.0",
+        "typescript": "^5.3.0"
+    },
+    "engines": {
+        "node": ">=18.0.0"
+    }
+}

package/templates/server.ts

@@ -0,0 +1,66 @@
+import express from 'express';
+import { NestFactory } from '@nestjs/core';
+import { ExpressAdapter } from '@nestjs/platform-express';
+import next from 'next';
+import path from 'path';
+
+const dev = process.env.NODE_ENV !== 'production';
+const port = parseInt(process.env.PORT || '3000', 10);
+
+async function bootstrap() {
+    console.log('🚀 Starting WEXTS Unified Server...\n');
+
+    // 1. Initialize Next.js
+    console.log('📦 Loading Next.js...');
+    const nextApp = next({
+        dev,
+        dir: path.join(__dirname, 'apps/web'),
+    });
+    await nextApp.prepare();
+    const nextHandler = nextApp.getRequestHandler();
+    console.log('✅ Next.js ready\n');
+
+    // 2. Initialize NestJS with Express
+    console.log('📦 Loading NestJS...');
+    const server = express();
+
+    // Import AppModule dynamically
+    const { AppModule } = dev
+        ? await import('./apps/api/src/app.module')
+        : await import('./apps/api/dist/app.module');
+
+    const app = await NestFactory.create(
+        AppModule,
+        new ExpressAdapter(server),
+        { cors: true }
+    );
+
+    app.setGlobalPrefix('api');
+
+    // Smart routing middleware - MUST be before NestJS init
+    server.use((req, res, next) => {
+        if (req.url.startsWith('/api')) {
+            return next(); // Let NestJS handle API routes
+        }
+        return nextHandler(req, res); // Next.js handles everything else
+    });
+
+    await app.init();
+    console.log('✅ NestJS ready\n');
+
+    // 3. Start server
+    server.listen(port, () => {
+        console.log('\n🎉 WEXTS Unified Server Running!');
+        console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+        console.log(`   🌐 Server: http://localhost:${port}`);
+        console.log(`   📱 Frontend: All routes except /api/*`);
+        console.log(`   🔌 Backend: /api/*`);
+        console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
+        console.log('✨ Routes are smartly separated!\n');
+    });
+}
+
+bootstrap().catch((err) => {
+    console.error('❌ Failed to start:', err);
+    process.exit(1);
+});

package/templates/tsconfig.json

@@ -0,0 +1,31 @@
+{
+    "compilerOptions": {
+        "target": "ES2020",
+        "module": "commonjs",
+        "lib": [
+            "ES2020"
+        ],
+        "experimentalDecorators": true,
+        "emitDecoratorMetadata": true,
+        "esModuleInterop": true,
+        "allowSyntheticDefaultImports": true,
+        "skipLibCheck": true,
+        "strict": false,
+        "forceConsistentCasingInFileNames": true,
+        "moduleResolution": "node",
+        "resolveJsonModule": true,
+        "outDir": "./dist",
+        "declaration": true,
+        "declarationMap": true,
+        "sourceMap": true
+    },
+    "include": [
+        "server.ts",
+        "apps/api/src/**/*"
+    ],
+    "exclude": [
+        "node_modules",
+        "dist",
+        "apps/web"
+    ]
+}