Benchmarks

def rows
  return (0..50).map(fn(i) {
    return { "id": i + 1, "title": "Post title #{i + 1}", "views": (i + 1) * 7 }
  })
end

def json_only
  render_json(this.rows())
end

def rows
  (1..50).map { |i| { id: i, title: "Post title #{i}", views: i * 7 } }
end

def json_only
  render json: rows
end

const rows = () =>
  Array.from({ length: 50 }, (_, i) =>
    ({ id: i + 1, title: `Post title ${i + 1}`, views: (i + 1) * 7 }));

app.get('/json', (req, res) => res.json(rows()));

private rows() {
  return Array.from({ length: 50 }, (_, i) => ({
    id: i + 1, title: `Post title ${i + 1}`, views: (i + 1) * 7,
  }))
}

async jsonOnly({ response }: HttpContext) {
  return response.json(this.rows())
}

private function rows(): array
{
    $out = [];
    for ($i = 1; $i <= 50; $i++) {
        $out[] = (object) ['id' => $i, 'title' => "Post title {$i}", 'views' => $i * 7];
    }
    return $out;
}

public function jsonOnly() { return response()->json($this->rows()); }

def _rows():
    return [{"id": i, "title": f"Post title {i}", "views": i * 7} for i in range(1, 51)]


def json_only(request):
    # compact separators, or the payload is 299 bytes larger than everyone else's
    return JsonResponse(_rows(), safe=False, json_dumps_params={"separators": (",", ":")})

def template_only
  render("posts/list", { "title": "Posts", "items": this.rows() })
end

def template_only
  @title = "Posts"
  render "posts/list", locals: { items: rows }
end

app.get('/template', (req, res) =>
  res.type('html').send(layout({ title: 'Posts', body: list({ items: rows() }) })));

async templateOnly({ view }: HttpContext) {
  return view.render('posts/list', { title: 'Posts', items: this.rows() })
}

public function templateOnly()
{
    return view('posts.list', ['title' => 'Posts', 'items' => $this->rows()]);
}

def template_only(request):
    return render(request, "posts/list.html", {"title": "Posts", "items": _rows()})

# The builder is bound to a local BEFORE render_json: passed inline as a call
# argument it is evaluated twice and the query goes out twice.
def db_json
  let rows = Post.pluck(:id, :title, :views).all
  return render_json(rows)
end

# pluck returns arrays, so the map is what makes the payload match the others.
def db_json
  render json: Post.pluck(:id, :title, :views)
    .map { |id, title, views| { id: id, title: title, views: views } }
end

// raw: true projects without instantiating models — the analogue of pluck.
const ORM_PROJECTION = { attributes: ['id', 'title', 'views'], raw: true };

app.get('/db', async (req, res) => res.json(await PostModel.findAll(ORM_PROJECTION)));

// Projection without hydrating models — the Lucid analogue of pluck.
// node-postgres renders int8 as a string, and the primary key is bigint, so
// start/pg_types.ts registers a parser or the payload stops matching.
private dbRows() {
  return db.from('posts').select('id', 'title', 'views')
}

async dbJson({ response }: HttpContext) {
  return response.json(await this.dbRows())
}

// toBase() is Eloquent's own way to project without hydrating models.
private function dbRows()
{
    return Post::query()->toBase()->select('id', 'title', 'views')->get();
}

public function dbJson() { return response()->json($this->dbRows()); }

# .values() projects without instantiating model objects.
def _db_rows():
    return list(Post.objects.values("id", "title", "views"))


def db_json(request):
    return JsonResponse(_db_rows(), safe=False, json_dumps_params=COMPACT)

def db_template
  render("posts/list", { "title": "Posts", "items": Post.pluck(:id, :title, :views).all })
end

def db_template
  @title = "Posts"
  render "posts/list", locals: {
    items: Post.pluck(:id, :title, :views)
      .map { |id, title, views| { id: id, title: title, views: views } }
  }
end

app.get('/db-template', async (req, res) => {
  const rows = await PostModel.findAll(ORM_PROJECTION);
  res.type('html').send(layout({ title: 'Posts', body: list({ items: rows }) }));
});

async dbTemplate({ view }: HttpContext) {
  return view.render('posts/list', { title: 'Posts', items: await this.dbRows() })
}

public function dbTemplate()
{
    return view('posts.list', ['title' => 'Posts', 'items' => $this->dbRows()]);
}

def db_template(request):
    return render(request, "posts/list.html", {"title": "Posts", "items": _db_rows()})

def w_create(req: Any) -> Any {
  Wpost.create({ "title": "Post title 0", "views": 7 })
  return { "status": 201, "body": "ok" }
}

