domain: add the in-process domain

Signed-off-by: Ignasi Barrera <ignasi@tetrate.io>

Author: nacx

src/pkg/common/common.go

@@ -12,6 +12,7 @@ import (
 	"strings"
 
 	oscalTypes "github.com/defenseunicorns/go-oscal/src/types/oscal-1-1-3"
+	"github.com/defenseunicorns/lula/src/pkg/domains/inprocess"
 	goversion "github.com/hashicorp/go-version"
 	"k8s.io/apimachinery/pkg/util/yaml"
 
@@ -155,6 +156,8 @@ func GetDomain(domain *Domain) (types.Domain, error) {
 		return api.CreateApiDomain(domain.ApiSpec)
 	case "file":
 		return files.CreateDomain(domain.FileSpec)
+	case "in-process":
+		return inprocess.CreateDomain(domain.InProcessSpec)
 	default:
 		return nil, fmt.Errorf("domain is unsupported")
 	}

src/pkg/common/schemas/validation.json

@@ -52,7 +52,8 @@
                     "enum": [
                         "kubernetes",
                         "api",
-                        "file"
+                        "file",
+                        "in-process"
                     ],
                     "description": "The type of domain (Required)"
                 },
@@ -462,6 +463,14 @@
                 }
             }
         },
+        "inprocess-spec": {
+            "type": "object",
+            "properties": {
+                "resources": {
+                    "type": "object"
+                }
+            }
+        },
         "provider": {
             "type": "object",
             "properties": {

src/pkg/common/types.go

@@ -10,6 +10,7 @@ import (
 	"github.com/defenseunicorns/go-oscal/src/pkg/uuid"
 	oscalValidation "github.com/defenseunicorns/go-oscal/src/pkg/validation"
 	oscalTypes "github.com/defenseunicorns/go-oscal/src/types/oscal-1-1-3"
+	"github.com/defenseunicorns/lula/src/pkg/domains/inprocess"
 	"sigs.k8s.io/yaml"
 
 	"github.com/defenseunicorns/lula/src/config"
@@ -104,6 +105,8 @@ type Domain struct {
 	ApiSpec *api.ApiSpec `json:"api-spec,omitempty" yaml:"api-spec,omitempty"`
 	// FileSpec is the specification for a File domain, required if type is file
 	FileSpec *files.Spec `json:"file-spec,omitempty" yaml:"file-spec,omitempty"`
+	// InProcessSpec is the specification for an InProcess domain, required if type is in-process
+	InProcessSpec *inprocess.Spec `json:"inprocess-spec,omitempty" yaml:"inprocess-spec,omitempty"`
 }
 
 type Provider struct {

src/pkg/domains/inprocess/registry.go

@@ -0,0 +1,81 @@
+// Copyright (c) Tetrate, Inc 2025 All Rights Reserved.
+
+package inprocess
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"sync"
+)
+
+var (
+	ErrAlreadyRegistered = errors.New("already registered")
+	ErrNotFound          = errors.New("not found")
+
+	// globalRegistry is the global registry of domain functions.
+	globalRegistry = NewRegistry()
+
+	_ Registry = (*registry)(nil)
+)
+
+// ResourcesFunction is a function used to return the domain resources.
+type (
+	ResourcesFunction func(context.Context) (any, error)
+
+	// Registry is the interface for the global registry of domain functions.
+	Registry interface {
+		// Register the given domain function in the registry.
+		Register(name string, f ResourcesFunction) error
+		// Unregister the given domain function from the registry.
+		Unregister(name string)
+		// Run the domain function with the given name.
+		Run(ctx context.Context, name string) (any, error)
+	}
+)
+
+// GlobalRegistry returns the global registry of domain functions.
+func GlobalRegistry() Registry { return globalRegistry }
+
+// NewRegistry creates a new registry of domain functions.
+func NewRegistry() Registry {
+	return &registry{functions: make(map[string]ResourcesFunction)}
+}
+
+// registry is a thread-safe collection of domain functions.
+type registry struct {
+	mu        sync.RWMutex
+	functions map[string]ResourcesFunction
+}
+
+// Register the given domain function in the registry.
+func (r *registry) Register(name string, f ResourcesFunction) error {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+
+	if _, ok := r.functions[name]; ok {
+		return fmt.Errorf("%w: %s", ErrAlreadyRegistered, name)
+	}
+	r.functions[name] = f
+	return nil
+}
+
+// Unregister the given domain function from the registry.
+func (r *registry) Unregister(name string) {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+
+	delete(r.functions, name)
+}
+
+// Run the domain function with the given name.
+func (r *registry) Run(ctx context.Context, name string) (any, error) {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+
+	f, ok := r.functions[name]
+	if !ok {
+		return nil, fmt.Errorf("%w: %s", ErrNotFound, name)
+	}
+	return f(ctx)
+}

src/pkg/domains/inprocess/spec.go

@@ -0,0 +1,49 @@
+// Copyright (c) Tetrate, Inc 2025 All Rights Reserved.
+
+package inprocess
+
+import (
+	"context"
+
+	"github.com/defenseunicorns/lula/src/types"
+)
+
+type (
+	// Spec configures the properties of the in process domain
+	Spec struct {
+		// Resources is a map of variables to function names to call
+		Resources map[string]string `json:"resources" yaml:"resources"`
+	}
+
+	// Domain is a structure that contains the domain type and the corresponding spec
+	Domain struct {
+		Spec     *Spec `json:"spec" yaml:"spec"`
+		registry Registry
+	}
+)
+
+// CreateDomain creates a new in process domain.
+func CreateDomain(spec *Spec) (*Domain, error) {
+	return &Domain{
+		Spec:     spec,
+		registry: GlobalRegistry(),
+	}, nil
+}
+
+// IsExecutable implements Domain.
+func (d Domain) IsExecutable() bool { return false }
+
+// GetResources implements Domain.
+func (d Domain) GetResources(ctx context.Context) (types.DomainResources, error) {
+	resources := make(types.DomainResources)
+	for variable, functionName := range d.Spec.Resources {
+		res, err := d.registry.Run(ctx, functionName)
+		if err != nil {
+			return nil, err
+		}
+		resources[variable] = res
+	}
+	return resources, nil
+}
+
+var _ types.Domain = (*Domain)(nil)