import { WebApplication, BaseController } from '@blendsdk/webafx';

const app = new WebApplication({ PORT: 3000 });

class UserController extends BaseController {
  routes() {
    return [
      this.route().get('/').handle(this.list),
      this.authenticated().post('/').handle(this.create),
    ];
  }
}

app.registerController('/api/users', UserController);
await app.start();

import { PostgreSQLDatabase } from '@blendsdk/postgresql';

const db = new PostgreSQLDatabase({
  host: 'localhost',
  database: 'myapp',
  user: 'postgres',
  password: 'secret',
});

await db.connect();
const users = await db.query('SELECT * FROM users WHERE active = $1', [true]);
await db.shutdown();

import { SelectStatement } from '@blendsdk/dbcore';

const query = new SelectStatement()
  .from('users')
  .select('id', 'email', 'name')
  .where('active = $1', true)
  .orderBy('created_at DESC')
  .limit(10);

const { sql, params } = query.compile();

import { query } from '@blendsdk/expression';

const result = query()
  .where('status')
  .equals('active')
  .and(q => q.where('age').greaterThan(21).or('verified').equals(true))
  .compile();

// Output: { sql: "status = $1 AND (age > $2 OR verified = $3)", params: {...} }

import { SchemaContainer, TypeGenerator } from '@blendsdk/codegen';

const schema = new SchemaContainer();
const s = schema.scope('api');

const User = s
  .object({
    id: s.number(),
    email: s.string(),
    role: s.string().enum(['admin', 'user']),
  })
  .named('User');

const typeGen = new TypeGenerator();
const tsCode = await typeGen.generate(schema);

import { compileExpression, evaluateExpression } from '@blendsdk/blendscript';

const compiled = compileExpression('Country == "NL" AND Enabled == TRUE', {
  schema: {
    Country: { type: 'string' },
    Enabled: { type: 'boolean' },
  },
  expectedResult: 'boolean',
});

if (compiled.ok) {
  const result = evaluateExpression(compiled.expression, {
    Country: 'NL',
    Enabled: true,
  });
}

import { isString, isNumber, isDefined } from '@blendsdk/stdlib';

if (isString(value)) {
  console.log(value.toUpperCase()); // TypeScript knows value is string
}

import { CommandLineParser } from '@blendsdk/cmdline';

const parser = new CommandLineParser()
  .option('--port', { type: 'number', default: 3000 })
  .option('--env', { type: 'string', choices: ['dev', 'prod'] })
  .flag('--verbose');

const args = parser.parse(process.argv);
console.log(`Starting on port ${args.port}`);

import { WebApplication, BaseController } from '@blendsdk/webafx';
import { PostgreSQLDatabase } from '@blendsdk/postgresql';

const app = new WebApplication({ PORT: 3000 });

// Register database service
app.registerService({
  name: 'db',
  type: 'singleton',
  factory: async () => {
    const db = new PostgreSQLDatabase({/* config */});
    await db.connect();
    return db;
  },
});

// Create controller
class UserController extends BaseController {
  routes() {
    return [this.route().get('/').handle(this.list)];
  }

  async list(req, res) {
    const db = await req.services.get('db');
    const users = await db.query('SELECT * FROM users');
    res.json(users);
  }
}

app.registerController('/api/users', UserController);

const shutdown = await app.start();
console.log('Server running on http://localhost:3000');

process.on('SIGTERM', shutdown);

import { PostgreSQLDatabase } from '@blendsdk/postgresql';
import { SelectStatement } from '@blendsdk/dbcore';
import { query } from '@blendsdk/expression';

const db = new PostgreSQLDatabase({/* config */});
await db.connect();

// Using raw queries
const result = await db.query('SELECT * FROM users WHERE id = $1', [123]);

// Using statement builders
const stmt = new SelectStatement()
  .from('users')
  .select('*')
  .where(query().where('active').equals(true).and('role').in(['admin', 'user']).compile());

const { sql, params } = stmt.compile();
const users = await db.query(sql, Object.values(params));

import { SchemaContainer, TypeGenerator, ZodGenerator } from '@blendsdk/codegen';

const schema = new SchemaContainer();
const s = schema.scope('api');

// Define schema
const User = s
  .object({
    id: s.number(),
    email: s.string(),
    name: s.string().optional(),
    roles: s.string().arrayed(),
  })
  .named('User');

// Generate TypeScript types
const typeGen = new TypeGenerator();
const types = await typeGen.generate(schema);
console.log(types);
// export interface User {
//   id: number;
//   email: string;
//   name?: string;
//   roles: string[];
// }

// Generate Zod schemas
const zodGen = new ZodGenerator();
const schemas = await zodGen.generate(schema);
console.log(schemas);
// export const UserSchema = z.object({
//   id: z.number(),
//   email: z.string(),
//   name: z.string().optional(),
//   roles: z.array(z.string())
// });