def w_create
  Wpost.create!(title: "Post title 0", views: 7)
  head :created
end

app.post('/w', async (req, res) => {
  await WPost.create({ title: 'Post title 0', views: 7 });
  res.sendStatus(201);
});

async wCreate({ response }: HttpContext) {
  await Wpost.create({ title: 'Post title 0', views: 7 })
  return response.status(201).send('')
}

public function wCreate()
{
    Wpost::create(['title' => 'Post title 0', 'views' => 7]);
    return response('', 201);
}

if request.method == "POST":
    Wpost.objects.create(title="Post title 0", views=7)
    return HttpResponse(status=201)

# Random key in 1..800000 — the same range in every stack.
def w_update(req: Any) -> Any {
  Wpost.update(this.w_key(), { "views": 42 })
  return { "status": 200, "body": "ok" }
}

# update_all is the ORM's single-statement form, like Soli's Model.update.
def w_update
  Wpost.where(id: rand(1..WPOOL)).update_all(views: 42)
  head :ok
end

app.patch('/w', async (req, res) => {
  await WPost.update({ views: 42 }, { where: { id: wkey() } });
  res.sendStatus(200);
});

async wUpdate({ response }: HttpContext) {
  const id = Math.floor(Math.random() * WPOOL) + 1
  await Wpost.query().where('id', id).update({ views: 42 })
  return response.status(200).send('')
}

public function wUpdate()
{
    Wpost::where('id', random_int(1, self::WPOOL))->update(['views' => 42]);
    return response('', 200);
}

if request.method == "PATCH":
    Wpost.objects.filter(id=random.randint(1, WPOOL)).update(views=42)
    return HttpResponse(status=200)

# A key already deleted is a miss; the hit rate is measured by counting
# the collection before and after the cell, not assumed.
def w_delete(req: Any) -> Any {
  Wpost.delete(this.w_key()) rescue null
  return { "status": 200, "body": "ok" }
}

def w_delete
  Wpost.where(id: rand(1..WPOOL)).delete_all
  head :ok
end

app.delete('/w', async (req, res) => {
  await WPost.destroy({ where: { id: wkey() } });
  res.sendStatus(200);
});

async wDelete({ response }: HttpContext) {
  const id = Math.floor(Math.random() * WPOOL) + 1
  await Wpost.query().where('id', id).delete()
  return response.status(200).send('')
}

public function wDelete()
{
    Wpost::where('id', random_int(1, self::WPOOL))->delete();
    return response('', 200);
}

Wpost.objects.filter(id=random.randint(1, WPOOL)).delete()
return HttpResponse(status=200)

# config/routes.sl
websocket("/ws/echo", "ws#echo")

# app/controllers/ws_controller.sl
def echo(event: Any) -> Any {
  return { "send": event["message"] } if event["type"] == "message"
  return {}
}

const wssEcho = new WebSocketServer({ noServer: true });
wssEcho.on('connection', (ws) => ws.on('message', (m) => ws.send(m.toString())));

# config/cable.yml — redis, not async: the async adapter keeps its pubsub
# in-process, so with 16 Puma workers a broadcast reaches only one of them.
production:
  adapter: redis
  url: redis://127.0.0.1:6399/1

# app/channels/echo_channel.rb
class EchoChannel < ApplicationCable::Channel
  def subscribed
    stream_from "echo_#{SecureRandom.hex(8)}"
  end

  def echo(data)
    transmit(data["body"])
  end
end

# One process, so "broadcast" means every connection the server holds.
def room(event: Any) -> Any {
  return { "broadcast": event["message"] } if event["type"] == "message"
  return {}
}

// Each cluster worker holds only its own sockets, so a local broadcast reaches
// ~1/N of the room. REDIS_URL routes every publish through a shared channel so
// all workers deliver — what a clustered Node app has to do.
const localBroadcast = (text) => {
  for (const client of wssRoom.clients) if (client.readyState === 1) client.send(text);
};

if (REDIS_URL) {
  sub.subscribe('room');
  sub.on('message', (_channel, text) => localBroadcast(text));
  wssRoom.on('connection', (ws) => ws.on('message', (m) => pub.publish('room', m.toString())));
} else {
  wssRoom.on('connection', (ws) => ws.on('message', (m) => localBroadcast(m.toString())));
}

class RoomChannel < ApplicationCable::Channel
  def subscribed
    stream_from "room"
  end

  def speak(data)
    # Goes through the redis adapter, so every Puma worker delivers.
    ActionCable.server.broadcast("room", data["body"])
  end
end