v1alpha1

type PublishedResource struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec PublishedResourceSpec `json:"spec"`

	// Status contains reconciliation information for the published resource.
	Status PublishedResourceStatus `json:"status,omitempty"`
}

type PublishedResourceList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []PublishedResource `json:"items"`
}

type PublishedResourceSpec struct {
	// Describes the "source" Resource that exists on this, the service cluster,
	// that should be exposed in kcp workspaces. All fields have to be specified.
	Resource SourceResourceDescriptor `json:"resource"`

	// If specified, the filter will be applied to the resources in a workspace
	// and allow restricting which of them will be handled by the Sync Agent.
	Filter *ResourceFilter `json:"filter,omitempty"`

	// Naming can be used to control how the namespace and names for local objects
	// are formed. If not specified, the Sync Agent will use defensive defaults to
	// prevent naming collisions in the service cluster.
	// When configuring this, great care must be taken to not allow for naming
	// collisions to happen; keep in mind that the same name/namespace can exists in
	// many different kcp workspaces.
	Naming *ResourceNaming `json:"naming,omitempty"`

	// EnableWorkspacePaths toggles whether the Sync Agent will not just store the kcp
	// cluster name as a label on each locally synced object, but also the full workspace
	// path. This is optional because it requires additional requests to kcp and
	// should only be used if the workspace path is of interest on the
	// service cluster side.
	EnableWorkspacePaths bool `json:"enableWorkspacePaths,omitempty"`

	// Projection is used to change the GVK of a published resource within kcp.
	// This can be used to hide implementation details and provide a customized API
	// experience to the user.
	// All fields in the projection are optional. If a field is set, it will overwrite
	// that field in the GVK. The namespaced field can be set to turn a cluster-wide
	// resource namespaced or vice-versa.
	Projection *ResourceProjection `json:"projection,omitempty"`

	// Mutation allows to configure "rewrite rules" to modify the objects in both
	// directions during the synchronization.
	Mutation *ResourceMutationSpec `json:"mutation,omitempty"`

	Related []RelatedResourceSpec `json:"related,omitempty"`
}

type PublishedResourceStatus struct {
	ResourceSchemaName string `json:"resourceSchemaName,omitempty"`
}

type RegularExpression struct {
	// Pattern can be left empty to simply replace the entire value with the
	// replacement.
	Pattern string `json:"pattern,omitempty"`
	// Replacement is the string that the matched pattern is replaced with. It
	// can contain references to groups in the pattern by using \N.
	Replacement string `json:"replacement,omitempty"`
}

type RelatedResourceObject struct {
	RelatedResourceObjectSpec `json:",inline"`

	// Namespace configures in what namespace the related object resides in. If
	// not specified, the same namespace as the main object is assumed. If the
	// main object is cluster-scoped, this field is required and an error will be
	// raised during syncing if the field is not specified.
	Namespace *RelatedResourceObjectSpec `json:"namespace,omitempty"`
}

type RelatedResourceObjectReference struct {
	// Path is a simplified JSONPath expression like "metadata.name". A reference
	// must always select at least _something_ in the object, even if the value
	// is discarded by the regular expression.
	Path string `json:"path"`
	// Regex is a Go regular expression that is optionally applied to the selected
	// value from the path.
	Regex *RegularExpression `json:"regex,omitempty"`
}

type RelatedResourceObjectSelector struct {
	metav1.LabelSelector `json:",inline"`

	Rewrite RelatedResourceSelectorRewrite `json:"rewrite"`
}

type RelatedResourceObjectSpec struct {
	// Selector is a label selector that is useful if no reference is in the
	// main resource (i.e. if the related object links back to its parent, instead
	// of the parent pointing to the related object).
	Selector *RelatedResourceObjectSelector `json:"selector,omitempty"`
	// Reference points to a field inside the main object. This reference is
	// evaluated on both source and destination sides to find the related object.
	Reference *RelatedResourceObjectReference `json:"reference,omitempty"`
	// Template is a Go templated string that can make use of variables to
	// construct the resulting string.
	Template *TemplateExpression `json:"template,omitempty"`
}

type RelatedResourceOrigin string

type RelatedResourceSelectorRewrite struct {
	// Regex is a Go regular expression that is optionally applied to the selected
	// value from the path.
	Regex    *RegularExpression  `json:"regex,omitempty"`
	Template *TemplateExpression `json:"template,omitempty"`
}

type RelatedResourceSpec struct {
	// Identifier is a unique name for this related resource. The name must be unique within one
	// PublishedResource and is the key by which consumers (end users) can identify and consume the
	// related resource. Common names are "connection-details" or "credentials".
	// The identifier must be an alphanumeric string.
	Identifier string `json:"identifier"`

	// +kubebuilder:validation:Enum=service;kcp
	Origin RelatedResourceOrigin `json:"origin"`

	// ConfigMap or Secret
	Kind string `json:"kind"`

	// Object describes how the related resource can be found on the origin side
	// and where it is to supposed to be created on the destination side.
	Object RelatedResourceObject `json:"object"`

	// Mutation configures optional transformation rules for the related resource.
	// Status mutations are only performed when the related resource originates in kcp.
	Mutation *ResourceMutationSpec `json:"mutation,omitempty"`
}

type ResourceDeleteMutation struct {
	Path string `json:"path"`
}

type ResourceFilter struct {
	// When given, the namespace filter will be applied to a resource's namespace.
	Namespace *metav1.LabelSelector `json:"namespace,omitempty"`
	// When given, the resource filter will be applied to a resource itself.
	Resource *metav1.LabelSelector `json:"resource,omitempty"`
}

