moonbitstack/moonctl/scaffold

README
U
Bind
U
DataSource
U
DataSourceError
U
DdlColumn
U
DdlTable
U
DocVersion
U
Field
U
FuncFn
U
GenFile
U
Group
U
PgTarget
U
Plugin
U
Proto
U
ProtoEnum
U
ProtoEnumValue
U
ProtoField
U
ProtoMessage
U
ProtoOneof
U
ProtoService
U
Range
U
ReflectedColumn
U
Regen
U
Route
U
Rpc
U
Spec
U
SpecError
U
Style
U
StyleError
U
Template
U
TemplateError
U
TreeFile
U
TypeDef
U
Value
V
deps
V
gen_files_to_json
V
generate
V
generate_agent
V
generate_crud
V
generate_crud_from_ddl
V
generate_crud_from_reflection
V
generate_doc
V
generate_gql
V
generate_grpc
V
generate_model
V
generate_tree
V
generate_with
V
openapi_document
V
parse
V
parse_all
V
parse_ddl
V
parse_dsn
V
parse_gen_files
V
parse_lenient
V
parse_proto
V
pins
V
plugin_argv
V
plugin_from_json
V
plugin_request
V
port
V
proto_reserved_conflicts
V
render
V
resolve_import
V
scaffold_api
V
scaffold_docker
V
scaffold_kube
V
scaffold_model
V
scaffold_rpc
V
spec_from_json
V
spec_to_json
V
spec_to_value
V
swagger_ui_stub
V
tables_from_reflection
V
tree_plan

moonbitstack/moonctl/scaffold does not have a README file

Regen

pub(all) enum Regen {
  Always
  Once
} derive(Eq)

Whether a regeneration may replace a file that is already on disk. Always is for what moonctl owns — the routes and the types, which must follow the spec — and Once for what it only seeds: handlers, logic, configuration, manifests.

Regen::equal

source

fn Regen::equal(Regen, Regen) -> Bool

Regen::not_equal

source

fn Regen::not_equal(x : Regen, y : Regen) -> Bool

TreeFile

source

pub(all) struct TreeFile {
  path : String
  content : String
  regen : Regen
}

One file of a generated project tree: where it goes, what is in it, and whether regenerating the tree is allowed to overwrite it.

generate_tree

source

fn generate_tree(spec : @moonbitstack/moonctl/api.Spec
Spec, style? : @moonbitstack/moonctl/style.Style
Style, dir? : String) -> Array[TreeFile]

Generate the layered project tree goctl writes, in MoonBit: the service entry point and its moon.mod, etc/<service>.yaml, internal/config, internal/svc, internal/types, internal/handler (the generated routes plus a stub per handler, under internal/handler/<group>/ for a grouped route), internal/logic, internal/middleware for every middleware an @server block named, and a moon.pkg for each of those packages.

style (default gozero) names the files and the handler, logic and middleware entry points inside them. Names the spec itself chose — the type blocks and their fields — are left as written, since a MoonBit type name has to keep its capital. dir puts the whole tree under a directory.

Each file says whether a regeneration may overwrite it; hand the result to tree_plan to apply that.

pins

source

let pins : Map[String, String]

The version of each library generated code imports.

These are the versions this repository's CI scaffolds a project against and builds, so a generated project is promised to compile with them. A project that wants a later release edits its own moon.mod.

port

source

let port : Int

The port a scaffolded service listens on.

12000, the one every server in this family defaults to: HTTP, WebSocket and h2c share it because one listener tells them apart, so a generated manifest and a generated configuration name the same number without anyone saying which they meant.

scaffold_api

source

fn scaffold_api(name : String) -> Array[@moonbitstack/moonctl/plugin.GenFile
GenFile]

Scaffold a runnable moonapi service project under <name>/: a moon.mod (depending on the published moonapi + moonasgi), a sample <name>.api spec, its generated routes+handlers in src/app.mbt (through the same generate the gen api command uses, so it compiles), and a README. This is goctl's goctl api new.

scaffold_docker

source

fn scaffold_docker(name : String, port? : Int) -> Array[@moonbitstack/moonctl/plugin.GenFile
GenFile]

Scaffold container files for a native mctl-generated service: a Dockerfile (a MoonBit build stage that produces the native binary, then a slim runtime stage that runs it) and a .dockerignore. name is the binary/image name, port the port the service listens on. goctl's goctl docker.

scaffold_kube

source

fn scaffold_kube(name : String, port? : Int, replicas? : Int) -> Array[@moonbitstack/moonctl/plugin.GenFile
GenFile]

Scaffold a Kubernetes deployment for the service under deploy/: a Deployment (replicas pods of the <name> image, a container port, and a liveness probe on /ping) and a Service exposing it. goctl's goctl kube deploy.

The manifests are built as values and written by moonyaml, not joined out of string fragments. A generator that joins fragments has the indentation in its string literals, where a missed space is invisible, and quotes nothing — so the first service name with a colon in it emits a file Kubernetes reads as something else.

scaffold_model

source

fn scaffold_model(name : String) -> Array[@moonbitstack/moonctl/plugin.GenFile
GenFile]

Scaffold a moonorm data-layer project under <name>/: a moon.mod (depending on the published moonorm + moondb), a sample schema.sql, its generated models + CRUD in src/model.mbt (through the same generate_crud_from_ddl as gen crud), and a README. goctl's goctl model … new.

scaffold_rpc

source

fn scaffold_rpc(name : String) -> Array[@moonbitstack/moonctl/plugin.GenFile
GenFile]

Scaffold a moonrpc service project under <name>/: a moon.mod (depending on the published moonrpc), a sample <name>.proto, its generated service stub in src/service.mbt (through the same generate_grpc as gen proto), and a README. goctl's goctl rpc new.

tree_plan

source

fn tree_plan(tree : Array[TreeFile], exists : (String) -> Bool) -> Array[@moonbitstack/moonctl/plugin.GenFile
GenFile]

The files of tree a run should actually write, given a way to ask whether a path is already on disk. A file moonctl owns (Always — the routes and the types) is always written; anything else is written only when it is not there yet, so a second run refreshes what follows the spec and leaves every handler and logic body the author has since filled in exactly as it is.

Source Files

Install

Download zip

moonctl (mctl) — a spec-driven code generator for MoonBit (← goctl): parse a .api service spec and emit compilable moonapi scaffolding (routes + handler stubs).

goctlcodegenscaffoldapimoonapimoonbitcli