feat: add --types flag and stdlib nullable type support for bun/gorm writers
* Fix pgsql reader double-quoting defaults: normalizePostgresDefault strips surrounding SQL string literal quotes from column_default before storing, matching the convention used by every other reader. * Add NullableTypes field to WriterOptions with NullableTypeResolveSpec (default) and NullableTypeStdlib constants. * Both bun and gorm TypeMappers now accept a typeStyle parameter. stdlib mode produces sql.NullString/NullInt32/NullTime etc. for nullable scalars, plain Go slices for arrays, and time.Time for NOT NULL timestamps. Default resolvespec behaviour is unchanged. * Add --types flag to convert and split commands. * Update bun/README.md and gorm/README.md with side-by-side generated code examples, updated type mapping tables, and Writer Options documentation.
This commit is contained in:
Hein
@@ -48,22 +48,23 @@ func main() {
|
||||
### CLI Examples
|
||||
|
||||
```bash
|
||||
# Generate GORM models from PostgreSQL database (single file)
|
||||
relspec --input pgsql \
|
||||
--conn "postgres://localhost/mydb" \
|
||||
--output gorm \
|
||||
--out-file models.go \
|
||||
--package models
|
||||
# Generate GORM models from a DBML schema (default: resolvespec types)
|
||||
relspec convert --from dbml --from-path schema.dbml \
|
||||
--to gorm --to-path models.go --package models
|
||||
|
||||
# Generate GORM models with multi-file output (one file per table)
|
||||
relspec --input json \
|
||||
--in-file schema.json \
|
||||
--output gorm \
|
||||
--out-file models/ \
|
||||
--package models
|
||||
# Use standard library database/sql nullable types instead of resolvespec
|
||||
relspec convert --from dbml --from-path schema.dbml \
|
||||
--to gorm --to-path models.go --package models \
|
||||
--types stdlib
|
||||
|
||||
# Convert DBML to GORM models
|
||||
relspec --input dbml --in-file schema.dbml --output gorm --out-file models.go
|
||||
# Explicitly select resolvespec types (same as omitting --types)
|
||||
relspec convert --from pgsql --from-conn "postgres://localhost/mydb" \
|
||||
--to gorm --to-path models.go --package models \
|
||||
--types resolvespec
|
||||
|
||||
# Multi-file output (one file per table)
|
||||
relspec convert --from json --from-path schema.json \
|
||||
--to gorm --to-path models/ --package models
|
||||
```
|
||||
|
||||
## Output Modes
|
||||
@@ -86,58 +87,86 @@ relspec --input pgsql --conn "..." --output gorm --out-file models/
|
||||
|
||||
Files are named: `sql_{schema}_{table}.go`
|
||||
|
||||
## Generated Code Example
|
||||
## Generated Code Examples
|
||||
|
||||
### Default — resolvespec types (`--types resolvespec`)
|
||||
|
||||
```go
|
||||
package models
|
||||
|
||||
import (
|
||||
"time"
|
||||
sql_types "git.warky.dev/wdevs/sql_types"
|
||||
sql_types "github.com/bitechdev/ResolveSpec/pkg/spectypes"
|
||||
)
|
||||
|
||||
type ModelUser struct {
|
||||
ID int64 `gorm:"column:id;type:bigint;primaryKey;autoIncrement" json:"id"`
|
||||
Username string `gorm:"column:username;type:varchar(50);not null;uniqueIndex" json:"username"`
|
||||
Email string `gorm:"column:email;type:varchar(100);not null" json:"email"`
|
||||
CreatedAt time.Time `gorm:"column:created_at;type:timestamp;not null;default:now()" json:"created_at"`
|
||||
|
||||
// Relationships
|
||||
Pos []*ModelPost `gorm:"foreignKey:UserID;references:ID;constraint:OnDelete:CASCADE" json:"pos,omitempty"`
|
||||
ID string `gorm:"column:id;type:uuid;primaryKey" json:"id"`
|
||||
Username string `gorm:"column:username;type:text;not null" json:"username"`
|
||||
Email sql_types.SqlString `gorm:"column:email;type:text" json:"email,omitempty"`
|
||||
Tags sql_types.SqlStringArray `gorm:"column:tags;type:text[];not null;default:'{}'" json:"tags"`
|
||||
CreatedAt sql_types.SqlTimeStamp `gorm:"column:created_at;type:timestamptz;not null;default:now()" json:"created_at"`
|
||||
}
|
||||
|
||||
func (ModelUser) TableName() string {
|
||||
return "public.users"
|
||||
}
|
||||
```
|
||||
|
||||
type ModelPost struct {
|
||||
ID int64 `gorm:"column:id;type:bigint;primaryKey" json:"id"`
|
||||
UserID int64 `gorm:"column:user_id;type:bigint;not null" json:"user_id"`
|
||||
Title string `gorm:"column:title;type:varchar(200);not null" json:"title"`
|
||||
Content sql_types.SqlString `gorm:"column:content;type:text" json:"content,omitempty"`
|
||||
### Standard library — `--types stdlib`
|
||||
|
||||
// Belongs to
|
||||
Use *ModelUser `gorm:"foreignKey:UserID;references:ID" json:"use,omitempty"`
|
||||
```go
|
||||
package models
|
||||
|
||||
import (
|
||||
"database/sql"
|
||||
"time"
|
||||
)
|
||||
|
||||
type ModelUser struct {
|
||||
ID string `gorm:"column:id;type:uuid;primaryKey" json:"id"`
|
||||
Username string `gorm:"column:username;type:text;not null" json:"username"`
|
||||
Email sql.NullString `gorm:"column:email;type:text" json:"email,omitempty"`
|
||||
Tags []string `gorm:"column:tags;type:text[];not null;default:'{}'" json:"tags"`
|
||||
CreatedAt time.Time `gorm:"column:created_at;type:timestamptz;not null;default:now()" json:"created_at"`
|
||||
}
|
||||
|
||||
func (ModelPost) TableName() string {
|
||||
return "public.posts"
|
||||
func (ModelUser) TableName() string {
|
||||
return "public.users"
|
||||
}
|
||||
```
|
||||
|
||||
## Writer Options
|
||||
|
||||
### NullableTypes
|
||||
|
||||
Controls which Go package is used for nullable column types. Set via the `--types` CLI flag or `WriterOptions.NullableTypes`:
|
||||
|
||||
```go
|
||||
// Use resolvespec types (default — omit NullableTypes or set to "resolvespec")
|
||||
options := &writers.WriterOptions{
|
||||
OutputPath: "models.go",
|
||||
PackageName: "models",
|
||||
NullableTypes: writers.NullableTypeResolveSpec,
|
||||
}
|
||||
|
||||
// Use standard library database/sql types
|
||||
options := &writers.WriterOptions{
|
||||
OutputPath: "models.go",
|
||||
PackageName: "models",
|
||||
NullableTypes: writers.NullableTypeStdlib,
|
||||
}
|
||||
```
|
||||
|
||||
### Metadata Options
|
||||
|
||||
Configure the writer behavior using metadata in `WriterOptions`:
|
||||
Configure additional writer behavior using metadata in `WriterOptions`:
|
||||
|
||||
```go
|
||||
options := &writers.WriterOptions{
|
||||
OutputPath: "models.go",
|
||||
PackageName: "models",
|
||||
Metadata: map[string]interface{}{
|
||||
"multi_file": true, // Enable multi-file mode
|
||||
"populate_refs": true, // Populate RefDatabase/RefSchema
|
||||
Metadata: map[string]any{
|
||||
"multi_file": true, // Enable multi-file mode
|
||||
"populate_refs": true, // Populate RefDatabase/RefSchema
|
||||
"generate_get_id_str": true, // Generate GetIDStr() methods
|
||||
},
|
||||
}
|
||||
@@ -145,18 +174,23 @@ options := &writers.WriterOptions{
|
||||
|
||||
## Type Mapping
|
||||
|
||||
| SQL Type | Go Type | Notes |
|
||||
|----------|---------|-------|
|
||||
| bigint, int8 | int64 | - |
|
||||
| integer, int, int4 | int | - |
|
||||
| smallint, int2 | int16 | - |
|
||||
| varchar, text | string | Not nullable |
|
||||
| varchar, text (nullable) | sql_types.SqlString | Nullable |
|
||||
| boolean, bool | bool | - |
|
||||
| timestamp, timestamptz | time.Time | - |
|
||||
| numeric, decimal | float64 | - |
|
||||
| uuid | string | - |
|
||||
| json, jsonb | string | - |
|
||||
The nullable type package is selected with `--types` (or `WriterOptions.NullableTypes`).
|
||||
|
||||
| SQL Type | NOT NULL — both | Nullable — resolvespec | Nullable — stdlib |
|
||||
|---|---|---|---|
|
||||
| `bigint` | `int64` | `SqlInt64` | `sql.NullInt64` |
|
||||
| `integer` | `int32` | `SqlInt32` | `sql.NullInt32` |
|
||||
| `smallint` | `int16` | `SqlInt16` | `sql.NullInt16` |
|
||||
| `text`, `varchar` | `string` | `SqlString` | `sql.NullString` |
|
||||
| `boolean` | `bool` | `SqlBool` | `sql.NullBool` |
|
||||
| `timestamp`, `timestamptz` | `time.Time` | `SqlTimeStamp` | `sql.NullTime` |
|
||||
| `numeric`, `decimal` | `float64` | `SqlFloat64` | `sql.NullFloat64` |
|
||||
| `uuid` | `string` | `SqlUUID` | `sql.NullString` |
|
||||
| `jsonb` | `string` | `SqlString` | `sql.NullString` |
|
||||
| `text[]` | `SqlStringArray` | `SqlStringArray` | `[]string` |
|
||||
| `integer[]` | `SqlInt32Array` | `SqlInt32Array` | `[]int32` |
|
||||
| `uuid[]` | `SqlUUIDArray` | `SqlUUIDArray` | `[]string` |
|
||||
| `vector` | `SqlVector` | `SqlVector` | `[]float32` |
|
||||
|
||||
## Relationship Generation
|
||||
|
||||
@@ -170,7 +204,8 @@ The writer automatically generates relationship fields:
|
||||
## Notes
|
||||
|
||||
- Model names are prefixed with "Model" (e.g., `ModelUser`)
|
||||
- Nullable columns use `sql_types.SqlString`, `sql_types.SqlInt64`, etc.
|
||||
- Nullable columns use `sql_types.SqlString`, `sql_types.SqlInt64`, etc. by default; pass `--types stdlib` to use `sql.NullString`, `sql.NullInt64`, etc. instead
|
||||
- Array columns use `sql_types.SqlStringArray`, `sql_types.SqlInt32Array`, etc. by default; `--types stdlib` produces plain Go slices (`[]string`, `[]int32`, …)
|
||||
- Generated code is auto-formatted with `go fmt`
|
||||
- JSON tags are automatically added
|
||||
- Supports schema-qualified table names in `TableName()` method
|
||||
|
||||
@@ -11,29 +11,43 @@ import (
|
||||
|
||||
// TypeMapper handles type conversions between SQL and Go types
|
||||
type TypeMapper struct {
|
||||
// Package alias for sql_types import
|
||||
sqlTypesAlias string
|
||||
typeStyle string // writers.NullableTypeResolveSpec | writers.NullableTypeStdlib
|
||||
}
|
||||
|
||||
// NewTypeMapper creates a new TypeMapper with default settings
|
||||
func NewTypeMapper() *TypeMapper {
|
||||
// NewTypeMapper creates a new TypeMapper.
|
||||
// typeStyle should be writers.NullableTypeResolveSpec or writers.NullableTypeStdlib;
|
||||
// an empty string defaults to resolvespec.
|
||||
func NewTypeMapper(typeStyle string) *TypeMapper {
|
||||
if typeStyle == "" {
|
||||
typeStyle = writers.NullableTypeResolveSpec
|
||||
}
|
||||
return &TypeMapper{
|
||||
sqlTypesAlias: "sql_types",
|
||||
typeStyle: typeStyle,
|
||||
}
|
||||
}
|
||||
|
||||
// SQLTypeToGoType converts a SQL type to its Go equivalent
|
||||
// Handles nullable types using ResolveSpec sql_types package
|
||||
// SQLTypeToGoType converts a SQL type to its Go equivalent.
|
||||
func (tm *TypeMapper) SQLTypeToGoType(sqlType string, notNull bool) string {
|
||||
// Normalize SQL type (lowercase, remove length/precision)
|
||||
// Array types are handled separately for both styles.
|
||||
if pgsql.IsArrayType(sqlType) {
|
||||
return tm.arrayGoType(tm.extractBaseType(sqlType))
|
||||
}
|
||||
|
||||
baseType := tm.extractBaseType(sqlType)
|
||||
|
||||
// If not null, use base Go types
|
||||
if tm.typeStyle == writers.NullableTypeStdlib {
|
||||
if notNull {
|
||||
return tm.rawGoType(baseType)
|
||||
}
|
||||
return tm.stdlibNullableGoType(baseType)
|
||||
}
|
||||
|
||||
// resolvespec (default)
|
||||
if notNull {
|
||||
return tm.baseGoType(baseType)
|
||||
}
|
||||
|
||||
// For nullable fields, use sql_types
|
||||
return tm.nullableGoType(baseType)
|
||||
}
|
||||
|
||||
@@ -106,6 +120,9 @@ func (tm *TypeMapper) baseGoType(sqlType string) string {
|
||||
|
||||
// Other
|
||||
"money": "float64",
|
||||
|
||||
// pgvector — always uses SqlVector even when NOT NULL
|
||||
"vector": tm.sqlTypesAlias + ".SqlVector",
|
||||
}
|
||||
|
||||
if goType, ok := typeMap[sqlType]; ok {
|
||||
@@ -179,6 +196,9 @@ func (tm *TypeMapper) nullableGoType(sqlType string) string {
|
||||
|
||||
// Other
|
||||
"money": tm.sqlTypesAlias + ".SqlFloat64",
|
||||
|
||||
// pgvector
|
||||
"vector": tm.sqlTypesAlias + ".SqlVector",
|
||||
}
|
||||
|
||||
if goType, ok := typeMap[sqlType]; ok {
|
||||
@@ -189,6 +209,123 @@ func (tm *TypeMapper) nullableGoType(sqlType string) string {
|
||||
return tm.sqlTypesAlias + ".SqlString"
|
||||
}
|
||||
|
||||
// arrayGoType returns the Go type for a PostgreSQL array column.
|
||||
// The baseElemType is the canonical base type (e.g. "text", "integer").
|
||||
func (tm *TypeMapper) arrayGoType(baseElemType string) string {
|
||||
if tm.typeStyle == writers.NullableTypeStdlib {
|
||||
return tm.stdlibArrayGoType(baseElemType)
|
||||
}
|
||||
typeMap := map[string]string{
|
||||
"text": tm.sqlTypesAlias + ".SqlStringArray", "varchar": tm.sqlTypesAlias + ".SqlStringArray",
|
||||
"char": tm.sqlTypesAlias + ".SqlStringArray", "character": tm.sqlTypesAlias + ".SqlStringArray",
|
||||
"citext": tm.sqlTypesAlias + ".SqlStringArray", "bpchar": tm.sqlTypesAlias + ".SqlStringArray",
|
||||
"inet": tm.sqlTypesAlias + ".SqlStringArray", "cidr": tm.sqlTypesAlias + ".SqlStringArray",
|
||||
"macaddr": tm.sqlTypesAlias + ".SqlStringArray",
|
||||
"json": tm.sqlTypesAlias + ".SqlStringArray", "jsonb": tm.sqlTypesAlias + ".SqlStringArray",
|
||||
"integer": tm.sqlTypesAlias + ".SqlInt32Array", "int": tm.sqlTypesAlias + ".SqlInt32Array",
|
||||
"int4": tm.sqlTypesAlias + ".SqlInt32Array", "serial": tm.sqlTypesAlias + ".SqlInt32Array",
|
||||
"smallint": tm.sqlTypesAlias + ".SqlInt16Array", "int2": tm.sqlTypesAlias + ".SqlInt16Array",
|
||||
"smallserial": tm.sqlTypesAlias + ".SqlInt16Array",
|
||||
"bigint": tm.sqlTypesAlias + ".SqlInt64Array", "int8": tm.sqlTypesAlias + ".SqlInt64Array",
|
||||
"bigserial": tm.sqlTypesAlias + ".SqlInt64Array",
|
||||
"real": tm.sqlTypesAlias + ".SqlFloat32Array", "float4": tm.sqlTypesAlias + ".SqlFloat32Array",
|
||||
"double precision": tm.sqlTypesAlias + ".SqlFloat64Array", "float8": tm.sqlTypesAlias + ".SqlFloat64Array",
|
||||
"numeric": tm.sqlTypesAlias + ".SqlFloat64Array", "decimal": tm.sqlTypesAlias + ".SqlFloat64Array",
|
||||
"money": tm.sqlTypesAlias + ".SqlFloat64Array",
|
||||
"boolean": tm.sqlTypesAlias + ".SqlBoolArray", "bool": tm.sqlTypesAlias + ".SqlBoolArray",
|
||||
"uuid": tm.sqlTypesAlias + ".SqlUUIDArray",
|
||||
}
|
||||
if goType, ok := typeMap[baseElemType]; ok {
|
||||
return goType
|
||||
}
|
||||
return tm.sqlTypesAlias + ".SqlStringArray"
|
||||
}
|
||||
|
||||
// rawGoType returns the plain Go type for a NOT NULL column in stdlib mode.
|
||||
func (tm *TypeMapper) rawGoType(sqlType string) string {
|
||||
typeMap := map[string]string{
|
||||
"integer": "int32", "int": "int32", "int4": "int32", "serial": "int32",
|
||||
"smallint": "int16", "int2": "int16", "smallserial": "int16",
|
||||
"bigint": "int64", "int8": "int64", "bigserial": "int64",
|
||||
"boolean": "bool", "bool": "bool",
|
||||
"real": "float32", "float4": "float32",
|
||||
"double precision": "float64", "float8": "float64",
|
||||
"numeric": "float64", "decimal": "float64", "money": "float64",
|
||||
"text": "string", "varchar": "string", "char": "string",
|
||||
"character": "string", "citext": "string", "bpchar": "string",
|
||||
"inet": "string", "cidr": "string", "macaddr": "string",
|
||||
"uuid": "string", "json": "string", "jsonb": "string",
|
||||
"timestamp": "time.Time",
|
||||
"timestamp without time zone": "time.Time",
|
||||
"timestamp with time zone": "time.Time",
|
||||
"timestamptz": "time.Time",
|
||||
"date": "time.Time",
|
||||
"time": "time.Time",
|
||||
"time without time zone": "time.Time",
|
||||
"time with time zone": "time.Time",
|
||||
"timetz": "time.Time",
|
||||
"bytea": "[]byte",
|
||||
"vector": "[]float32",
|
||||
}
|
||||
if goType, ok := typeMap[sqlType]; ok {
|
||||
return goType
|
||||
}
|
||||
return "string"
|
||||
}
|
||||
|
||||
// stdlibNullableGoType returns the database/sql nullable type for a column.
|
||||
func (tm *TypeMapper) stdlibNullableGoType(sqlType string) string {
|
||||
typeMap := map[string]string{
|
||||
"integer": "sql.NullInt32", "int": "sql.NullInt32", "int4": "sql.NullInt32", "serial": "sql.NullInt32",
|
||||
"smallint": "sql.NullInt16", "int2": "sql.NullInt16", "smallserial": "sql.NullInt16",
|
||||
"bigint": "sql.NullInt64", "int8": "sql.NullInt64", "bigserial": "sql.NullInt64",
|
||||
"boolean": "sql.NullBool", "bool": "sql.NullBool",
|
||||
"real": "sql.NullFloat64", "float4": "sql.NullFloat64",
|
||||
"double precision": "sql.NullFloat64", "float8": "sql.NullFloat64",
|
||||
"numeric": "sql.NullFloat64", "decimal": "sql.NullFloat64", "money": "sql.NullFloat64",
|
||||
"text": "sql.NullString", "varchar": "sql.NullString", "char": "sql.NullString",
|
||||
"character": "sql.NullString", "citext": "sql.NullString", "bpchar": "sql.NullString",
|
||||
"inet": "sql.NullString", "cidr": "sql.NullString", "macaddr": "sql.NullString",
|
||||
"uuid": "sql.NullString", "json": "sql.NullString", "jsonb": "sql.NullString",
|
||||
"timestamp": "sql.NullTime",
|
||||
"timestamp without time zone": "sql.NullTime",
|
||||
"timestamp with time zone": "sql.NullTime",
|
||||
"timestamptz": "sql.NullTime",
|
||||
"date": "sql.NullTime",
|
||||
"time": "sql.NullTime",
|
||||
"time without time zone": "sql.NullTime",
|
||||
"time with time zone": "sql.NullTime",
|
||||
"timetz": "sql.NullTime",
|
||||
"bytea": "[]byte",
|
||||
"vector": "[]float32",
|
||||
}
|
||||
if goType, ok := typeMap[sqlType]; ok {
|
||||
return goType
|
||||
}
|
||||
return "sql.NullString"
|
||||
}
|
||||
|
||||
// stdlibArrayGoType returns a plain Go slice type for array columns in stdlib mode.
|
||||
func (tm *TypeMapper) stdlibArrayGoType(baseElemType string) string {
|
||||
typeMap := map[string]string{
|
||||
"text": "[]string", "varchar": "[]string", "char": "[]string",
|
||||
"character": "[]string", "citext": "[]string", "bpchar": "[]string",
|
||||
"inet": "[]string", "cidr": "[]string", "macaddr": "[]string",
|
||||
"uuid": "[]string", "json": "[]string", "jsonb": "[]string",
|
||||
"integer": "[]int32", "int": "[]int32", "int4": "[]int32", "serial": "[]int32",
|
||||
"smallint": "[]int16", "int2": "[]int16", "smallserial": "[]int16",
|
||||
"bigint": "[]int64", "int8": "[]int64", "bigserial": "[]int64",
|
||||
"real": "[]float32", "float4": "[]float32",
|
||||
"double precision": "[]float64", "float8": "[]float64",
|
||||
"numeric": "[]float64", "decimal": "[]float64", "money": "[]float64",
|
||||
"boolean": "[]bool", "bool": "[]bool",
|
||||
}
|
||||
if goType, ok := typeMap[baseElemType]; ok {
|
||||
return goType
|
||||
}
|
||||
return "[]string"
|
||||
}
|
||||
|
||||
// BuildGormTag generates a complete GORM tag string for a column
|
||||
func (tm *TypeMapper) BuildGormTag(column *models.Column, table *models.Table) string {
|
||||
var parts []string
|
||||
@@ -330,7 +467,16 @@ func (tm *TypeMapper) NeedsFmtImport(generateGetIDStr bool) bool {
|
||||
return generateGetIDStr
|
||||
}
|
||||
|
||||
// GetSQLTypesImport returns the import path for sql_types
|
||||
// GetSQLTypesImport returns the import path for the ResolveSpec spectypes package.
|
||||
func (tm *TypeMapper) GetSQLTypesImport() string {
|
||||
return "github.com/bitechdev/ResolveSpec/pkg/spectypes"
|
||||
}
|
||||
|
||||
// GetNullableTypeImportLine returns the full Go import line for the nullable type
|
||||
// package (ready to pass to AddImport). Returns empty string when no import is needed.
|
||||
func (tm *TypeMapper) GetNullableTypeImportLine() string {
|
||||
if tm.typeStyle == writers.NullableTypeStdlib {
|
||||
return "\"database/sql\""
|
||||
}
|
||||
return fmt.Sprintf("%s \"%s\"", tm.sqlTypesAlias, tm.GetSQLTypesImport())
|
||||
}
|
||||
|
||||
@@ -24,7 +24,7 @@ type Writer struct {
|
||||
func NewWriter(options *writers.WriterOptions) *Writer {
|
||||
w := &Writer{
|
||||
options: options,
|
||||
typeMapper: NewTypeMapper(),
|
||||
typeMapper: NewTypeMapper(options.NullableTypes),
|
||||
config: LoadMethodConfigFromMetadata(options.Metadata),
|
||||
}
|
||||
|
||||
@@ -77,8 +77,8 @@ func (w *Writer) writeSingleFile(db *models.Database) error {
|
||||
packageName := w.getPackageName()
|
||||
templateData := NewTemplateData(packageName, w.config)
|
||||
|
||||
// Add sql_types import (always needed for nullable types)
|
||||
templateData.AddImport(fmt.Sprintf("sql_types \"%s\"", w.typeMapper.GetSQLTypesImport()))
|
||||
// Add nullable types import (resolvespec or stdlib depending on options)
|
||||
templateData.AddImport(w.typeMapper.GetNullableTypeImportLine())
|
||||
|
||||
// Collect all models
|
||||
for _, schema := range db.Schemas {
|
||||
@@ -171,8 +171,8 @@ func (w *Writer) writeMultiFile(db *models.Database) error {
|
||||
// Create template data for this single table
|
||||
templateData := NewTemplateData(packageName, w.config)
|
||||
|
||||
// Add sql_types import
|
||||
templateData.AddImport(fmt.Sprintf("sql_types \"%s\"", w.typeMapper.GetSQLTypesImport()))
|
||||
// Add nullable types import (resolvespec or stdlib depending on options)
|
||||
templateData.AddImport(w.typeMapper.GetNullableTypeImportLine())
|
||||
|
||||
// Create model data
|
||||
modelData := NewModelData(table, schema.Name, w.typeMapper, w.options.FlattenSchema)
|
||||
|
||||
@@ -643,7 +643,7 @@ func TestNameConverter_Pluralize(t *testing.T) {
|
||||
}
|
||||
|
||||
func TestTypeMapper_SQLTypeToGoType(t *testing.T) {
|
||||
mapper := NewTypeMapper()
|
||||
mapper := NewTypeMapper("")
|
||||
|
||||
tests := []struct {
|
||||
sqlType string
|
||||
@@ -671,7 +671,7 @@ func TestTypeMapper_SQLTypeToGoType(t *testing.T) {
|
||||
}
|
||||
|
||||
func TestTypeMapper_BuildGormTag_PreservesExplicitTypeModifiers(t *testing.T) {
|
||||
mapper := NewTypeMapper()
|
||||
mapper := NewTypeMapper("")
|
||||
|
||||
col := &models.Column{
|
||||
Name: "embedding",
|
||||
|
||||
Reference in New Issue
Block a user