type ResourceMutation struct {
	Delete   *ResourceDeleteMutation   `json:"delete,omitempty"`
	Regex    *ResourceRegexMutation    `json:"regex,omitempty"`
	Template *ResourceTemplateMutation `json:"template,omitempty"`
}

type ResourceMutationSpec struct {
	Spec   []ResourceMutation `json:"spec,omitempty"`
	Status []ResourceMutation `json:"status,omitempty"`
}

type ResourceNaming struct {
	// The name field allows to control the name the local objects created by the Sync Agent.
	// If left empty, the default value is:
	//
	//   "{{ .Object.metadata.namespace | sha3short }}-{{ .Object.metadata.name | sha3short }}"
	//
	// This guarantees unique names as long as the cluster name is used for the local namespace
	// (the default unless configured otherwise).
	//
	// This value is a Go template, see the documentation for the available variables and functions.
	//
	// Alternatively (but deprecated), this value can be a simple string using one of the following
	// placeholders:
	//
	//   - $remoteClusterName   -- the kcp workspace's cluster name (e.g. "1084s8ceexsehjm2")
	//   - $remoteNamespace     -- the original namespace used by the consumer inside the kcp
	//                             workspace (if targetNamespace is left empty, it's equivalent
	//                             to setting "$remote_ns")
	//   - $remoteNamespaceHash -- first 20 hex characters of the SHA-1 hash of $remoteNamespace
	//   - $remoteName          -- the original name of the object inside the kcp workspace
	//                             (rarely used to construct local namespace names)
	//   - $remoteNameHash      -- first 20 hex characters of the SHA-1 hash of $remoteName
	//
	// Authors are advised to use Go templates instead, as the custom variable syntax is deprecated
	// and will be removed from a future release of the Sync Agent.
	Name string `json:"name,omitempty"`

	// For namespaced resources, the this field allows to control where the local objects will
	// be created. If left empty, "{{ .ClusterName }}" is assumed.
	//
	// This value is a Go template, see the documentation for the available variables and functions.
	//
	// Alternatively (but deprecated), this value can be a simple string using one of the following
	// placeholders:
	//
	//   - $remoteClusterName   -- the kcp workspace's cluster name (e.g. "1084s8ceexsehjm2")
	//   - $remoteNamespace     -- the original namespace used by the consumer inside the kcp
	//                             workspace (if targetNamespace is left empty, it's equivalent
	//                             to setting "$remote_ns")
	//   - $remoteNamespaceHash -- first 20 hex characters of the SHA-1 hash of $remoteNamespace
	//   - $remoteName          -- the original name of the object inside the kcp workspace
	//                             (rarely used to construct local namespace names)
	//   - $remoteNameHash      -- first 20 hex characters of the SHA-1 hash of $remoteName
	//
	// Authors are advised to use Go templates instead, as the custom variable syntax is deprecated
	// and will be removed from a future release of the Sync Agent.
	Namespace string `json:"namespace,omitempty"`
}

type ResourceProjection struct {
	// The API group, for example "myservice.example.com". Leave empty to not modify the API group.
	Group string `json:"group,omitempty"`
	// The API version, for example "v1beta1". Leave empty to not modify the version.
	//
	// This field must not be set when multiple versions have been selected.
	//
	// Deprecated: Use .versions instead.
	Version string `json:"version,omitempty"`
	// Versions allows to map API versions onto new values in kcp. Leave empty to not modify the
	// versions.
	Versions map[string]string `json:"versions,omitempty"`
	// Whether or not the resource is namespaced.
	// +kubebuilder:validation:Enum=Cluster;Namespaced
	Scope ResourceScope `json:"scope,omitempty"`
	// The resource Kind, for example "Database". Setting this field will also overwrite
	// the singular name by lowercasing the resource kind. In addition, if this is set,
	// the plural name will also be updated by taking the lowercased kind name and appending
	// an "s". If this would yield an undesirable name, use the plural field to explicitly
	// give the plural name.
	Kind string `json:"kind,omitempty"`
	// When overwriting the Kind, it can be necessary to also override the plural name in
	// case of more complex pluralization rules.
	Plural string `json:"plural,omitempty"`
	// ShortNames can be used to overwrite the original short names for a resource, usually
	// when the Kind is remapped, new short names are also in order. Set this to an empty
	// list to remove all short names.
	// +optional
	ShortNames []string `json:"shortNames"` // not omitempty because we need to distinguish between [] and nil
	// Categories can be used to overwrite the original categories a resource was in. Set
	// this to an empty list to remove all categories.
	// +optional
	Categories []string `json:"categories"` // not omitempty because we need to distinguish between [] and nil
}

type ResourceRegexMutation struct {
	Path string `json:"path"`
	// Pattern can be left empty to simply replace the entire value with the
	// replacement.
	Pattern     string `json:"pattern,omitempty"`
	Replacement string `json:"replacement,omitempty"`
}

type ResourceScope string

type ResourceTemplateMutation struct {
	Path     string `json:"path"`
	Template string `json:"template"`
}

type SourceResourceDescriptor struct {
	// The API group of a resource, for example "storage.initroid.com".
	APIGroup string `json:"apiGroup"`
	// The API version, for example "v1beta1". Setting this field will only publish
	// the given version, otherwise all versions for the group/kind will be
	// published.
	//
	// Deprecated: Use .versions instead.
	Version string `json:"version,omitempty"`
	// Versions allows to select a subset of versions to publish. Leave empty
	// to publish all available versions.
	Versions []string `json:"versions,omitempty"`
	// The resource Kind, for example "Database".
	Kind string `json:"kind"`
}

type TemplateExpression struct {
	Template string `json:"template,omitempty"`
}