import { Route } from '@pondoknusa/core';
import { Response } from '@pondoknusa/http';
import { UserController } from '../controllers/user-controller.js';
import { StoreUserRequest } from '../requests/store-user-request.js';

// Basic route
Route.get('/', (request) => Response.json({ message: 'Welcome to Pondoknusa', path: request.path }));

// Route groups with middleware and prefixes
Route.prefix('api/v1')
  .middleware('auth:api')
  .group(() => {
    Route.get('/users', [UserController, 'index']).name('users.index');
    Route.post('/users', [UserController, 'store', StoreUserRequest]).name('users.store');
    
    // Implicit Route Model Binding
    Route.get('/users/{user}', [UserController, 'show']).name('users.show');
  });

// Signed URL generation
const signedUrl = Route.signed('verify.email', { user: 1 }, { expiresIn: 3600 });

import { FormRequest } from '@pondoknusa/core';
import { User } from '../models/user.js';

export class StoreUserRequest extends FormRequest<{ name: string; email: string; role: string }> {
  async authorize(): Promise<boolean> {
    return this.authorizePolicy('create', User);
  }

  rules() {
    return {
      name: ['required', 'string', 'min_length:2'],
      email: ['required', 'email', 'unique:users,email'],
      role: ['required', 'in:admin,editor,member'],
    };
  }
}

import { JsonResource } from '@pondoknusa/http';
import type { PondoknusaRequest } from '@pondoknusa/http';
import { User } from '../models/user.js';

export class UserResource extends JsonResource<User> {
  toArray(_request?: PondoknusaRequest) {
    return {
      id: this.resource.getAttribute('id'),
      name: this.resource.getAttribute('name'),
      email: this.resource.getAttribute('email'),
      created_at: this.resource.getAttribute('created_at'),
    };
  }
}

// In controller:
return UserResource.make(user);                        // Wrapped in { data: ... }
return UserResource.collection(users);                 // Collection
return UserResource.collection(await User.paginate()); // Paginated collection with meta & links

import { Model } from '@pondoknusa/database';
import type { ModelQueryBuilder } from '@pondoknusa/database';
import { Post } from './post.js';

export interface UserAttributes {
  id: number;
  name: string;
  email: string;
  active: boolean;
  settings: Record<string, unknown>;
}

export class User extends Model<UserAttributes> {
  static override table = 'users';
  static override casts = {
    active: 'boolean',
    settings: 'json',
  };

  // Query Scope
  static scopeActive(builder: ModelQueryBuilder): ModelQueryBuilder {
    return builder.where('active', true);
  }

  // Relations
  posts() {
    return this.hasMany(Post, 'user_id');
  }
}

// Queries
const users = await User.scope('active').orderBy('created_at', 'desc').getModels();
const user = await User.find(1);
const posts = await user.posts().get();
const newPost = await user.posts().create({ title: 'Hello World', body: '...' });

// Pagination
const page = await User.query().paginate(15, 1);

import { Schema } from '@pondoknusa/database';

export async function up(schema: Schema): Promise<void> {
  await schema.create('users', (table) => {
    table.id();
    table.string('name');
    table.string('email').unique();
    table.boolean('active').default(true);
    table.json('settings').nullable();
    table.timestamps();
  });
}

import { collect } from '@pondoknusa/collection';

const staff = collect([
  { id: 1, name: 'Ada Lovelace', role: 'admin', points: 120 },
  { id: 2, name: 'Grace Hopper', role: 'editor', points: 95 },
  { id: 3, name: 'Alan Turing', role: 'admin', points: 150 },
]);

const adminTotal = staff
  .filter(u => u.role === 'admin')
  .sortByDesc('points')
  .sum('points'); // 270

const grouped = staff.groupBy('role');
// Collection: { admin: [...], editor: [...] }

import { Job } from '@pondoknusa/queue';
import { dispatch, Queue } from '@pondoknusa/core';

export class ProcessReportJob extends Job<{ reportId: number }> {
  override async handle(): Promise<void> {
    const { reportId } = this.data;
    // Execute expensive calculation
  }
}

