moonbitstack/moonctl/scaffold

README
U
Bind
U
Command
U
Config
U
DataSource
U
DataSourceError
U
DdlColumn
U
DdlTable
U
Diagnostic
U
DocVersion
U
Field
U
FuncFn
U
GatewayRoute
U
GenFile
U
Group
U
Label
U
Lang
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
Severity
U
Spec
U
SpecError
U
Style
U
StyleError
U
Template
U
TemplateEntry
U
TemplateError
U
TreeFile
U
TypeDef
U
Value
V
bug_report
V
cache_file_name
V
client_file
V
client_file_name
V
command_names
V
commands
V
completion
V
config_get
V
config_keys
V
config_set
V
config_text
V
default_config
V
default_routes
V
deps
V
env_report
V
find_template
V
format
V
gateway_file_name
V
gen_files_to_json
V
generate
V
generate_agent
V
generate_cached
V
generate_client
V
generate_crud
V
generate_crud_from_ddl
V
generate_crud_from_reflection
V
generate_doc
V
generate_gateway
V
generate_gql
V
generate_gql_tree
V
generate_grpc
V
generate_markdown
V
generate_mcp_tree
V
generate_migrations
V
generate_model
V
generate_mongo
V
generate_rpc_tree
V
generate_tree
V
generate_with
V
has_errors
V
has_method
V
markdown_file_name
V
migrate_config
V
migrate_file_name
V
mod_pins
V
mongo_file_name
V
openapi_document
V
parse
V
parse_all
V
parse_config
V
parse_ddl
V
parse_dsn
V
parse_gen_files
V
parse_lenient
V
parse_proto
V
parse_route_map
V
pin_module
V
pinned_version
V
pins
V
plugin_argv
V
plugin_from_json
V
plugin_plan
V
plugin_request
V
port
V
proto_reserved_conflicts
V
render
V
resolve_import
V
safe_path
V
scaffold_api
V
scaffold_docker
V
scaffold_gql
V
scaffold_kube
V
scaffold_mcp
V
scaffold_model
V
scaffold_rpc
V
spec_from_json
V
spec_to_json
V
spec_to_value
V
subcommands
V
swagger_ui_stub
V
tables_from_reflection
V
template_detail
V
template_table
V
templates
V
templates_of
V
tree_plan
V
upgrade_pins
V
usage_text
V
validate
V
validate_files
V
validate_source

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_gql_tree

source

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

The layered GraphQL tree for spec under dir: internal/schema with build_schema() (rewritten on every run), internal/logic with the resolvers and a test that queries ping, internal/config/internal/svc (seeded once), and the entry point serving graphql_app on 12000.

Hand the result to tree_plan to keep what the author has filled in.

generate_mcp_tree

source

fn generate_mcp_tree(module_ : String, style? : @moonbitstack/moonctl/style.Style
Style, dir? : String) -> Array[TreeFile]

The MCP server tree for module module_ under dir: the shared module, configuration and context, internal/tools with the annotated functions, their generated registration and a test, and the build rule that keeps the registration in step with the functions.

generate_rpc_tree

source

fn generate_rpc_tree(proto : @moonbitstack/moonctl/proto.Proto
Proto, style? : @moonbitstack/moonctl/style.Style
Style, dir? : String) -> Array[TreeFile]

The layered gRPC tree goctl writes for a .proto, in MoonBit, under dir: pb/ with the messages, codecs and handler tables (rewritten on every run), internal/logic with one function per RPC and internal/config/internal/svc (seeded once), internal/server wiring the logic into each service, client/ with a typed client per service, and the entry point serving it all on 12000.

Hand the result to tree_plan to keep what the author has filled in.

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 moonapi service under <name>/: goctl's api new. The layered tree of generate_tree for a sample spec with GET /ping, a test calling it, and an entry point serving it on mooncat.

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_gql

source

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

Scaffold a moongql service under <name>/: the layered tree of generate_gql_tree for a sample spec, with a ping resolver and a test querying it.

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_mcp

source

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

Scaffold an MCP server under <name>/: annotated tools, a resource and a prompt, a test calling the tool, and an entry point serving them over Streamable HTTP or, with --stdio, over stdio.

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 under <name>/: goctl's rpc new. The layered tree of generate_rpc_tree for a sample proto with a Ping that answers pong, and a test serving it and calling it through the typed client.

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.