The shell

One statement against the project's classes, kv and databases, spelled as a script spells it, with an immediate answer.

Where it is

The project has one shell: the Shell entry in the console's sidebar, or actias shell <project> in the cli. Every class page's open the shell lands there with that class filled in.

Auction:find { status = "open", high_bid = { gt = 100 } }

  3 entries · 41 ms
  name       status  high_bid  closes_at
  lot-42     open    120       1788292618009
  lot-57     open    340       1788292700114
  lot-61     open    105       1788293001922

The line is typed by the analyser that checks a script: a misspelled field underlines before anything is sent, and after page = Auction:find { ... } the next line completes page.entries. Names complete from what the project holds, inside the quotes of kv(" and database(".

What binds

Each of those is one statement: it resolves where you typed it into the request the corresponding console page already makes, and nothing is woken. \resources lists what the project holds; \fields Auction lists a class's declared fields and methods.

kv("presence"):list()
kv("presence"):get("ada")
database("directory"):query("select name from handles limit 3")
Auction:list { where = { status = "open" }, order = { high_bid = "desc" }, limit = 20 }
Auction:visit { where = { status = "open" } }     -- every row checked against its object

Read-only and write mode

A session starts read-only. \write lifts it; \read puts it back.

A method call goes through the object's own lane, serialized with every other call, exactly as a script's call would. Nothing declares which methods write, so a read-only session refuses a call rather than hiding it. Naming an instance that does not exist creates it, admission permitting.

In write mode every call and every chunk is logged by the api against your account, one line per action:

shell call by ada on 3f2de568-…: Auction("lot-42"):bid
shell run by ada on 3f2de568-…: 95 chars, write

Chunks

A loop, an expression, a value used as an argument: those are not one statement, and the shell does not pretend otherwise. Such a line runs as a chunk, in a fresh vm on a worker, under your grants. So does anything you give to \run or \paste.

Auction:get(Auction:find().entries[1].name)     -- a nested call: a chunk

-- \run, then paste; an impromptu join across a class and a namespace
local presence = kv "presence"
local rows = {}
for _, e in Auction:find({ status = "open" }).entries do
    table.insert(rows, { lot = e.name, seen = presence:get("lot:" .. e.name) ~= nil })
end
return rows

The session's mode travels with the chunk. In a read-only session the vm refuses kv set, set_batch and delete, database exec and every method call inside the chunk, naming \write:

runtime error: kv set is a write, and this shell session is read-only; \write allows it

A chunk is possible and not encouraged: the one-statement forms are what the shell is for, and a chunk you would run twice is a script.

Commands

A line starting with -- is a comment and does nothing.

From a pipe

The cli shell reads statements from stdin when it is not a terminal, one per line, and prints each answer, so a scripted check is a heredoc:

actias shell 3f2de568-f50b-4bcd-8877-a9c8a1f58797 <<'EOF'
\resources
Auction:find { status = "open" }
kv("presence"):list()
\quit
EOF

Completions come from the language service when actias-luau is beside the binary or on your PATH, and from the project's contract otherwise; the banner says which.

Access

Limits

Gotchas

• Auction:get("lot-42") in a chunk is a handle, not the row. In a statement, the same spelling reads the row.
• A bare name in { name = name } is a variable, and an undefined one: the analyser says so before enter, and a chunk sees nil.
• order takes one field, as everywhere.
• The shell is per project. A class, namespace or database another project holds is "not in this project".

Related

• Directory: the reads the shell resolves.
• kv and database: the verbs and their pages.
• Objects: what a method call does.