Code Editor Guide

The Stellify Code Editor works like VSCode, providing a familiar environment for writing backend code. Code is stored as structured data in the database, allowing for visual editing, AI assistance, and export to PHP files.

Overview

The Code Editor is designed to feel identical to VSCode:

• Syntax highlighting
• Code completion
• Error detection
• File navigation
• Multiple tabs
• Keyboard shortcuts

Getting Started

Opening the Code Editor

1. Navigate to Files in your project
2. Click on a Controller, Model, or Class to edit
3. Or click New File to create one

The editor opens with your selected file.

Editor Layout

┌─────────────────────────────────────────────────────┐
│  File Tabs (Home.php, UserController.php, ...)      │
├──────────────┬────────────────────────────────────────┤
│              │                                        │
│  File Tree   │   Editor Pane                         │
│              │                                        │
│  Controllers │   <?php                               │
│  ├─ Home     │                                        │
│  ├─ User     │   namespace App\Controllers;          │
│  └─ Auth     │                                        │
│              │   class UserController {              │
│  Models      │       public function index() {       │
│  ├─ User     │           // Your code here           │
│  ├─ Post     │       }                                │
│  └─ Comment  │   }                                    │
│              │                                        │
└──────────────┴────────────────────────────────────────┘

File Structure

Controllers

Controllers handle HTTP requests and return responses.

Creating a Controller:

1. Click New File → Controller
2. Name your controller (e.g., UserController)
3. Choose namespace (default: App\Http\Controllers)

Basic structure:

<?php

namespace App\Http\Controllers;

use App\Models\User;
use Illuminate\Http\Request;

class UserController extends Controller
{
    public function index()
    {
        $users = User::all();
        return view('users.index', ['users' => $users]);
    }

    public function store(Request $request)
    {
        $validated = $request->validate([
            'name' => 'required|string|max:255',
            'email' => 'required|email|unique:users'
        ]);

        User::create($validated);

        return redirect()->route('users.index');
    }
}

Models

Models represent database tables and handle data logic.

Creating a Model:

1. Click New File → Model
2. Name your model (singular, e.g., User)
3. Stellify creates standard Eloquent model structure

Basic structure:

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class User extends Model
{
    protected $fillable = ['name', 'email', 'password'];

    protected $hidden = ['password', 'remember_token'];

    // Relationships
    public function posts()
    {
        return $this->hasMany(Post::class);
    }

    // Accessors
    public function getFullNameAttribute()
    {
        return "{$this->first_name} {$this->last_name}";
    }
}

Custom Classes

For services, helpers, and other classes.

Creating a Class:

1. Click New File → Class
2. Name your class (e.g., EmailService)
3. Choose namespace

Example:

<?php

namespace App\Services;

use Illuminate\Support\Facades\Mail;

class EmailService
{
    public function sendWelcomeEmail($user)
    {
        Mail::to($user->email)->send(new WelcomeEmail($user));
    }
}

Writing Code

Methods

Methods are the core unit of code in Stellify.

Adding a method:

1. Open a file in the editor
2. Place cursor where you want the method
3. Type the method signature
4. Write your code

Syntax:

public function methodName($param1, $param2)
{
    // Method body
    // Code stored as structured data
    // But written like normal PHP
}

Code Completion

The editor provides intelligent autocompletion:

Type hints:

• Type $this-> → See class methods and properties
• Type $request-> → See Request methods
• Type User:: → See model methods

Laravel helpers:

• request() - Current request
• auth() - Authentication
• session() - Session data
• config() - Configuration
• route() - Named routes
• view() - Views

Imports

Add use statements at the top of your file:

use App\Models\User;
use App\Models\Post;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;

The editor auto-suggests available classes when you type use.

Working with Databases

Query Builder

Use Laravel's query builder:

// Select all users
$users = DB::table('users')->get();

// Where clause
$activeUsers = DB::table('users')
    ->where('active', true)
    ->get();

// Joins
$posts = DB::table('posts')
    ->join('users', 'posts.user_id', '=', 'users.id')
    ->select('posts.*', 'users.name')
    ->get();

Eloquent ORM

Preferred method for database operations:

// Find by ID
$user = User::find(1);

// Find or fail
$user = User::findOrFail($id);

// Create
$user = User::create([
    'name' => 'John Doe',
    'email' => 'john@example.com'
]);

// Update
$user->update(['name' => 'Jane Doe']);

// Delete
$user->delete();

// Relationships
$user->posts; // Get user's posts
$post->user; // Get post's author

Configuring Database

Your database connection is configured in Settings:

1. Navigate to Settings → Database
2. Enter connection details
3. Test connection
4. Save configuration

The editor uses your configured connection when executing code.

Testing Code

Running Methods

Execute code directly in the platform:

1. Open a file with methods
2. Select a method
3. Click Run button
4. View output in console

Example:

public function test()
{
    $users = User::all();
    return $users; // View in console
}

Debug Output

Use Laravel's debugging helpers:

// Dump and die
dd($variable);

// Dump without stopping
dump($variable);

// Log to file
\Log::info('Debug message', ['data' => $data]);

Output appears in the console panel.

Validation Testing

Test form validation:

public function store(Request $request)
{
    $validated = $request->validate([
        'name' => 'required|string|max:255',
        'email' => 'required|email|unique:users',
        'age' => 'required|integer|min:18'
    ]);

    // If validation passes, code continues
    return User::create($validated);
}

Send test data to see validation in action.

