metadataobject

type DefaultObjectType int

type DefaultWriteDiffOpts struct {
	From Object
	WriteDiffOpts
	ExcludeFilesPatterns []string
}

type ErrParsingMetadataObject interface {
	// ObjectName corresponds to metadata object in JSON format
	// eg: source, api_limits etc
	ObjectName() string
	// Filename corresponding to metadata object
	// eg: databases.yaml, actions.yaml
	Filename() string
	// ErrorContext will contain any additional information regarding error
	ErrorContext() string

	// Unwrap will make sure the error returned is unwrappable
	// https://blog.golang.org/go1.13-errors#TOC_3.1.
	Unwrap() error
	error
}

type Object interface {
	// Build will be responsible for reading the metadata object from metadata files in project directory
	// It should return nil if it was not able to find the matching metadata file
	// Build returns a map of the objects, and it's corresponding unmarshalled content
	// For example:
	// an implementation for handling the "remote_schemas" object might return a map like
	// "remote_schemas": []yaml.Node
	// since there is a chance that this function can return a yaml.Node. The return value is not expected to
	// directly be unmarshalled to JSON using json.Marshal
	Build() (map[string]interface{}, ErrParsingMetadataObject)
	// Export is responsible for writing the yaml Node(s) for the metadata object
	// to project directory
	// Export expects a map[string]yaml.Node specifically rather than a builtin data structure like
	// map[string]interface{} because it does not guarantee the order in which contents will be unmarshalled.
	// eg: say we received the following JSON metadata from the server
	// {
	//		"foo": [
	//			"x": 1,
	//			"a": 2,
	//		],
	// }
	// we are interested in preserving the order of keys when transforming this to YAML. Something like the following
	// foo:
	// 	x: 1
	// 	a: 2
	// This ordering is not guaranteed if we are using map[string]interface{} to unmarshal the JSON. This might look
	// something like the following
	// foo:
	// 	a: 2
	// 	x: 1
	// This not bug, since JSON spec doesn't guarantee the ordering anyway.
	// We are interested in writing or transforming the JSON object received from the server in
	// the same order to YAML files. This coupled with our requirement of NOT strongly typing metadata on CLI requires
	// using yaml.Node to preserve the ordering.
	Export(metadata map[string]yaml.Node) (map[string][]byte, ErrParsingMetadataObject)
	CreateFiles() error
	// GetFiles will return an array of file paths which make up the metadata object.
	// For example the "sources" metadata key is made up of files like
	// databases.yaml. which then will have !include tags which will branch to include
	// files like databases/<source-name>/tables/tables.yaml
	// this function is expected to return the list of all these files which make up the metadata object
	GetFiles() ([]string, ErrParsingMetadataObject)
	// WriteDiff should be implemented such that it should write the difference
	// between the current object and passed in object on the provided writer
	WriteDiff(WriteDiffOpts) ErrParsingMetadataObject
	Key() string
	Filename() string
	// BaseDirectory will return the parent directory of `Filename()`
	BaseDirectory() string
}

type Objects []Object

type WriteDiffOpts struct {
	To           Object
	W            io.Writer
	DisableColor bool
}