🥮 mooncakes.io

    moonbitstack/moonctl/model does not have a README file

    DataSourceError

    source
    pub suberror DataSourceError {
      BadDsn(String)
    }

    Raised when a DSN string cannot be parsed into a DataSource.

    DataSource

    source
    pub(all) enum DataSource {
      Sqlite(String)
      Postgres(PgTarget)
    }

    A parsed datasource DSN: which backend to read, and how to reach it.

    DdlColumn

    source
    pub(all) struct DdlColumn {
      name : String
      type_ : String
      primary_key : Bool
      nullable : Bool
      default_ : String?
    }

    One parsed column of a CREATE TABLE statement: the SQL column name, the MoonBit type_ its SQL type maps to (Int/Int64/String/Double/Bool/ Bytes), whether it is a primary key, whether it accepts NULL, and its literal DEFAULT clause if any (kept as source text — it is emitted into DDL comments, never bound).

    DdlTable

    source
    pub(all) struct DdlTable {
      name : String
      columns : Array[DdlColumn]
    }

    A parsed CREATE TABLE: the SQL table name and its ordered columns.

    PgTarget

    source
    pub(all) struct PgTarget {
      host : String
      port : Int
      user : String
      password : String
      database : String
    }

    A PostgreSQL connection target parsed from a postgres:// DSN.

    ReflectedColumn

    source
    pub(all) struct ReflectedColumn {
      table : String
      name : String
      sql_type : String
      primary_key : Bool
      nullable : Bool
    }

    One column of a reflected database schema: the table it belongs to, its name, its raw SQL type text (INTEGER, character varying, VARCHAR(255), …), and whether it is a primary key / accepts NULL. This is the neutral shape a live reader (SQLite PRAGMA table_info, PostgreSQL information_schema.columns) produces and tables_from_reflection folds into DdlTables.

    cache_file_name

    source
    fn cache_file_name(service : String) -> String

    The file a cached layer lands in: greet → greet_cache.mbt, beside the <service>_model.mbt whose records it caches.

    generate_cached

    source
    fn generate_cached(spec : 
    Spec    ) -> String

    Generate the cached CRUD layer for every table of spec: for a type block with a field to look records up by, the key function plus read-through find, invalidating write, and evict. A block with no single-valued field has no key to cache under, so it gets no layer and the file says why.

    The output needs no import and no driver: the record types it names are the ones mctl model generates for the same spec.

    generate_crud

    source
    fn generate_crud(tables : Array[DdlTable]) -> String

    Generate a moonorm data-access layer from parsed DDL: for every table, the record struct, its @moonorm.Model (columns + from_row + to_columns), a @moonorm.Table descriptor, an up/down migration pair, and typed CRUD (insert/all, plus find_by_id/update/delete_by_id when the table has a single-column primary key). The output compiles against moonbitstack/moonorm + moonbitstack/moondb; a consuming package imports both. This is the .sql-schema counterpart of goctl's model mysql ddl.

    generate_crud_from_ddl

    source
    fn generate_crud_from_ddl(source : String) -> String

    Parse a SQL DDL script and generate its moonorm data-access layer in one step.

    generate_crud_from_reflection

    source
    fn generate_crud_from_reflection(cols : Array[ReflectedColumn]) -> String

    Generate a moonorm data-access layer (models + typed CRUD) straight from a live schema's reflected columns — the in-memory counterpart of generate_crud_from_ddl. The reflect sub-package produces the ReflectedColumns from a real connection.

    generate_migrations

    source
    fn generate_migrations(spec : 
    Spec    ) -> String

    The migration file for a spec: one CREATE TABLE per type. service names the file and the header, so two specs migrated into one directory do not look alike.

    generate_model

    source
    fn generate_model(spec : 
    Spec    ) -> String

    Generate a moonorm data layer for every type block in spec. A block whose fields are all storable yields: the model struct; a <table>_model : @moonorm.Model[T] built with @moonorm.Model::new — declared columns (an id column is the primary key), a from_row decoder, and the to_columns projection an INSERT binds; a <table>_table : @moonorm.Table descriptor; and a <table>_up / <table>_down migration pair (create the table idempotently / drop it). This is the explicit MoonBit stand-in for a SQLAlchemy declarative class plus an Alembic revision, which reflection would otherwise synthesise. A block with a non-storable field (a slice, map, or nested message) still gets its struct and a plain @moonorm.Table descriptor.

    The output compiles against moonbitstack/moonorm + moonbitstack/moondb; a consuming package imports both.

    generate_mongo

    source
    fn generate_mongo(spec : 
    Spec    ) -> String

    Generate a Mongo document model for every type block of spec: a Doc struct that is the document as stored, and a Repo over the Collection port with insert, all, and — when the spec has a key field — find, replace and delete.

    The output compiles against MoonBit core: Json and ToJson are builtin, and the file imports moonbitlang/core/json as @json for from_json. A driver supplies the port; without one, nothing here needs a database to typecheck.

    migrate_file_name

    source
    fn migrate_file_name(service : String) -> String

    The name a migration file takes: greet → greet_migrate.sql.

    mongo_file_name

    source
    fn mongo_file_name(service : String) -> String

    The file a document model lands in: greet → greet_mongo.mbt, named after the service so two specs generated into one directory do not collide.

    parse_ddl

    source
    fn parse_ddl(source : String) -> Array[DdlTable]

    Parse a SQL DDL script into its CREATE TABLE definitions. Recognises CREATETABLE [IF NOT EXISTS] name ( … ) (quoted or bare name), skipping any other statement. Column types, primary keys (column- or table-level), NOT NULL and DEFAULT clauses are captured; everything needed to emit a moonorm model.

    parse_dsn

    source
    fn parse_dsn(dsn : String) -> DataSource raise DataSourceError

    Parse a datasource DSN into a DataSource. Recognised forms:

    • SQLite: sqlite:PATH, sqlite://PATH, sqlite3:PATH, file:PATH, the literal :memory:, or a bare path ending in .db / .sqlite / .sqlite3.
    • PostgreSQL: postgres://[user[:password]@]host[:port][/database][?…] (and the postgresql:// spelling). The port defaults to 5432, the user to postgres; the database name is required.

    Raises BadDsn on an unrecognised scheme or a PostgreSQL URL missing its host or database.

    tables_from_reflection

    source
    fn tables_from_reflection(cols : Array[ReflectedColumn]) -> Array[DdlTable]

    Fold reflected columns into DdlTables, grouping by table in first-seen order and mapping each raw SQL type onto its MoonBit scalar (the leading type keyword drives the mapping, so character varying and VARCHAR(255) both land on String). The result feeds generate_crud, so a live schema and a .sql file reach the same model generator.

    Source Files

    Powered by MoonBit

    Site sourceReport issueModulesSkillsBuild queueStatistics

    © 2026 mooncakes.io