// Dispatch immediately or delayed
await dispatch(new ProcessReportJob({ reportId: 42 }));
await Queue.later(60, new ProcessReportJob({ reportId: 42 }));

import { Event, Listener, QueuedListener } from '@pondoknusa/events';
import { Events } from '@pondoknusa/core';

export class OrderPlaced extends Event<{ orderId: number; amount: number }> {}

// Background queued listener
export class SendOrderConfirmation extends QueuedListener<OrderPlaced> {
  static override queue = 'emails';

  override async handle(event: OrderPlaced): Promise<void> {
    // Sends confirmation email asynchronously
  }
}

await Events.dispatch(new OrderPlaced({ orderId: 101, amount: 49.99 }));

import { inferenceChat, streamInferenceChat, registerInferenceProvidersFromEnv } from '@pondoknusa/inference';

// Auto-registers all providers found in .env (OpenAI, Anthropic, Gemini, DeepSeek, Groq, Ollama, etc.)
registerInferenceProvidersFromEnv();

// Simple chat completion
const response = await inferenceChat([
  { role: 'system', content: 'You are a helpful assistant.' },
  { role: 'user', content: 'Explain post-quantum cryptography briefly.' },
], { provider: 'deepseek', model: 'deepseek-chat' });

console.log(response.content);

// Streaming response
for await (const delta of streamInferenceChat(messages, { provider: 'openai' })) {
  process.stdout.write(delta);
}

import { VectorStore } from '@pondoknusa/vector';
import { RagPipeline } from '@pondoknusa/rag';

// Search vector database
const matches = await VectorStore.connection('pgvector').search('embeddings_table', queryVector, {
  limit: 5,
  similarity: 'cosine',
});

// Grounded RAG prompt construction
const rag = new RagPipeline();
const groundedPrompt = await rag.buildContext(userQuestion, matches);

import { Auth, Gate, Password } from '@pondoknusa/core';

// Session login
await Auth.attempt({ email: 'ada@example.com', password: 'secret-password' });

// API tokens (hashed at rest with tyr_ prefix)
const token = await Auth.createToken('cli-token', ['read:reports'], { expiresIn: '30d' });

// Gate authorization
await Gate.authorize(Auth.user(), 'update', document);

// Server: src/events/message-sent.ts
import { Event } from '@pondoknusa/events';

export class MessageSent extends Event<{ message: string; from: string }> {
  broadcastOn() {
    return ['chat-room'];
  }
}

// Browser: Native WebSocket Echo client (zero third-party deps)
import { Echo } from '@pondoknusa/echo';

const echo = new Echo({
  broadcaster: 'websocket',
  wsHost: window.location.hostname,
  wsPort: 3000,
});

echo.channel('chat-room').listen('MessageSent', (event) => {
  console.log(`${event.from}: ${event.message}`);
});

import { Cache, Mail, Notifications, Storage } from '@pondoknusa/core';
import { InvoicePaidNotification } from '../notifications/invoice-paid.js';
import { WelcomeMail } from '../mail/welcome-mail.js';

// Cache with stampede protection & tagging
const stats = await Cache.tags(['analytics']).remember('daily_summary', 3600, async () => {
  return computeAnalytics();
});

// Mail (log, array, SMTP)
await Mail.to('user@example.com').send(new WelcomeMail(user));

// Multi-channel Notifications (database, mail, Slack, SMS)
await Notifications.send(user, new InvoicePaidNotification(invoice));

// Cloud & local filesystem storage
await Storage.disk('s3').put('reports/annual.pdf', fileBuffer);
const url = await Storage.disk('s3').temporaryUrl('reports/annual.pdf', 300);

import { TestCase, withPondoknusaTest, mailFake } from '@pondoknusa/testing';

class UserTest extends TestCase {}
const t = withPondoknusaTest(UserTest);

it('creates a user and sends welcome mail', async () => {
  const mail = mailFake();

  const response = await t.http.post('/api/v1/users', {
    json: { name: 'Ada Lovelace', email: 'ada@example.com' },
  });

  await response.assertStatus(201).assertJsonPath('data.name', 'Ada Lovelace');
  mail.assertSent(WelcomeMail);
});