config

type Column struct {
	// The name of the column. This is the name that will be used in the output.
	Name string `hcl:"name,label" cty:"name"`
	// The DuckDB name of the column in the source.
	Type *string `hcl:"type" cty:"type"`
	// The source name of the column. This is the field name in the source data
	Source *string `hcl:"source" cty:"source"`
	// An optional description of the column.
	Description *string `hcl:"description" cty:"description"`
	// Is the column required?
	Required *bool `hcl:"required" cty:"required"`
	// An optional null value for the column. If the source value contains this, the column will be null
	NullIf *string `hcl:"null_if" cty:"null_if"`
	// A duck DB transform function to apply to the column. This should be expressed as a SQL function
	// If a Transform is provided, no source should be provided.
	// e.g. "upper(name)"
	Transform *string `hcl:"transform" cty:"transform"`
}

type Filter struct {
	modconfig.HclResourceImpl
	// required to allow partial decoding
	Remain hcl.Body `hcl:",remain" json:"-"`

	Where *string `hcl:"where"`
}

type Format struct {
	modconfig.HclResourceImpl
	// required to allow partial decoding
	Remain hcl.Body `hcl:",remain" json:"-"`

	// the format type
	Type string `cty:"type"`
	// the raw HCL of the format (this will be decoded by the plugin which implements the format)
	Config *HclBytes `cty:"config"`
	// alternatively, the preset name opf the format
	PresetName string `cty:"preset"`
}

type HclBytes struct {
	Hcl   []byte           `cty:"hcl"`
	Range hclhelpers.Range `cty:"range"`
}

type Partition struct {
	modconfig.HclResourceImpl
	// required to allow partial decoding
	Remain hcl.Body `hcl:",remain" json:"-"`

	// the name of the table this partition is for - this is the first label in the partition block
	TableName string

	// if the partition of for a custom table, this will be set to the custom table config
	CustomTable *Table `cty:"table"`

	// Plugin used for this partition
	Plugin *plugin.Plugin `cty:"-"`

	// Source of the data for this partition
	Source Source `cty:"source"`

	// any partition-type specific config data for the partition
	Config []byte `cty:"config"`
	// the config location
	ConfigRange hclhelpers.Range `cty:"config_range"`
	// an option filter in the format of a SQL where clause
	Filter string
}

type Source struct {
	Type       string              `hcl:" type,label" cty:"type"`
	Connection *TailpipeConnection `hcl:"connection" cty:"connection"`
	// optional: the format (for custom tables)
	Format *Format `hcl:"format" cty:"format"`
	// the config hcl
	Config *HclBytes `cty:"config"`
}

type Table struct {
	modconfig.HclResourceImpl
	// required to allow partial decoding
	Remain hcl.Body `hcl:",remain" json:"-"`

	// the default format for this table (todo make a map keyed by source name?)
	DefaultSourceFormat *Format `hcl:"format" cty:"format"`

	Columns []Column `hcl:"column,block" cty:"columns"`

	// should we include ALL source fields in addition to any defined columns, or ONLY include the columns defined
	MapFields []string `hcl:"map_fields,optional" cty:"map_fields"`
	// the default null value for the table (may be overridden for specific columns)
	NullIf string `hcl:"null_if,optional" cty:"null_if"`
}

type TailpipeConfig struct {
	// map of partitions, keyed by unqualified name (<partition_type>.<partition_name>)
	Partitions map[string]*Partition

	Connections map[string]*TailpipeConnection

	PluginVersions map[string]*versionfile.InstalledVersion
	CustomTables   map[string]*Table
	Formats        map[string]*Format
}

type TailpipeConnection struct {
	modconfig.HclResourceImpl
	// required to allow partial decoding
	Remain hcl.Body `hcl:",remain" json:"-"`

	Plugin string `cty:"plugin"`
	Hcl    []byte `cty:"hcl"`
	// the hcl range for the connection - use our version so we can sty serialise it
	HclRange hclhelpers.Range `cty:"hcl_range"`
}