#moonctl (mctl)

#From spec to code

service greet {
  get  /ping        ping        "health check"
  get  /users/:id   get_user
  post /users        create_user "create a user"
}

// Code generated by moonctl. DO NOT EDIT.

///|
/// Build the greet application with its routes wired to handlers.
pub fn build_app() -> @moonapi.App {
  let app = @moonapi.App::new()
  app.get("/ping", ctx => ping(ctx), summary="health check")
  app.get("/users/:id", ctx => get_user(ctx))
  app.post("/users", ctx => create_user(ctx), summary="create a user")
  app
}

///|
pub fn ping(_ctx : @moonapi.Context) -> @moonasgi.Response {
  @moonapi.text(200, "TODO: ping")
}
// ... one stub per handler

#Usage

let spec = @moonctl.parse(source)          // -> Spec { service, routes, types }
let code = @moonctl.generate(spec)         // -> compilable moonapi scaffold (String)

$ mctl gen api   greet.api                 # -> greet.mbt          (moonapi scaffold)
$ mctl gen proto greet.proto               # -> greet_grpc.mbt     (moonrpc service stub)
$ mctl gen model user.api                  # -> user_model.mbt     (moonorm model + migration)
$ mctl gen crud  schema.sql                # -> schema_model.mbt   (moonorm model + typed CRUD)
$ mctl gen doc   greet.api                 # -> greet_openapi.json + greet_swagger.html
$ mctl model datasource sqlite:shop.db     # -> datasource_model.mbt (read a live DB's schema)
$ mctl api  new  blog                      # scaffold a moonapi service project under blog/
$ mctl rpc  new  echo                      # scaffold a moonrpc service project under echo/
$ mctl model new account                   # scaffold a moonorm data-layer project under account/
$ mctl docker    greet                     # -> Dockerfile + .dockerignore
$ mctl kube      greet                     # -> deploy/deployment.yaml + deploy/service.yaml
$ mctl plugin    ./my-plugin greet.api     # run an external plugin over the parsed spec

#Cross-repo codegen

• .proto → moonrpc: parse_proto reads a proto3 file (service / rpc / message, including stream, repeated, and map<K, V>); generate_grpc emits a struct per message, a @moonrpc.Method descriptor per RPC (its gRPC :path is /package.Service/Method), a <Service>Server handler-registration struct (one synchronous-core handler per RPC, returning its reply or a gRPC @moonrpc.Status), and a <service>_methods() listing.

• .api type → moonorm: generate_model turns each storable type block into a model struct, a <table>_model : @moonorm.Model[T] (declared columns — an id column is the primary key — plus the from_row decoder and to_columns projection that MoonBit can't synthesise for want of reflection), a <table>_table : @moonorm.Table descriptor, and a <table>_up / <table>_down migration pair (create the table idempotently, drop it — the explicit stand-in for an Alembic revision). A block with a non-storable field (a slice, map, or nested message) still gets its struct and a plain Table descriptor. The output compiles against moonorm + moondb, so a consumer imports both.

let stub  = @moonctl.generate_grpc(@moonctl.parse_proto(proto_src))  // -> moonrpc stub
let model = @moonctl.generate_model(@moonctl.parse(api_src))         // -> moonorm model + migration

#SQL DDL → CRUD

let code = @moonctl.generate_crud_from_ddl(sql_src)   // -> moonorm model + CRUD (String)

#Live datasource reflection

$ mctl model datasource sqlite:shop.db
$ mctl model datasource postgres://user:pass@localhost:5432/shop

#Project scaffolds

$ mctl api  new  blog        # blog/{moon.mod.json, blog.api, src/{moon.pkg.json, app.mbt}, README.md}
$ mctl rpc  new  echo        # echo/{moon.mod.json, echo.proto, src/{moon.pkg.json, service.mbt}, README.md}
$ mctl model new account     # account/{moon.mod.json, schema.sql, src/{moon.pkg.json, model.mbt}, README.md}
$ mctl docker    greet       # Dockerfile (two-stage native build) + .dockerignore
$ mctl kube      greet       # deploy/deployment.yaml + deploy/service.yaml

let files = @moonctl.scaffold_api("blog")        // -> Array[GenFile] to write

#Plugins

let req   = @moonctl.plugin_request(spec)              // JSON for the plugin's stdin
let files = @moonctl.parse_gen_files(@json.parse(out)) // the plugin's stdout -> files to write

#OpenAPI / Swagger

let spec = @moonctl.parse(api_src)
let json = @moonctl.generate_doc(spec, version=OpenApi31)   // or Swagger20 / OpenApi30
let html = @moonctl.swagger_ui_stub(spec_url="/openapi.json")

#Template engine

let out = @moonctl.render(
  "{{range .routes}}{{.verb}} {{.path}} -> {{.handler}}\n{{end}}",
  @moonctl.spec_to_value(spec),
)
// or drive codegen from a caller-supplied template:
let code = @moonctl.generate(spec, template=my_template)   // == generate_with

#Status & roadmap (transliterating goctl)

#License