Keyboard Shortcuts

| Shortcut | Action | |----------|--------| | Ctrl/Cmd + S | Save file | | Ctrl/Cmd + F | Find in file | | Ctrl/Cmd + H | Find and replace | | Ctrl/Cmd + / | Comment/uncomment line | | Ctrl/Cmd + D | Duplicate line | | Ctrl/Cmd + X | Cut line | | Alt + Up/Down | Move line up/down | | Ctrl/Cmd + Space | Trigger autocomplete | | Ctrl/Cmd + Click | Go to definition | | Ctrl/Cmd + P | Quick file open |

Code Organization

Namespaces

Use PSR-4 namespaces:

// Controllers
namespace App\Http\Controllers;

// Models
namespace App\Models;

// Services
namespace App\Services;

// Custom packages
namespace App\MyPackage;

Including Files

Import classes you need:

use App\Models\User;
use App\Services\EmailService;
use Illuminate\Support\Facades\Log;

class UserController extends Controller
{
    public function __construct(
        private EmailService $emailService
    ) {}
}

Working with Routes

Defining Routes

Routes connect URLs to your controller methods.

In Routes panel:

1. Click New Route
2. Enter path: /users
3. Method: GET
4. Controller: UserController
5. Method: index

Result:

Route::get('/users', [UserController::class, 'index'])
    ->name('users.index');

Route Parameters

Accept dynamic segments:

// Route: /users/{id}
public function show($id)
{
    $user = User::findOrFail($id);
    return view('users.show', ['user' => $user]);
}

// Route: /posts/{post}/comments/{comment}
public function showComment(Post $post, Comment $comment)
{
    // Laravel automatically resolves models
    return view('comments.show', [
        'post' => $post,
        'comment' => $comment
    ]);
}

Advanced Features

Middleware

Apply middleware to protect routes:

public function __construct()
{
    $this->middleware('auth');
    $this->middleware('admin')->only(['destroy']);
}

Dependency Injection

Laravel automatically injects dependencies:

public function store(Request $request, EmailService $emailService)
{
    $user = User::create($request->validated());
    $emailService->sendWelcomeEmail($user);
    return redirect()->route('users.index');
}

Form Requests

Create custom validation:

public function store(StoreUserRequest $request)
{
    // Validation handled by StoreUserRequest
    User::create($request->validated());
    return redirect()->route('users.index');
}

Jobs & Queues

Dispatch background jobs:

use App\Jobs\ProcessUpload;

public function upload(Request $request)
{
    $file = $request->file('upload');

    // Queue for background processing
    ProcessUpload::dispatch($file);

    return response()->json(['status' => 'processing']);
}

Error Handling

Try-Catch Blocks

Handle exceptions gracefully:

public function store(Request $request)
{
    try {
        $user = User::create($request->validated());
        return redirect()->route('users.show', $user);
    } catch (\Exception $e) {
        \Log::error('User creation failed', [
            'error' => $e->getMessage()
        ]);
        return back()->withErrors(['error' => 'Failed to create user']);
    }
}

Validation Errors

Laravel handles validation errors automatically:

$request->validate([
    'email' => 'required|email|unique:users'
]);

// If validation fails:
// - User redirected back
// - Errors available in session
// - Old input preserved

Code Storage

How It Works

Your code is stored as structured data:

• Statements - Individual lines/expressions
• Clauses - Tokens and operations
• Methods - Function definitions

Benefits:

• Visual editing capabilities
• AI can understand and modify code
• Export to clean PHP files
• Version control at granular level

Editing Modes

Visual Mode:

• Click on code elements
• Edit properties in sidebar
• Drag to reorder statements

Text Mode (default):

• Type code naturally
• Saved as structured data
• Exported as PHP

Best Practices

Code Style

Follow PSR-12 standards:

// Good
public function store(Request $request)
{
    $user = User::create($request->validated());
    return redirect()->route('users.index');
}

// Avoid
public function store(Request $request){
$user=User::create($request->validated());
return redirect()->route('users.index');}

Method Naming

Use descriptive names:

// Good
public function activateUser($userId)
public function sendPasswordResetEmail($email)

// Avoid
public function doStuff($id)
public function process($data)

Comments

Add comments for complex logic:

// Calculate discount based on user tier and order total
$discount = $this->calculateTieredDiscount($user, $orderTotal);

// Process payment through configured gateway
$payment = $this->processPayment($order, $paymentMethod);

Security

Always validate input:

// Validate user input
$validated = $request->validate([
    'email' => 'required|email',
    'password' => 'required|min:8'
]);

// Use mass assignment protection
protected $fillable = ['name', 'email'];

// Hash passwords
$user->password = Hash::make($request->password);

Troubleshooting

Code not saving?

• Check for syntax errors
• Ensure proper permissions
• Try refreshing the editor

Autocompletion not working?

• Wait for initial load to complete
• Check internet connection
• Clear browser cache

Method not executing?

• Verify database connection
• Check method signature
• Review error logs in console

Import errors?

• Ensure class exists
• Check namespace spelling
• Verify use statements

Exporting Code

When ready to deploy:

1. Click Export in the editor
2. Choose export format
3. Download PHP files
4. Deploy to your server

See Exporting Code Guide for details.

Video Tutorial

Coming Soon: Code Editor walkthrough video

Next Steps

• Learn about Interface Builder for frontend
• Read Configuration Guide for settings
• Explore Importing Code to bring in existing files

---

Need help? Check the API documentation or contact support.