snapshot of https://github.com/cortezaproject/corteza.git (2024.9.x, 2026-09-18; blobs > 131072B omitted)

server/compose/rest/attachment.go

@@ -0,0 +1,199 @@
+package rest
+
+import (
+	"context"
+	"fmt"
+	"github.com/cortezaproject/corteza/server/pkg/errors"
+	"io"
+	"net/http"
+	"net/url"
+
+	"github.com/cortezaproject/corteza/server/compose/rest/request"
+	"github.com/cortezaproject/corteza/server/compose/service"
+	"github.com/cortezaproject/corteza/server/compose/types"
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/cortezaproject/corteza/server/pkg/auth"
+)
+
+type (
+	attachmentPayload struct {
+		*types.Attachment
+	}
+
+	attachmentSetPayload struct {
+		Filter types.AttachmentFilter `json:"filter"`
+		Set    []*attachmentPayload   `json:"set"`
+	}
+
+	Attachment struct {
+		attachment service.AttachmentService
+	}
+)
+
+func (Attachment) New() *Attachment {
+	return &Attachment{
+		attachment: service.DefaultAttachment,
+	}
+}
+
+// Attachments returns list of all files attached to records
+func (ctrl Attachment) List(ctx context.Context, r *request.AttachmentList) (interface{}, error) {
+	if !auth.GetIdentityFromContext(ctx).Valid() {
+		return nil, errors.Unauthorized("cannot list attachments")
+	}
+
+	f := types.AttachmentFilter{
+		NamespaceID: r.NamespaceID,
+		Kind:        r.Kind,
+		ModuleID:    r.ModuleID,
+		RecordID:    r.RecordID,
+		FieldName:   r.FieldName,
+	}
+
+	set, filter, err := ctrl.attachment.Find(ctx, f)
+	return ctrl.makeFilterPayload(ctx, set, filter, err)
+}
+
+func (ctrl Attachment) Read(ctx context.Context, r *request.AttachmentRead) (interface{}, error) {
+	if !auth.GetIdentityFromContext(ctx).Valid() {
+		return nil, errors.Unauthorized("cannot read attachment")
+	}
+
+	a, err := ctrl.attachment.FindByID(ctx, r.NamespaceID, r.AttachmentID)
+	return makeAttachmentPayload(ctx, a, err)
+}
+
+func (ctrl Attachment) Delete(ctx context.Context, r *request.AttachmentDelete) (interface{}, error) {
+	if !auth.GetIdentityFromContext(ctx).Valid() {
+		return nil, errors.Unauthorized("cannot delete attachment")
+	}
+
+	_, err := ctrl.attachment.FindByID(ctx, r.NamespaceID, r.AttachmentID)
+	if err != nil {
+		return nil, err
+	}
+
+	return api.OK(), ctrl.attachment.DeleteByID(ctx, r.NamespaceID, r.AttachmentID)
+}
+
+func (ctrl Attachment) Original(ctx context.Context, r *request.AttachmentOriginal) (interface{}, error) {
+	if err := ctrl.isAccessible(r.Kind, r.NamespaceID, r.AttachmentID, r.UserID, r.Sign); err != nil {
+		return nil, err
+	}
+
+	return ctrl.serve(ctx, r.NamespaceID, r.AttachmentID, false, r.Download)
+}
+
+func (ctrl Attachment) Preview(ctx context.Context, r *request.AttachmentPreview) (interface{}, error) {
+	if err := ctrl.isAccessible(r.Kind, r.NamespaceID, r.AttachmentID, r.UserID, r.Sign); err != nil {
+		return nil, err
+	}
+
+	return ctrl.serve(ctx, r.NamespaceID, r.AttachmentID, true, false)
+}
+
+func (ctrl Attachment) isAccessible(kind string, namespaceID, attachmentID, userID uint64, signature string) error {
+	if kind == types.PageAttachment || kind == types.IconAttachment || kind == types.NamespaceAttachment {
+		// Public Attachments
+		return nil
+	}
+
+	if signature == "" {
+		return errors.Unauthorized("missing signature")
+	}
+
+	if userID == 0 {
+		return errors.InvalidData("missing or invalid user ID")
+	}
+
+	if attachmentID == 0 {
+		return errors.InvalidData("missing or invalid attachment ID")
+	}
+
+	if !auth.DefaultSigner.Verify(signature, userID, namespaceID, attachmentID) {
+		return errors.InvalidData("missing or invalid signature")
+	}
+
+	return nil
+}
+
+func (ctrl Attachment) serve(ctx context.Context, namespaceID, attachmentID uint64, preview, download bool) (interface{}, error) {
+	return func(w http.ResponseWriter, req *http.Request) {
+		att, err := ctrl.attachment.FindByID(ctx, namespaceID, attachmentID)
+		if err != nil {
+			// Simplify error handling for now
+			w.WriteHeader(http.StatusNotFound)
+			return
+		}
+
+		var fh io.ReadSeekCloser
+
+		if preview {
+			fh, err = ctrl.attachment.OpenPreview(att)
+		} else {
+			fh, err = ctrl.attachment.OpenOriginal(att)
+		}
+
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+
+		defer fh.Close()
+
+		name := url.QueryEscape(att.Name)
+
+		if download {
+			w.Header().Add("Content-Disposition", "attachment; filename="+name)
+		} else {
+			w.Header().Add("Content-Disposition", "inline; filename="+name)
+			w.Header().Add("Content-Security-Policy", "default-src 'none'; style-src 'unsafe-inline'; sandbox")
+		}
+
+		http.ServeContent(w, req, name, att.CreatedAt, fh)
+	}, nil
+}
+
+func (ctrl Attachment) makeFilterPayload(ctx context.Context, aa types.AttachmentSet, f types.AttachmentFilter, err error) (*attachmentSetPayload, error) {
+	if err != nil {
+		return nil, err
+	}
+
+	asp := &attachmentSetPayload{Filter: f, Set: make([]*attachmentPayload, len(aa))}
+
+	for i := range aa {
+		asp.Set[i], _ = makeAttachmentPayload(ctx, aa[i], nil)
+	}
+
+	return asp, nil
+}
+
+func makeAttachmentPayload(ctx context.Context, a *types.Attachment, err error) (*attachmentPayload, error) {
+	if err != nil || a == nil {
+		return nil, err
+	}
+
+	var (
+		userID     = auth.GetIdentityFromContext(ctx).Identity()
+		signParams = fmt.Sprintf("?sign=%s&userID=%d", auth.DefaultSigner.Sign(userID, a.NamespaceID, a.ID), userID)
+
+		preview string
+		baseURL = fmt.Sprintf("/namespace/%d/attachment/%s/%d/", a.NamespaceID, a.Kind, a.ID)
+	)
+
+	if a.Meta.Preview != nil {
+		var ext = a.Meta.Preview.Extension
+		if ext == "" {
+			ext = "jpg"
+		}
+
+		preview = baseURL + fmt.Sprintf("preview.%s", ext) + signParams
+	}
+
+	ap := &attachmentPayload{a}
+
+	ap.Url = baseURL + fmt.Sprintf("original/%s", url.PathEscape(a.Name)) + signParams
+	ap.PreviewUrl = preview
+
+	return ap, nil
+}

server/compose/rest/automation.go

@@ -0,0 +1,49 @@
+package rest
+
+import (
+	"context"
+
+	"github.com/cortezaproject/corteza/server/pkg/api"
+
+	"github.com/cortezaproject/corteza/server/compose/rest/request"
+	"github.com/cortezaproject/corteza/server/compose/service/event"
+	"github.com/cortezaproject/corteza/server/pkg/corredor"
+)
+
+type (
+	Automation struct{}
+)
+
+func (Automation) New() *Automation {
+	return &Automation{}
+}
+
+func (ctrl *Automation) List(ctx context.Context, r *request.AutomationList) (interface{}, error) {
+	return corredor.GenericListHandler(
+		ctx,
+		corredor.Service(),
+		corredor.Filter{
+			ResourceTypePrefixes: r.ResourceTypePrefixes,
+			ExcludeInvalid:       r.ExcludeInvalid,
+			ResourceTypes:        r.ResourceTypes,
+			EventTypes:           r.EventTypes,
+			ExcludeServerScripts: r.ExcludeServerScripts,
+			ExcludeClientScripts: r.ExcludeClientScripts,
+		},
+		"compose",
+	)
+}
+
+func (ctrl *Automation) Bundle(ctx context.Context, r *request.AutomationBundle) (interface{}, error) {
+	return corredor.GenericBundleHandler(
+		ctx,
+		corredor.Service(),
+		r.Bundle,
+		r.Type,
+		r.Ext,
+	)
+}
+
+func (ctrl *Automation) TriggerScript(ctx context.Context, r *request.AutomationTriggerScript) (interface{}, error) {
+	return api.OK(), corredor.Service().Exec(ctx, r.Script, corredor.ExtendScriptArgs(event.ComposeOnManual(), r.Args))
+}

server/compose/rest/chart.go

@@ -0,0 +1,173 @@
+package rest
+
+import (
+	"context"
+
+	"github.com/cortezaproject/corteza/server/compose/rest/request"
+	"github.com/cortezaproject/corteza/server/compose/service"
+	"github.com/cortezaproject/corteza/server/compose/types"
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/cortezaproject/corteza/server/pkg/filter"
+)
+
+type (
+	chartPayload struct {
+		*types.Chart
+
+		CanGrant       bool `json:"canGrant"`
+		CanUpdateChart bool `json:"canUpdateChart"`
+		CanDeleteChart bool `json:"canDeleteChart"`
+	}
+
+	chartSetPayload struct {
+		Filter types.ChartFilter `json:"filter"`
+		Set    []*chartPayload   `json:"set"`
+	}
+
+	Chart struct {
+		chart interface {
+			FindByID(ctx context.Context, namespaceID, chartID uint64) (*types.Chart, error)
+			FindByHandle(ctx context.Context, namespaceID uint64, handle string) (*types.Chart, error)
+			Find(ctx context.Context, filter types.ChartFilter) (set types.ChartSet, f types.ChartFilter, err error)
+
+			Create(ctx context.Context, chart *types.Chart) (*types.Chart, error)
+			Update(ctx context.Context, chart *types.Chart) (*types.Chart, error)
+			DeleteByID(ctx context.Context, namespaceID, chartID uint64) error
+		}
+		locale service.ResourceTranslationsManagerService
+		ac     chartAccessController
+	}
+
+	chartAccessController interface {
+		CanGrant(context.Context) bool
+
+		CanUpdateChart(context.Context, *types.Chart) bool
+		CanDeleteChart(context.Context, *types.Chart) bool
+	}
+)
+
+func (Chart) New() *Chart {
+	return &Chart{
+		chart:  service.DefaultChart,
+		locale: service.DefaultResourceTranslation,
+		ac:     service.DefaultAccessControl,
+	}
+}
+
+func (ctrl Chart) List(ctx context.Context, r *request.ChartList) (interface{}, error) {
+	var (
+		err error
+		f   = types.ChartFilter{
+			NamespaceID: r.NamespaceID,
+
+			Handle: r.Handle,
+			Query:  r.Query,
+			Labels: r.Labels,
+		}
+	)
+
+	if f.Paging, err = filter.NewPaging(r.Limit, r.PageCursor); err != nil {
+		return nil, err
+	}
+
+	f.IncTotal = r.IncTotal
+
+	if f.Sorting, err = filter.NewSorting(r.Sort); err != nil {
+		return nil, err
+	}
+
+	set, filter, err := ctrl.chart.Find(ctx, f)
+	return ctrl.makeFilterPayload(ctx, set, filter, err)
+}
+
+func (ctrl Chart) Create(ctx context.Context, r *request.ChartCreate) (interface{}, error) {
+	var err error
+	mod := &types.Chart{
+		NamespaceID: r.NamespaceID,
+		Name:        r.Name,
+		Handle:      r.Handle,
+		Labels:      r.Labels,
+	}
+
+	if len(r.Config) > 2 {
+		if err = r.Config.Unmarshal(&mod.Config); err != nil {
+			return nil, err
+		}
+	}
+	mod, err = ctrl.chart.Create(ctx, mod)
+	return ctrl.makePayload(ctx, mod, err)
+}
+
+func (ctrl Chart) Read(ctx context.Context, r *request.ChartRead) (interface{}, error) {
+	mod, err := ctrl.chart.FindByID(ctx, r.NamespaceID, r.ChartID)
+	return ctrl.makePayload(ctx, mod, err)
+
+}
+
+func (ctrl Chart) Update(ctx context.Context, r *request.ChartUpdate) (interface{}, error) {
+	var (
+		err error
+		mod = &types.Chart{
+			ID:          r.ChartID,
+			Name:        r.Name,
+			Handle:      r.Handle,
+			NamespaceID: r.NamespaceID,
+			UpdatedAt:   r.UpdatedAt,
+			Labels:      r.Labels,
+		}
+	)
+
+	if len(r.Config) > 2 {
+		if err = r.Config.Unmarshal(&mod.Config); err != nil {
+			return nil, err
+		}
+	}
+	mod, err = ctrl.chart.Update(ctx, mod)
+	return ctrl.makePayload(ctx, mod, err)
+}
+
+func (ctrl Chart) Delete(ctx context.Context, r *request.ChartDelete) (interface{}, error) {
+	_, err := ctrl.chart.FindByID(ctx, r.NamespaceID, r.ChartID)
+	if err != nil {
+		return nil, err
+	}
+
+	return api.OK(), ctrl.chart.DeleteByID(ctx, r.NamespaceID, r.ChartID)
+}
+
+func (ctrl Chart) ListTranslations(ctx context.Context, r *request.ChartListTranslations) (interface{}, error) {
+	return ctrl.locale.Chart(ctx, r.NamespaceID, r.ChartID)
+}
+
+func (ctrl Chart) UpdateTranslations(ctx context.Context, r *request.ChartUpdateTranslations) (interface{}, error) {
+	return api.OK(), ctrl.locale.Upsert(ctx, r.Translations)
+}
+
+func (ctrl Chart) makePayload(ctx context.Context, c *types.Chart, err error) (*chartPayload, error) {
+	if err != nil || c == nil {
+		return nil, err
+	}
+
+	return &chartPayload{
+		Chart: c,
+
+		CanGrant: ctrl.ac.CanGrant(ctx),
+
+		CanUpdateChart: ctrl.ac.CanUpdateChart(ctx, c),
+		CanDeleteChart: ctrl.ac.CanDeleteChart(ctx, c),
+	}, nil
+}
+
+func (ctrl Chart) makeFilterPayload(ctx context.Context, nn types.ChartSet, f types.ChartFilter, err error) (*chartSetPayload, error) {
+	if err != nil {
+		return nil, err
+	}
+
+	modp := &chartSetPayload{Filter: f, Set: make([]*chartPayload, len(nn))}
+
+	for i := range nn {
+		modp.Set[i], _ = ctrl.makePayload(ctx, nn[i], nil)
+	}
+
+	return modp, nil
+}

server/compose/rest/data_privacy.go

@@ -0,0 +1,137 @@
+package rest
+
+import (
+	"context"
+
+	"github.com/cortezaproject/corteza/server/compose/rest/request"
+	"github.com/cortezaproject/corteza/server/compose/service"
+	"github.com/cortezaproject/corteza/server/compose/types"
+	"github.com/cortezaproject/corteza/server/pkg/filter"
+	"github.com/cortezaproject/corteza/server/pkg/payload"
+)
+
+type (
+	sensitiveRecordsSetPayload struct {
+		Set []*sensitiveDataPayload `json:"set"`
+	}
+
+	sensitiveDataPayload struct {
+		NamespaceID uint64 `json:"namespaceID,string"`
+		Namespace   string `json:"namespace"`
+		ModuleID    uint64 `json:"moduleID,string"`
+		Module      string `json:"module"`
+
+		Records []sensitiveRecords `json:"records"`
+	}
+
+	sensitiveRecords struct {
+		RecordID uint64           `json:"recordID,string"`
+		Values   []map[string]any `json:"values"`
+	}
+
+	privacyModuleSetPayload struct {
+		Filter types.PrivacyModuleFilter `json:"filter"`
+		Set    []*types.PrivacyModule    `json:"set"`
+	}
+
+	privateDataFinder interface {
+		SearchSensitive(ctx context.Context) (set []types.SensitiveRecordSet, err error)
+	}
+
+	DataPrivacy struct {
+		record    privateDataFinder
+		module    service.ModuleService
+		namespace service.NamespaceService
+		privacy   service.DataPrivacyService
+	}
+)
+
+func (DataPrivacy) New() *DataPrivacy {
+	return &DataPrivacy{
+		record:    service.DefaultRecord,
+		module:    service.DefaultModule,
+		namespace: service.DefaultNamespace,
+		privacy:   service.DefaultDataPrivacy,
+	}
+}
+
+func (ctrl *DataPrivacy) RecordList(ctx context.Context, r *request.DataPrivacyRecordList) (out interface{}, err error) {
+	// If we're requesting only specific connections, prepare filter params here
+	reqConns := make(map[uint64]bool)
+	hasReqConns := len(r.ConnectionID) > 0
+	for _, connectionID := range payload.ParseUint64s(r.ConnectionID) {
+		reqConns[connectionID] = true
+	}
+
+	// Collect sensitive records
+	ss, err := ctrl.record.SearchSensitive(ctx)
+	if err != nil {
+		return
+	}
+
+	outSet := sensitiveRecordsSetPayload{
+		Set: make([]*sensitiveDataPayload, 0, 10),
+	}
+
+	for _, s := range ss {
+		// Skip the ones we don't want
+		if hasReqConns && !reqConns[s.Module.Config.DAL.ConnectionID] {
+			continue
+		}
+
+		// Build the payload
+		payload := &sensitiveDataPayload{
+			NamespaceID: s.Namespace.ID,
+			Namespace:   s.Namespace.Name,
+
+			ModuleID: s.Module.ID,
+			Module:   s.Module.Name,
+
+			Records: make([]sensitiveRecords, 0, len(s.Records)),
+		}
+		for _, a := range s.Records {
+			if len(a.Values) == 0 {
+				continue
+			}
+			payload.Records = append(payload.Records, sensitiveRecords{
+				RecordID: a.RecordID,
+				Values:   a.Values,
+			})
+		}
+
+		outSet.Set = append(outSet.Set, payload)
+	}
+
+	return outSet, nil
+}
+
+func (ctrl *DataPrivacy) ModuleList(ctx context.Context, r *request.DataPrivacyModuleList) (out interface{}, err error) {
+	var (
+		f = types.PrivacyModuleFilter{
+			ConnectionID: r.ConnectionID,
+		}
+	)
+
+	if f.Paging, err = filter.NewPaging(r.Limit, r.PageCursor); err != nil {
+		return nil, err
+	}
+
+	if f.Sorting, err = filter.NewSorting(r.Sort); err != nil {
+		return nil, err
+	}
+
+	set, f, err := ctrl.privacy.FindModules(ctx, f)
+	return ctrl.makeFilterPayload(ctx, set, f, err)
+}
+
+func (ctrl DataPrivacy) makeFilterPayload(_ context.Context, mm types.PrivacyModuleSet, f types.PrivacyModuleFilter, err error) (*privacyModuleSetPayload, error) {
+	if err != nil {
+		return nil, err
+	}
+
+	if len(mm) == 0 {
+		mm = make([]*types.PrivacyModule, 0)
+	}
+
+	return &privacyModuleSetPayload{Filter: f, Set: mm}, nil
+}

server/compose/rest/handlers/attachment.go

@@ -0,0 +1,133 @@
+package handlers
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"context"
+	"github.com/cortezaproject/corteza/server/compose/rest/request"
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	AttachmentAPI interface {
+		List(context.Context, *request.AttachmentList) (interface{}, error)
+		Read(context.Context, *request.AttachmentRead) (interface{}, error)
+		Delete(context.Context, *request.AttachmentDelete) (interface{}, error)
+		Original(context.Context, *request.AttachmentOriginal) (interface{}, error)
+		Preview(context.Context, *request.AttachmentPreview) (interface{}, error)
+	}
+
+	// HTTP API interface
+	Attachment struct {
+		List     func(http.ResponseWriter, *http.Request)
+		Read     func(http.ResponseWriter, *http.Request)
+		Delete   func(http.ResponseWriter, *http.Request)
+		Original func(http.ResponseWriter, *http.Request)
+		Preview  func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewAttachment(h AttachmentAPI) *Attachment {
+	return &Attachment{
+		List: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewAttachmentList()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.List(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Read: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewAttachmentRead()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Read(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Delete: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewAttachmentDelete()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Delete(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Original: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewAttachmentOriginal()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Original(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Preview: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewAttachmentPreview()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Preview(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+	}
+}
+
+func (h Attachment) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Get("/namespace/{namespaceID}/attachment/{kind}/", h.List)
+		r.Get("/namespace/{namespaceID}/attachment/{kind}/{attachmentID}", h.Read)
+		r.Delete("/namespace/{namespaceID}/attachment/{kind}/{attachmentID}", h.Delete)
+		r.Get("/namespace/{namespaceID}/attachment/{kind}/{attachmentID}/original/{name}", h.Original)
+		r.Get("/namespace/{namespaceID}/attachment/{kind}/{attachmentID}/preview.{ext}", h.Preview)
+	})
+}

server/compose/rest/handlers/automation.go

@@ -0,0 +1,95 @@
+package handlers
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"context"
+	"github.com/cortezaproject/corteza/server/compose/rest/request"
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	AutomationAPI interface {
+		List(context.Context, *request.AutomationList) (interface{}, error)
+		Bundle(context.Context, *request.AutomationBundle) (interface{}, error)
+		TriggerScript(context.Context, *request.AutomationTriggerScript) (interface{}, error)
+	}
+
+	// HTTP API interface
+	Automation struct {
+		List          func(http.ResponseWriter, *http.Request)
+		Bundle        func(http.ResponseWriter, *http.Request)
+		TriggerScript func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewAutomation(h AutomationAPI) *Automation {
+	return &Automation{
+		List: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewAutomationList()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.List(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Bundle: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewAutomationBundle()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Bundle(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		TriggerScript: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewAutomationTriggerScript()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.TriggerScript(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+	}
+}
+
+func (h Automation) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Get("/automation/", h.List)
+		r.Get("/automation/{bundle}-{type}.{ext}", h.Bundle)
+		r.Post("/automation/trigger", h.TriggerScript)
+	})
+}

server/compose/rest/handlers/chart.go

@@ -0,0 +1,171 @@
+package handlers
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"context"
+	"github.com/cortezaproject/corteza/server/compose/rest/request"
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	ChartAPI interface {
+		List(context.Context, *request.ChartList) (interface{}, error)
+		Create(context.Context, *request.ChartCreate) (interface{}, error)
+		Read(context.Context, *request.ChartRead) (interface{}, error)
+		Update(context.Context, *request.ChartUpdate) (interface{}, error)
+		Delete(context.Context, *request.ChartDelete) (interface{}, error)
+		ListTranslations(context.Context, *request.ChartListTranslations) (interface{}, error)
+		UpdateTranslations(context.Context, *request.ChartUpdateTranslations) (interface{}, error)
+	}
+
+	// HTTP API interface
+	Chart struct {
+		List               func(http.ResponseWriter, *http.Request)
+		Create             func(http.ResponseWriter, *http.Request)
+		Read               func(http.ResponseWriter, *http.Request)
+		Update             func(http.ResponseWriter, *http.Request)
+		Delete             func(http.ResponseWriter, *http.Request)
+		ListTranslations   func(http.ResponseWriter, *http.Request)
+		UpdateTranslations func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewChart(h ChartAPI) *Chart {
+	return &Chart{
+		List: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewChartList()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.List(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Create: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewChartCreate()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Create(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Read: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewChartRead()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Read(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Update: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewChartUpdate()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Update(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Delete: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewChartDelete()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Delete(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		ListTranslations: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewChartListTranslations()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.ListTranslations(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		UpdateTranslations: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewChartUpdateTranslations()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.UpdateTranslations(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+	}
+}
+
+func (h Chart) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Get("/namespace/{namespaceID}/chart/", h.List)
+		r.Post("/namespace/{namespaceID}/chart/", h.Create)
+		r.Get("/namespace/{namespaceID}/chart/{chartID}", h.Read)
+		r.Post("/namespace/{namespaceID}/chart/{chartID}", h.Update)
+		r.Delete("/namespace/{namespaceID}/chart/{chartID}", h.Delete)
+		r.Get("/namespace/{namespaceID}/chart/{chartID}/translation", h.ListTranslations)
+		r.Patch("/namespace/{namespaceID}/chart/{chartID}/translation", h.UpdateTranslations)
+	})
+}

server/compose/rest/handlers/dataPrivacy.go

@@ -0,0 +1,76 @@
+package handlers
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"context"
+	"github.com/cortezaproject/corteza/server/compose/rest/request"
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	DataPrivacyAPI interface {
+		RecordList(context.Context, *request.DataPrivacyRecordList) (interface{}, error)
+		ModuleList(context.Context, *request.DataPrivacyModuleList) (interface{}, error)
+	}
+
+	// HTTP API interface
+	DataPrivacy struct {
+		RecordList func(http.ResponseWriter, *http.Request)
+		ModuleList func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewDataPrivacy(h DataPrivacyAPI) *DataPrivacy {
+	return &DataPrivacy{
+		RecordList: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewDataPrivacyRecordList()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.RecordList(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		ModuleList: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewDataPrivacyModuleList()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.ModuleList(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+	}
+}
+
+func (h DataPrivacy) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Get("/data-privacy/record", h.RecordList)
+		r.Get("/data-privacy/module", h.ModuleList)
+	})
+}

server/compose/rest/handlers/icon.go

@@ -0,0 +1,95 @@
+package handlers
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"context"
+	"github.com/cortezaproject/corteza/server/compose/rest/request"
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	IconAPI interface {
+		List(context.Context, *request.IconList) (interface{}, error)
+		Upload(context.Context, *request.IconUpload) (interface{}, error)
+		Delete(context.Context, *request.IconDelete) (interface{}, error)
+	}
+
+	// HTTP API interface
+	Icon struct {
+		List   func(http.ResponseWriter, *http.Request)
+		Upload func(http.ResponseWriter, *http.Request)
+		Delete func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewIcon(h IconAPI) *Icon {
+	return &Icon{
+		List: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewIconList()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.List(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Upload: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewIconUpload()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Upload(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Delete: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewIconDelete()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Delete(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+	}
+}
+
+func (h Icon) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Get("/icon/", h.List)
+		r.Post("/icon/", h.Upload)
+		r.Delete("/icon/{iconID}", h.Delete)
+	})
+}

server/compose/rest/handlers/module.go

@@ -0,0 +1,190 @@
+package handlers
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"context"
+	"github.com/cortezaproject/corteza/server/compose/rest/request"
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	ModuleAPI interface {
+		List(context.Context, *request.ModuleList) (interface{}, error)
+		Create(context.Context, *request.ModuleCreate) (interface{}, error)
+		Read(context.Context, *request.ModuleRead) (interface{}, error)
+		Update(context.Context, *request.ModuleUpdate) (interface{}, error)
+		Delete(context.Context, *request.ModuleDelete) (interface{}, error)
+		TriggerScript(context.Context, *request.ModuleTriggerScript) (interface{}, error)
+		ListTranslations(context.Context, *request.ModuleListTranslations) (interface{}, error)
+		UpdateTranslations(context.Context, *request.ModuleUpdateTranslations) (interface{}, error)
+	}
+
+	// HTTP API interface
+	Module struct {
+		List               func(http.ResponseWriter, *http.Request)
+		Create             func(http.ResponseWriter, *http.Request)
+		Read               func(http.ResponseWriter, *http.Request)
+		Update             func(http.ResponseWriter, *http.Request)
+		Delete             func(http.ResponseWriter, *http.Request)
+		TriggerScript      func(http.ResponseWriter, *http.Request)
+		ListTranslations   func(http.ResponseWriter, *http.Request)
+		UpdateTranslations func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewModule(h ModuleAPI) *Module {
+	return &Module{
+		List: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewModuleList()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.List(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Create: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewModuleCreate()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Create(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Read: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewModuleRead()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Read(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Update: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewModuleUpdate()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Update(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Delete: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewModuleDelete()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Delete(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		TriggerScript: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewModuleTriggerScript()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.TriggerScript(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		ListTranslations: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewModuleListTranslations()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.ListTranslations(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		UpdateTranslations: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewModuleUpdateTranslations()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.UpdateTranslations(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+	}
+}
+
+func (h Module) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Get("/namespace/{namespaceID}/module/", h.List)
+		r.Post("/namespace/{namespaceID}/module/", h.Create)
+		r.Get("/namespace/{namespaceID}/module/{moduleID}", h.Read)
+		r.Post("/namespace/{namespaceID}/module/{moduleID}", h.Update)
+		r.Delete("/namespace/{namespaceID}/module/{moduleID}", h.Delete)
+		r.Post("/namespace/{namespaceID}/module/{moduleID}/trigger", h.TriggerScript)
+		r.Get("/namespace/{namespaceID}/module/{moduleID}/translation", h.ListTranslations)
+		r.Patch("/namespace/{namespaceID}/module/{moduleID}/translation", h.UpdateTranslations)
+	})
+}

server/compose/rest/handlers/namespace.go

@@ -0,0 +1,285 @@
+package handlers
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"context"
+	"github.com/cortezaproject/corteza/server/compose/rest/request"
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	NamespaceAPI interface {
+		List(context.Context, *request.NamespaceList) (interface{}, error)
+		Create(context.Context, *request.NamespaceCreate) (interface{}, error)
+		Read(context.Context, *request.NamespaceRead) (interface{}, error)
+		Update(context.Context, *request.NamespaceUpdate) (interface{}, error)
+		Delete(context.Context, *request.NamespaceDelete) (interface{}, error)
+		Upload(context.Context, *request.NamespaceUpload) (interface{}, error)
+		Clone(context.Context, *request.NamespaceClone) (interface{}, error)
+		Export(context.Context, *request.NamespaceExport) (interface{}, error)
+		ImportInit(context.Context, *request.NamespaceImportInit) (interface{}, error)
+		ImportRun(context.Context, *request.NamespaceImportRun) (interface{}, error)
+		TriggerScript(context.Context, *request.NamespaceTriggerScript) (interface{}, error)
+		ListTranslations(context.Context, *request.NamespaceListTranslations) (interface{}, error)
+		UpdateTranslations(context.Context, *request.NamespaceUpdateTranslations) (interface{}, error)
+	}
+
+	// HTTP API interface
+	Namespace struct {
+		List               func(http.ResponseWriter, *http.Request)
+		Create             func(http.ResponseWriter, *http.Request)
+		Read               func(http.ResponseWriter, *http.Request)
+		Update             func(http.ResponseWriter, *http.Request)
+		Delete             func(http.ResponseWriter, *http.Request)
+		Upload             func(http.ResponseWriter, *http.Request)
+		Clone              func(http.ResponseWriter, *http.Request)
+		Export             func(http.ResponseWriter, *http.Request)
+		ImportInit         func(http.ResponseWriter, *http.Request)
+		ImportRun          func(http.ResponseWriter, *http.Request)
+		TriggerScript      func(http.ResponseWriter, *http.Request)
+		ListTranslations   func(http.ResponseWriter, *http.Request)
+		UpdateTranslations func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewNamespace(h NamespaceAPI) *Namespace {
+	return &Namespace{
+		List: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewNamespaceList()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.List(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Create: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewNamespaceCreate()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Create(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Read: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewNamespaceRead()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Read(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Update: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewNamespaceUpdate()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Update(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Delete: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewNamespaceDelete()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Delete(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Upload: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewNamespaceUpload()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Upload(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Clone: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewNamespaceClone()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Clone(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Export: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewNamespaceExport()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Export(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		ImportInit: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewNamespaceImportInit()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.ImportInit(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		ImportRun: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewNamespaceImportRun()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.ImportRun(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		TriggerScript: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewNamespaceTriggerScript()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.TriggerScript(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		ListTranslations: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewNamespaceListTranslations()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.ListTranslations(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		UpdateTranslations: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewNamespaceUpdateTranslations()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.UpdateTranslations(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+	}
+}
+
+func (h Namespace) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Get("/namespace/", h.List)
+		r.Post("/namespace/", h.Create)
+		r.Get("/namespace/{namespaceID}", h.Read)
+		r.Post("/namespace/{namespaceID}", h.Update)
+		r.Delete("/namespace/{namespaceID}", h.Delete)
+		r.Post("/namespace/upload", h.Upload)
+		r.Post("/namespace/{namespaceID}/clone", h.Clone)
+		r.Get("/namespace/{namespaceID}/export/{filename}.zip", h.Export)
+		r.Post("/namespace/import", h.ImportInit)
+		r.Post("/namespace/import/{sessionID}", h.ImportRun)
+		r.Post("/namespace/{namespaceID}/trigger", h.TriggerScript)
+		r.Get("/namespace/{namespaceID}/translation", h.ListTranslations)
+		r.Patch("/namespace/{namespaceID}/translation", h.UpdateTranslations)
+	})
+}

server/compose/rest/handlers/notification.go

@@ -0,0 +1,57 @@
+package handlers
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"context"
+	"github.com/cortezaproject/corteza/server/compose/rest/request"
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	NotificationAPI interface {
+		EmailSend(context.Context, *request.NotificationEmailSend) (interface{}, error)
+	}
+
+	// HTTP API interface
+	Notification struct {
+		EmailSend func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewNotification(h NotificationAPI) *Notification {
+	return &Notification{
+		EmailSend: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewNotificationEmailSend()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.EmailSend(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+	}
+}
+
+func (h Notification) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Post("/notification/email", h.EmailSend)
+	})
+}

server/compose/rest/handlers/page.go

@@ -0,0 +1,266 @@
+package handlers
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"context"
+	"github.com/cortezaproject/corteza/server/compose/rest/request"
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	PageAPI interface {
+		List(context.Context, *request.PageList) (interface{}, error)
+		Create(context.Context, *request.PageCreate) (interface{}, error)
+		Read(context.Context, *request.PageRead) (interface{}, error)
+		Tree(context.Context, *request.PageTree) (interface{}, error)
+		Update(context.Context, *request.PageUpdate) (interface{}, error)
+		Reorder(context.Context, *request.PageReorder) (interface{}, error)
+		Delete(context.Context, *request.PageDelete) (interface{}, error)
+		Upload(context.Context, *request.PageUpload) (interface{}, error)
+		TriggerScript(context.Context, *request.PageTriggerScript) (interface{}, error)
+		ListTranslations(context.Context, *request.PageListTranslations) (interface{}, error)
+		UpdateTranslations(context.Context, *request.PageUpdateTranslations) (interface{}, error)
+		UpdateIcon(context.Context, *request.PageUpdateIcon) (interface{}, error)
+	}
+
+	// HTTP API interface
+	Page struct {
+		List               func(http.ResponseWriter, *http.Request)
+		Create             func(http.ResponseWriter, *http.Request)
+		Read               func(http.ResponseWriter, *http.Request)
+		Tree               func(http.ResponseWriter, *http.Request)
+		Update             func(http.ResponseWriter, *http.Request)
+		Reorder            func(http.ResponseWriter, *http.Request)
+		Delete             func(http.ResponseWriter, *http.Request)
+		Upload             func(http.ResponseWriter, *http.Request)
+		TriggerScript      func(http.ResponseWriter, *http.Request)
+		ListTranslations   func(http.ResponseWriter, *http.Request)
+		UpdateTranslations func(http.ResponseWriter, *http.Request)
+		UpdateIcon         func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewPage(h PageAPI) *Page {
+	return &Page{
+		List: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewPageList()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.List(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Create: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewPageCreate()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Create(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Read: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewPageRead()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Read(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Tree: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewPageTree()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Tree(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Update: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewPageUpdate()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Update(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Reorder: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewPageReorder()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Reorder(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Delete: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewPageDelete()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Delete(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Upload: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewPageUpload()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Upload(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		TriggerScript: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewPageTriggerScript()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.TriggerScript(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		ListTranslations: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewPageListTranslations()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.ListTranslations(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		UpdateTranslations: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewPageUpdateTranslations()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.UpdateTranslations(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		UpdateIcon: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewPageUpdateIcon()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.UpdateIcon(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+	}
+}
+
+func (h Page) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Get("/namespace/{namespaceID}/page/", h.List)
+		r.Post("/namespace/{namespaceID}/page/", h.Create)
+		r.Get("/namespace/{namespaceID}/page/{pageID}", h.Read)
+		r.Get("/namespace/{namespaceID}/page/tree", h.Tree)
+		r.Post("/namespace/{namespaceID}/page/{pageID}", h.Update)
+		r.Post("/namespace/{namespaceID}/page/{selfID}/reorder", h.Reorder)
+		r.Delete("/namespace/{namespaceID}/page/{pageID}", h.Delete)
+		r.Post("/namespace/{namespaceID}/page/{pageID}/attachment", h.Upload)
+		r.Post("/namespace/{namespaceID}/page/{pageID}/trigger", h.TriggerScript)
+		r.Get("/namespace/{namespaceID}/page/{pageID}/translation", h.ListTranslations)
+		r.Patch("/namespace/{namespaceID}/page/{pageID}/translation", h.UpdateTranslations)
+		r.Patch("/namespace/{namespaceID}/page/{pageID}/icon", h.UpdateIcon)
+	})
+}

server/compose/rest/handlers/pageLayout.go

@@ -0,0 +1,228 @@
+package handlers
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"context"
+	"github.com/cortezaproject/corteza/server/compose/rest/request"
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	PageLayoutAPI interface {
+		ListNamespace(context.Context, *request.PageLayoutListNamespace) (interface{}, error)
+		List(context.Context, *request.PageLayoutList) (interface{}, error)
+		Create(context.Context, *request.PageLayoutCreate) (interface{}, error)
+		Read(context.Context, *request.PageLayoutRead) (interface{}, error)
+		Update(context.Context, *request.PageLayoutUpdate) (interface{}, error)
+		Reorder(context.Context, *request.PageLayoutReorder) (interface{}, error)
+		Delete(context.Context, *request.PageLayoutDelete) (interface{}, error)
+		Undelete(context.Context, *request.PageLayoutUndelete) (interface{}, error)
+		ListTranslations(context.Context, *request.PageLayoutListTranslations) (interface{}, error)
+		UpdateTranslations(context.Context, *request.PageLayoutUpdateTranslations) (interface{}, error)
+	}
+
+	// HTTP API interface
+	PageLayout struct {
+		ListNamespace      func(http.ResponseWriter, *http.Request)
+		List               func(http.ResponseWriter, *http.Request)
+		Create             func(http.ResponseWriter, *http.Request)
+		Read               func(http.ResponseWriter, *http.Request)
+		Update             func(http.ResponseWriter, *http.Request)
+		Reorder            func(http.ResponseWriter, *http.Request)
+		Delete             func(http.ResponseWriter, *http.Request)
+		Undelete           func(http.ResponseWriter, *http.Request)
+		ListTranslations   func(http.ResponseWriter, *http.Request)
+		UpdateTranslations func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewPageLayout(h PageLayoutAPI) *PageLayout {
+	return &PageLayout{
+		ListNamespace: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewPageLayoutListNamespace()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.ListNamespace(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		List: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewPageLayoutList()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.List(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Create: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewPageLayoutCreate()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Create(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Read: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewPageLayoutRead()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Read(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Update: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewPageLayoutUpdate()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Update(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Reorder: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewPageLayoutReorder()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Reorder(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Delete: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewPageLayoutDelete()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Delete(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Undelete: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewPageLayoutUndelete()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Undelete(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		ListTranslations: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewPageLayoutListTranslations()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.ListTranslations(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		UpdateTranslations: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewPageLayoutUpdateTranslations()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.UpdateTranslations(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+	}
+}
+
+func (h PageLayout) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Get("/namespace/{namespaceID}/page-layout", h.ListNamespace)
+		r.Get("/namespace/{namespaceID}/page/{pageID}/layout/", h.List)
+		r.Post("/namespace/{namespaceID}/page/{pageID}/layout/", h.Create)
+		r.Get("/namespace/{namespaceID}/page/{pageID}/layout/{pageLayoutID}", h.Read)
+		r.Post("/namespace/{namespaceID}/page/{pageID}/layout/{pageLayoutID}", h.Update)
+		r.Post("/namespace/{namespaceID}/page/{pageID}/layout/reorder", h.Reorder)
+		r.Delete("/namespace/{namespaceID}/page/{pageID}/layout/{pageLayoutID}", h.Delete)
+		r.Post("/namespace/{namespaceID}/page/{pageID}/layout/{pageLayoutID}/undelete", h.Undelete)
+		r.Get("/namespace/{namespaceID}/page/{pageID}/layout/{pageLayoutID}/translation", h.ListTranslations)
+		r.Patch("/namespace/{namespaceID}/page/{pageID}/layout/{pageLayoutID}/translation", h.UpdateTranslations)
+	})
+}

server/compose/rest/handlers/permissions.go

@@ -0,0 +1,152 @@
+package handlers
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"context"
+	"github.com/cortezaproject/corteza/server/compose/rest/request"
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	PermissionsAPI interface {
+		List(context.Context, *request.PermissionsList) (interface{}, error)
+		Effective(context.Context, *request.PermissionsEffective) (interface{}, error)
+		Trace(context.Context, *request.PermissionsTrace) (interface{}, error)
+		Read(context.Context, *request.PermissionsRead) (interface{}, error)
+		Delete(context.Context, *request.PermissionsDelete) (interface{}, error)
+		Update(context.Context, *request.PermissionsUpdate) (interface{}, error)
+	}
+
+	// HTTP API interface
+	Permissions struct {
+		List      func(http.ResponseWriter, *http.Request)
+		Effective func(http.ResponseWriter, *http.Request)
+		Trace     func(http.ResponseWriter, *http.Request)
+		Read      func(http.ResponseWriter, *http.Request)
+		Delete    func(http.ResponseWriter, *http.Request)
+		Update    func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewPermissions(h PermissionsAPI) *Permissions {
+	return &Permissions{
+		List: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewPermissionsList()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.List(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Effective: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewPermissionsEffective()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Effective(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Trace: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewPermissionsTrace()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Trace(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Read: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewPermissionsRead()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Read(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Delete: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewPermissionsDelete()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Delete(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Update: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewPermissionsUpdate()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Update(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+	}
+}
+
+func (h Permissions) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Get("/permissions/", h.List)
+		r.Get("/permissions/effective", h.Effective)
+		r.Get("/permissions/trace", h.Trace)
+		r.Get("/permissions/{roleID}/rules", h.Read)
+		r.Delete("/permissions/{roleID}/rules", h.Delete)
+		r.Patch("/permissions/{roleID}/rules", h.Update)
+	})
+}

server/compose/rest/handlers/record.go

@@ -0,0 +1,437 @@
+package handlers
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"context"
+	"github.com/cortezaproject/corteza/server/compose/rest/request"
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	RecordAPI interface {
+		Report(context.Context, *request.RecordReport) (interface{}, error)
+		List(context.Context, *request.RecordList) (interface{}, error)
+		ImportInit(context.Context, *request.RecordImportInit) (interface{}, error)
+		ImportRun(context.Context, *request.RecordImportRun) (interface{}, error)
+		ImportProgress(context.Context, *request.RecordImportProgress) (interface{}, error)
+		ExportInit(context.Context, *request.RecordExportInit) (interface{}, error)
+		ExportPull(context.Context, *request.RecordExportPull) (interface{}, error)
+		Export(context.Context, *request.RecordExport) (interface{}, error)
+		Exec(context.Context, *request.RecordExec) (interface{}, error)
+		Create(context.Context, *request.RecordCreate) (interface{}, error)
+		Read(context.Context, *request.RecordRead) (interface{}, error)
+		Update(context.Context, *request.RecordUpdate) (interface{}, error)
+		Patch(context.Context, *request.RecordPatch) (interface{}, error)
+		BulkDelete(context.Context, *request.RecordBulkDelete) (interface{}, error)
+		Delete(context.Context, *request.RecordDelete) (interface{}, error)
+		Undelete(context.Context, *request.RecordUndelete) (interface{}, error)
+		BulkUndelete(context.Context, *request.RecordBulkUndelete) (interface{}, error)
+		Upload(context.Context, *request.RecordUpload) (interface{}, error)
+		TriggerScript(context.Context, *request.RecordTriggerScript) (interface{}, error)
+		TriggerScriptOnList(context.Context, *request.RecordTriggerScriptOnList) (interface{}, error)
+		Revisions(context.Context, *request.RecordRevisions) (interface{}, error)
+	}
+
+	// HTTP API interface
+	Record struct {
+		Report              func(http.ResponseWriter, *http.Request)
+		List                func(http.ResponseWriter, *http.Request)
+		ImportInit          func(http.ResponseWriter, *http.Request)
+		ImportRun           func(http.ResponseWriter, *http.Request)
+		ImportProgress      func(http.ResponseWriter, *http.Request)
+		ExportInit          func(http.ResponseWriter, *http.Request)
+		ExportPull          func(http.ResponseWriter, *http.Request)
+		Export              func(http.ResponseWriter, *http.Request)
+		Exec                func(http.ResponseWriter, *http.Request)
+		Create              func(http.ResponseWriter, *http.Request)
+		Read                func(http.ResponseWriter, *http.Request)
+		Update              func(http.ResponseWriter, *http.Request)
+		Patch               func(http.ResponseWriter, *http.Request)
+		BulkDelete          func(http.ResponseWriter, *http.Request)
+		Delete              func(http.ResponseWriter, *http.Request)
+		Undelete            func(http.ResponseWriter, *http.Request)
+		BulkUndelete        func(http.ResponseWriter, *http.Request)
+		Upload              func(http.ResponseWriter, *http.Request)
+		TriggerScript       func(http.ResponseWriter, *http.Request)
+		TriggerScriptOnList func(http.ResponseWriter, *http.Request)
+		Revisions           func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewRecord(h RecordAPI) *Record {
+	return &Record{
+		Report: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewRecordReport()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Report(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		List: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewRecordList()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.List(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		ImportInit: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewRecordImportInit()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.ImportInit(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		ImportRun: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewRecordImportRun()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.ImportRun(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		ImportProgress: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewRecordImportProgress()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.ImportProgress(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		ExportInit: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewRecordExportInit()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.ExportInit(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		ExportPull: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewRecordExportPull()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.ExportPull(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Export: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewRecordExport()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Export(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Exec: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewRecordExec()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Exec(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Create: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewRecordCreate()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Create(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Read: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewRecordRead()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Read(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Update: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewRecordUpdate()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Update(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Patch: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewRecordPatch()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Patch(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		BulkDelete: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewRecordBulkDelete()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.BulkDelete(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Delete: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewRecordDelete()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Delete(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Undelete: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewRecordUndelete()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Undelete(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		BulkUndelete: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewRecordBulkUndelete()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.BulkUndelete(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Upload: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewRecordUpload()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Upload(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		TriggerScript: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewRecordTriggerScript()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.TriggerScript(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		TriggerScriptOnList: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewRecordTriggerScriptOnList()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.TriggerScriptOnList(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Revisions: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewRecordRevisions()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Revisions(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+	}
+}
+
+func (h Record) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Get("/namespace/{namespaceID}/module/{moduleID}/record/report", h.Report)
+		r.Get("/namespace/{namespaceID}/module/{moduleID}/record/", h.List)
+		r.Post("/namespace/{namespaceID}/module/{moduleID}/record/import", h.ImportInit)
+		r.Patch("/namespace/{namespaceID}/module/{moduleID}/record/import/{sessionID}", h.ImportRun)
+		r.Get("/namespace/{namespaceID}/module/{moduleID}/record/import/{sessionID}", h.ImportProgress)
+		r.Post("/namespace/{namespaceID}/module/{moduleID}/record/export", h.ExportInit)
+		r.Get("/namespace/{namespaceID}/module/{moduleID}/record/export/{sessionID}/{filename}.{ext}", h.ExportPull)
+		r.Get("/namespace/{namespaceID}/module/{moduleID}/record/export{filename}.{ext}", h.Export)
+		r.Post("/namespace/{namespaceID}/module/{moduleID}/record/exec/{procedure}", h.Exec)
+		r.Post("/namespace/{namespaceID}/module/{moduleID}/record/", h.Create)
+		r.Get("/namespace/{namespaceID}/module/{moduleID}/record/{recordID}", h.Read)
+		r.Post("/namespace/{namespaceID}/module/{moduleID}/record/{recordID}", h.Update)
+		r.Patch("/namespace/{namespaceID}/module/{moduleID}/record/", h.Patch)
+		r.Delete("/namespace/{namespaceID}/module/{moduleID}/record/", h.BulkDelete)
+		r.Delete("/namespace/{namespaceID}/module/{moduleID}/record/{recordID}", h.Delete)
+		r.Post("/namespace/{namespaceID}/module/{moduleID}/record/{recordID}/undelete", h.Undelete)
+		r.Patch("/namespace/{namespaceID}/module/{moduleID}/record/undelete", h.BulkUndelete)
+		r.Post("/namespace/{namespaceID}/module/{moduleID}/record/attachment", h.Upload)
+		r.Post("/namespace/{namespaceID}/module/{moduleID}/record/{recordID}/trigger", h.TriggerScript)
+		r.Post("/namespace/{namespaceID}/module/{moduleID}/record/trigger", h.TriggerScriptOnList)
+		r.Get("/namespace/{namespaceID}/module/{moduleID}/record/{recordID}/revisions", h.Revisions)
+	})
+}

server/compose/rest/icon.go

@@ -0,0 +1,126 @@
+package rest
+
+import (
+	"context"
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/cortezaproject/corteza/server/pkg/auth"
+	"github.com/cortezaproject/corteza/server/pkg/errors"
+	"mime/multipart"
+
+	"github.com/cortezaproject/corteza/server/compose/rest/request"
+	"github.com/cortezaproject/corteza/server/compose/service"
+	"github.com/cortezaproject/corteza/server/compose/types"
+	"github.com/cortezaproject/corteza/server/pkg/filter"
+)
+
+type (
+	iconPayload struct {
+		*attachmentPayload
+	}
+
+	iconSetPayload struct {
+		Filter types.IconFilter `json:"filter"`
+		Set    []*iconPayload   `json:"set"`
+	}
+
+	Icon struct {
+		locale     service.ResourceTranslationsManagerService
+		attachment service.AttachmentService
+		ac         iconAccessController
+	}
+
+	iconAccessController interface {
+		CanGrant(context.Context) bool
+	}
+)
+
+func (Icon) New() *Icon {
+	return &Icon{
+		locale:     service.DefaultResourceTranslation,
+		attachment: service.DefaultAttachment,
+		ac:         service.DefaultAccessControl,
+	}
+}
+
+func (ctrl *Icon) List(ctx context.Context, r *request.IconList) (interface{}, error) {
+	var (
+		err error
+		f   = types.AttachmentFilter{
+			Kind: types.IconAttachment,
+		}
+		set types.AttachmentSet
+	)
+
+	if f.Paging, err = filter.NewPaging(r.Limit, r.PageCursor); err != nil {
+		return nil, err
+	}
+
+	if f.Sorting, err = filter.NewSorting(r.Sort); err != nil {
+		return nil, err
+	}
+
+	//Get only the undeleted icons
+	f.Deleted = filter.StateExcluded
+
+	set, f, err = ctrl.attachment.Find(ctx, f)
+	return ctrl.makeIconFilterPayload(ctx, set, f, err)
+}
+
+func (ctrl *Icon) Upload(ctx context.Context, r *request.IconUpload) (interface{}, error) {
+	file, err := r.Icon.Open()
+	if err != nil {
+		return nil, err
+	}
+
+	defer func(file multipart.File) {
+		err = file.Close()
+		if err != nil {
+			return
+		}
+	}(file)
+
+	a, err := ctrl.attachment.CreateIconAttachment(
+		ctx,
+		r.Icon.Filename,
+		r.Icon.Size,
+		file,
+	)
+
+	return makeAttachmentPayload(ctx, a, err)
+}
+
+func (ctrl *Icon) makeIconFilterPayload(ctx context.Context, nn types.AttachmentSet, f types.AttachmentFilter, err error) (*iconSetPayload, error) {
+	if err != nil {
+		return nil, err
+	}
+
+	var (
+		a  *attachmentPayload
+		ff types.IconFilter
+	)
+
+	ff.Paging = f.Paging
+	ff.Sorting = f.Sorting
+
+	res := &iconSetPayload{Filter: ff, Set: make([]*iconPayload, len(nn))}
+
+	for i := range nn {
+		a, _ = makeAttachmentPayload(ctx, nn[i], nil)
+		res.Set[i] = &iconPayload{a}
+	}
+
+	return res, nil
+}
+
+func (ctrl *Icon) Delete(ctx context.Context, r *request.IconDelete) (interface{}, error) {
+	if !auth.GetIdentityFromContext(ctx).Valid() {
+		return nil, errors.Unauthorized("cannot delete icon")
+	}
+
+	_, err := ctrl.attachment.FindByID(ctx, 0, r.IconID)
+	if err != nil {
+		return nil, err
+	}
+
+	return api.OK(), ctrl.attachment.DeleteByID(ctx, 0, r.IconID)
+}

server/compose/rest/module.go

@@ -0,0 +1,227 @@
+package rest
+
+import (
+	"context"
+
+	"github.com/cortezaproject/corteza/server/compose/rest/request"
+	"github.com/cortezaproject/corteza/server/compose/service"
+	"github.com/cortezaproject/corteza/server/compose/service/event"
+	"github.com/cortezaproject/corteza/server/compose/types"
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/cortezaproject/corteza/server/pkg/corredor"
+	"github.com/cortezaproject/corteza/server/pkg/filter"
+)
+
+type (
+	moduleSetPayload struct {
+		Filter types.ModuleFilter `json:"filter"`
+		Set    []*modulePayload   `json:"set"`
+	}
+
+	modulePayload struct {
+		*types.Module
+
+		Fields []*moduleFieldPayload `json:"fields"`
+
+		CanGrant             bool `json:"canGrant"`
+		CanUpdateModule      bool `json:"canUpdateModule"`
+		CanDeleteModule      bool `json:"canDeleteModule"`
+		CanCreateRecord      bool `json:"canCreateRecord"`
+		CanCreateOwnedRecord bool `json:"canCreateOwnedRecord"`
+	}
+
+	moduleFieldPayload struct {
+		*types.ModuleField
+
+		CanReadRecordValue   bool `json:"canReadRecordValue"`
+		CanUpdateRecordValue bool `json:"canUpdateRecordValue"`
+	}
+
+	Module struct {
+		module    service.ModuleService
+		locale    service.ResourceTranslationsManagerService
+		namespace service.NamespaceService
+		ac        moduleAccessController
+	}
+
+	moduleAccessController interface {
+		CanGrant(context.Context) bool
+
+		CanUpdateModule(context.Context, *types.Module) bool
+		CanDeleteModule(context.Context, *types.Module) bool
+		CanCreateRecordOnModule(context.Context, *types.Module) bool
+		CanCreateOwnedRecordOnModule(context.Context, *types.Module) bool
+		CanReadRecord(context.Context, *types.Record) bool
+
+		CanReadRecordValueOnModuleField(context.Context, *types.ModuleField) bool
+		CanUpdateRecordValueOnModuleField(context.Context, *types.ModuleField) bool
+	}
+)
+
+func (Module) New() *Module {
+	return &Module{
+		module:    service.DefaultModule,
+		namespace: service.DefaultNamespace,
+		ac:        service.DefaultAccessControl,
+		locale:    service.DefaultResourceTranslation,
+	}
+}
+
+func (ctrl *Module) List(ctx context.Context, r *request.ModuleList) (interface{}, error) {
+	var (
+		err error
+		f   = types.ModuleFilter{
+			NamespaceID: r.NamespaceID,
+			Query:       r.Query,
+			Name:        r.Name,
+			Handle:      r.Handle,
+			Labels:      r.Labels,
+		}
+	)
+
+	if f.Paging, err = filter.NewPaging(r.Limit, r.PageCursor); err != nil {
+		return nil, err
+	}
+
+	f.IncTotal = r.IncTotal
+
+	if f.Sorting, err = filter.NewSorting(r.Sort); err != nil {
+		return nil, err
+	}
+
+	set, filter, err := ctrl.module.Find(ctx, f)
+	return ctrl.makeFilterPayload(ctx, set, filter, err)
+}
+
+func (ctrl *Module) Read(ctx context.Context, r *request.ModuleRead) (interface{}, error) {
+	mod, err := ctrl.module.FindByID(ctx, r.NamespaceID, r.ModuleID)
+	return ctrl.makePayload(ctx, mod, err)
+}
+
+func (ctrl *Module) ListTranslations(ctx context.Context, r *request.ModuleListTranslations) (interface{}, error) {
+	return ctrl.locale.Module(ctx, r.NamespaceID, r.ModuleID)
+}
+
+func (ctrl *Module) UpdateTranslations(ctx context.Context, r *request.ModuleUpdateTranslations) (interface{}, error) {
+	return api.OK(), ctrl.locale.Upsert(ctx, r.Translations)
+}
+
+func (ctrl *Module) Create(ctx context.Context, r *request.ModuleCreate) (interface{}, error) {
+	var (
+		err error
+		mod = &types.Module{
+			NamespaceID: r.NamespaceID,
+			Config:      r.Config,
+			Name:        r.Name,
+			Handle:      r.Handle,
+			Fields:      r.Fields,
+			Meta:        r.Meta,
+			Labels:      r.Labels,
+		}
+	)
+
+	mod, err = ctrl.module.Create(ctx, mod)
+	return ctrl.makePayload(ctx, mod, err)
+}
+
+func (ctrl *Module) Update(ctx context.Context, r *request.ModuleUpdate) (interface{}, error) {
+	var (
+		err error
+		mod = &types.Module{
+			ID:          r.ModuleID,
+			NamespaceID: r.NamespaceID,
+			Config:      r.Config,
+			Name:        r.Name,
+			Handle:      r.Handle,
+			Fields:      r.Fields,
+			Meta:        r.Meta,
+			Labels:      r.Labels,
+			UpdatedAt:   r.UpdatedAt,
+		}
+	)
+
+	mod, err = ctrl.module.Update(ctx, mod)
+	return ctrl.makePayload(ctx, mod, err)
+}
+
+func (ctrl *Module) Delete(ctx context.Context, r *request.ModuleDelete) (interface{}, error) {
+	_, err := ctrl.module.FindByID(ctx, r.NamespaceID, r.ModuleID)
+	if err != nil {
+		return nil, err
+	}
+
+	return api.OK(), ctrl.module.DeleteByID(ctx, r.NamespaceID, r.ModuleID)
+}
+
+func (ctrl *Module) TriggerScript(ctx context.Context, r *request.ModuleTriggerScript) (rsp interface{}, err error) {
+	var (
+		module    *types.Module
+		namespace *types.Namespace
+	)
+
+	if module, err = ctrl.module.FindByID(ctx, r.NamespaceID, r.ModuleID); err != nil {
+		return
+	}
+
+	if namespace, err = ctrl.namespace.FindByID(ctx, r.NamespaceID); err != nil {
+		return
+	}
+
+	// @todo implement same behaviour as we have on record - module+oldModule
+	err = corredor.Service().Exec(ctx, r.Script, corredor.ExtendScriptArgs(event.ModuleOnManual(module, module, namespace), r.Args))
+	return ctrl.makePayload(ctx, module, err)
+}
+
+func (ctrl Module) makePayload(ctx context.Context, m *types.Module, err error) (*modulePayload, error) {
+	if err != nil || m == nil {
+		return nil, err
+	}
+
+	mfp, err := ctrl.makeFieldsPayload(ctx, m)
+	if err != nil {
+		return nil, err
+	}
+
+	return &modulePayload{
+		Module: m,
+
+		Fields: mfp,
+
+		CanGrant: ctrl.ac.CanGrant(ctx),
+
+		CanUpdateModule: ctrl.ac.CanUpdateModule(ctx, m),
+		CanDeleteModule: ctrl.ac.CanDeleteModule(ctx, m),
+
+		CanCreateRecord:      ctrl.ac.CanCreateRecordOnModule(ctx, m),
+		CanCreateOwnedRecord: ctrl.ac.CanCreateOwnedRecordOnModule(ctx, m),
+	}, nil
+}
+
+func (ctrl Module) makeFieldsPayload(ctx context.Context, m *types.Module) (out []*moduleFieldPayload, err error) {
+	out = make([]*moduleFieldPayload, len(m.Fields))
+
+	for i, f := range m.Fields {
+		out[i] = &moduleFieldPayload{
+			ModuleField: f,
+
+			CanReadRecordValue:   ctrl.ac.CanReadRecordValueOnModuleField(ctx, f),
+			CanUpdateRecordValue: ctrl.ac.CanUpdateRecordValueOnModuleField(ctx, f),
+		}
+	}
+
+	return
+}
+
+func (ctrl Module) makeFilterPayload(ctx context.Context, nn types.ModuleSet, f types.ModuleFilter, err error) (*moduleSetPayload, error) {
+	if err != nil {
+		return nil, err
+	}
+
+	msp := &moduleSetPayload{Filter: f, Set: make([]*modulePayload, len(nn))}
+
+	for i := range nn {
+		msp.Set[i], _ = ctrl.makePayload(ctx, nn[i], nil)
+	}
+
+	return msp, nil
+}

server/compose/rest/namespace.go

@@ -0,0 +1,600 @@
+package rest
+
+import (
+	"archive/zip"
+	"bytes"
+	"context"
+	"fmt"
+	"io"
+	"net/http"
+	"time"
+
+	automationTypes "github.com/cortezaproject/corteza/server/automation/types"
+	composeEnvoy "github.com/cortezaproject/corteza/server/compose/envoy"
+	"github.com/cortezaproject/corteza/server/compose/rest/request"
+	"github.com/cortezaproject/corteza/server/compose/service"
+	"github.com/cortezaproject/corteza/server/compose/service/event"
+	"github.com/cortezaproject/corteza/server/compose/types"
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/cortezaproject/corteza/server/pkg/corredor"
+	"github.com/cortezaproject/corteza/server/pkg/envoyx"
+	"github.com/cortezaproject/corteza/server/pkg/filter"
+	"github.com/cortezaproject/corteza/server/pkg/locale"
+	"github.com/cortezaproject/corteza/server/pkg/rbac"
+	systemEnvoy "github.com/cortezaproject/corteza/server/system/envoy"
+	systemService "github.com/cortezaproject/corteza/server/system/service"
+	systemTypes "github.com/cortezaproject/corteza/server/system/types"
+)
+
+type (
+	namespacePayload struct {
+		*types.Namespace
+
+		CanGrant           bool `json:"canGrant"`
+		CanExportNamespace bool `json:"canExportNamespace"`
+		CanUpdateNamespace bool `json:"canUpdateNamespace"`
+		CanDeleteNamespace bool `json:"canDeleteNamespace"`
+		CanManageNamespace bool `json:"canManageNamespace"`
+		CanCreateModule    bool `json:"canCreateModule"`
+		CanExportModules   bool `json:"canExportModules"`
+		CanCreateChart     bool `json:"canCreateChart"`
+		CanExportCharts    bool `json:"canExportCharts"`
+		CanCreatePage      bool `json:"canCreatePage"`
+	}
+
+	namespaceSetPayload struct {
+		Filter types.NamespaceFilter `json:"filter"`
+		Set    []*namespacePayload   `json:"set"`
+	}
+
+	pageFinder interface {
+		Find(ctx context.Context, filter types.PageFilter) (set types.PageSet, f types.PageFilter, err error)
+	}
+
+	pageLayoutFinder interface {
+		Find(ctx context.Context, filter types.PageLayoutFilter) (set types.PageLayoutSet, f types.PageLayoutFilter, err error)
+	}
+
+	chartFinder interface {
+		Find(ctx context.Context, filter types.ChartFilter) (set types.ChartSet, f types.ChartFilter, err error)
+	}
+
+	Namespace struct {
+		namespace  service.NamespaceService
+		module     service.ModuleService
+		page       pageFinder
+		pageLayout pageLayoutFinder
+		chart      chartFinder
+		locale     service.ResourceTranslationsManagerService
+		attachment service.AttachmentService
+		role       systemService.RoleService
+		ac         namespaceAccessController
+	}
+
+	namespaceAccessController interface {
+		CanGrant(context.Context) bool
+
+		CanExportNamespace(context.Context, *types.Namespace) bool
+		CanUpdateNamespace(context.Context, *types.Namespace) bool
+		CanDeleteNamespace(context.Context, *types.Namespace) bool
+		CanManageNamespace(context.Context, *types.Namespace) bool
+
+		CanCreateModuleOnNamespace(context.Context, *types.Namespace) bool
+		CanExportModulesOnNamespace(context.Context, *types.Namespace) bool
+		CanCreateChartOnNamespace(context.Context, *types.Namespace) bool
+		CanExportChartsOnNamespace(context.Context, *types.Namespace) bool
+		CanCreatePageOnNamespace(context.Context, *types.Namespace) bool
+	}
+)
+
+func (Namespace) New() *Namespace {
+	return &Namespace{
+		namespace:  service.DefaultNamespace,
+		module:     service.DefaultModule,
+		page:       service.DefaultPage,
+		pageLayout: service.DefaultPageLayout,
+		chart:      service.DefaultChart,
+		locale:     service.DefaultResourceTranslation,
+		role:       systemService.DefaultRole,
+		attachment: service.DefaultAttachment,
+		ac:         service.DefaultAccessControl,
+	}
+}
+
+func (ctrl Namespace) List(ctx context.Context, r *request.NamespaceList) (interface{}, error) {
+	var (
+		err error
+		f   = types.NamespaceFilter{
+			Query:  r.Query,
+			Slug:   r.Slug,
+			Labels: r.Labels,
+		}
+	)
+
+	if f.Paging, err = filter.NewPaging(r.Limit, r.PageCursor); err != nil {
+		return nil, err
+	}
+
+	f.IncTotal = r.IncTotal
+
+	if f.Sorting, err = filter.NewSorting(r.Sort); err != nil {
+		return nil, err
+	}
+
+	set, filter, err := ctrl.namespace.Find(ctx, f)
+	return ctrl.makeFilterPayload(ctx, set, filter, err)
+}
+
+func (ctrl Namespace) Create(ctx context.Context, r *request.NamespaceCreate) (interface{}, error) {
+	var (
+		err error
+		ns  = &types.Namespace{
+			Name:    r.Name,
+			Slug:    r.Slug,
+			Enabled: r.Enabled,
+			Labels:  r.Labels,
+		}
+	)
+
+	if err = r.Meta.Unmarshal(&ns.Meta); err != nil {
+		return nil, err
+	}
+
+	ns, err = ctrl.namespace.Create(ctx, ns)
+	return ctrl.makePayload(ctx, ns, err)
+}
+
+func (ctrl Namespace) Read(ctx context.Context, r *request.NamespaceRead) (interface{}, error) {
+	ns, err := ctrl.namespace.FindByID(ctx, r.NamespaceID)
+	return ctrl.makePayload(ctx, ns, err)
+}
+
+func (ctrl Namespace) ListTranslations(ctx context.Context, r *request.NamespaceListTranslations) (interface{}, error) {
+	return ctrl.locale.Namespace(ctx, r.NamespaceID)
+}
+
+func (ctrl Namespace) UpdateTranslations(ctx context.Context, r *request.NamespaceUpdateTranslations) (interface{}, error) {
+	return api.OK(), ctrl.locale.Upsert(ctx, r.Translations)
+}
+
+func (ctrl Namespace) Update(ctx context.Context, r *request.NamespaceUpdate) (interface{}, error) {
+	var (
+		err error
+		ns  = &types.Namespace{
+			ID:        r.NamespaceID,
+			Name:      r.Name,
+			Slug:      r.Slug,
+			Enabled:   r.Enabled,
+			Labels:    r.Labels,
+			UpdatedAt: r.UpdatedAt,
+		}
+	)
+
+	if err = r.Meta.Unmarshal(&ns.Meta); err != nil {
+		return nil, err
+	}
+
+	ns, err = ctrl.namespace.Update(ctx, ns)
+	return ctrl.makePayload(ctx, ns, err)
+}
+
+func (ctrl Namespace) Delete(ctx context.Context, r *request.NamespaceDelete) (interface{}, error) {
+	_, err := ctrl.namespace.FindByID(ctx, r.NamespaceID)
+	if err != nil {
+		return nil, err
+	}
+
+	return api.OK(), ctrl.namespace.DeleteByID(ctx, r.NamespaceID)
+}
+
+func (ctrl Namespace) Upload(ctx context.Context, r *request.NamespaceUpload) (interface{}, error) {
+	file, err := r.Upload.Open()
+	if err != nil {
+		return nil, err
+	}
+	defer file.Close()
+
+	a, err := ctrl.attachment.CreateNamespaceAttachment(
+		ctx,
+		r.Upload.Filename,
+		r.Upload.Size,
+		file,
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	return makeAttachmentPayload(ctx, a, err)
+}
+
+func (ctrl Namespace) Clone(ctx context.Context, r *request.NamespaceClone) (interface{}, error) {
+	dup := &types.Namespace{
+		Name: r.Name,
+		Slug: r.Slug,
+	}
+
+	// @todo temporary workaround cause Envoy requires some identifiable thing
+	if dup.Slug == "" {
+		dup.Slug = fmt.Sprintf("cl_%d", r.NamespaceID)
+	}
+
+	nodes, err := ctrl.gatherNodes(ctx, r.NamespaceID)
+	if err != nil {
+		return nil, err
+	}
+
+	decoder := func() (envoyx.NodeSet, error) {
+		return nodes, nil
+	}
+
+	ns, err := ctrl.namespace.Clone(ctx, r.NamespaceID, dup, decoder)
+	if err != nil {
+		return nil, err
+	}
+
+	// @todo temporary workaround cause Envoy requires some identifiable thing
+	if r.Slug == "" {
+		ns.Slug = ""
+		ns, err = ctrl.namespace.Update(ctx, ns)
+		if err != nil {
+			return nil, err
+		}
+	}
+	return ctrl.makePayload(ctx, ns, err)
+}
+
+func (ctrl Namespace) Export(ctx context.Context, r *request.NamespaceExport) (out interface{}, err error) {
+	nodes, err := ctrl.gatherNodes(ctx, r.NamespaceID)
+	if err != nil {
+		return
+	}
+
+	p := envoyx.EncodeParams{
+		Type:   envoyx.EncodeTypeIo,
+		Params: map[string]any{},
+	}
+
+	evsvc := envoyx.Global()
+	gg, err := evsvc.Bake(ctx, p, nil, nodes...)
+	if err != nil {
+		return
+	}
+
+	// Archive encoded resources
+	buf := bytes.NewBuffer(nil)
+	zw := zip.NewWriter(buf)
+
+	f, err := zw.Create(fmt.Sprintf("%s.yaml", r.Filename))
+	if err != nil {
+		return
+	}
+
+	p.Params["writer"] = f
+	err = evsvc.Encode(ctx, p, gg)
+	if err != nil {
+		return
+	}
+
+	err = zw.Close()
+	if err != nil {
+		return
+	}
+
+	return ctrl.serveExport(ctx, fmt.Sprintf("%s.zip", r.Filename), bytes.NewReader(buf.Bytes()), nil)
+}
+
+func (ctrl Namespace) ImportInit(ctx context.Context, r *request.NamespaceImportInit) (interface{}, error) {
+	f, err := r.Upload.Open()
+	if err != nil {
+		return nil, err
+	}
+	defer f.Close()
+
+	return ctrl.namespace.ImportInit(ctx, f, r.Upload.Size)
+	// return ctrl.namespace.ImportInit(ctx, f, r.Upload.Header.Get("content-type"), r.Upload.Size)
+}
+
+func (ctrl Namespace) ImportRun(ctx context.Context, r *request.NamespaceImportRun) (interface{}, error) {
+	var (
+		dup = &types.Namespace{
+			Name: r.Name,
+			Slug: r.Slug,
+		}
+	)
+
+	// @todo temporary workaround cause Envoy requires some identifiable thing
+	if dup.Slug == "" {
+		dup.Slug = fmt.Sprintf("cl_%d", r.SessionID)
+	}
+
+	ns, err := ctrl.namespace.ImportRun(ctx, r.SessionID, dup)
+	if err != nil {
+		return nil, err
+	}
+
+	// @todo temporary workaround cause Envoy requires some identifiable thing
+	if r.Slug == "" {
+		ns.Slug = ""
+		ns, err = ctrl.namespace.Update(ctx, ns)
+		if err != nil {
+			return nil, err
+		}
+	}
+	return ctrl.makePayload(ctx, ns, err)
+}
+
+func (ctrl Namespace) serveExport(ctx context.Context, fn string, archive io.ReadSeeker, err error) (interface{}, error) {
+	if err != nil {
+		return nil, err
+	}
+
+	return func(w http.ResponseWriter, req *http.Request) {
+		w.Header().Add("Content-Disposition", "attachment; filename="+fn)
+
+		http.ServeContent(w, req, fn, time.Now(), archive)
+	}, nil
+}
+
+func (ctrl *Namespace) TriggerScript(ctx context.Context, r *request.NamespaceTriggerScript) (rsp interface{}, err error) {
+	var (
+		namespace *types.Namespace
+	)
+
+	if namespace, err = ctrl.namespace.FindByID(ctx, r.NamespaceID); err != nil {
+		return
+	}
+
+	err = corredor.Service().Exec(ctx, r.Script, corredor.ExtendScriptArgs(event.NamespaceOnManual(namespace, nil), r.Args))
+	return ctrl.makePayload(ctx, namespace, err)
+}
+
+func (ctrl Namespace) makePayload(ctx context.Context, ns *types.Namespace, err error) (*namespacePayload, error) {
+	if err != nil || ns == nil {
+		return nil, err
+	}
+
+	return &namespacePayload{
+		Namespace: ns,
+
+		CanGrant:           ctrl.ac.CanGrant(ctx),
+		CanExportNamespace: ctrl.ac.CanExportNamespace(ctx, ns),
+		CanUpdateNamespace: ctrl.ac.CanUpdateNamespace(ctx, ns),
+		CanDeleteNamespace: ctrl.ac.CanDeleteNamespace(ctx, ns),
+		CanManageNamespace: ctrl.ac.CanManageNamespace(ctx, ns),
+
+		CanCreateModule:  ctrl.ac.CanCreateModuleOnNamespace(ctx, ns),
+		CanExportModules: ctrl.ac.CanExportModulesOnNamespace(ctx, ns),
+		CanCreateChart:   ctrl.ac.CanCreateChartOnNamespace(ctx, ns),
+		CanExportCharts:  ctrl.ac.CanExportChartsOnNamespace(ctx, ns),
+		CanCreatePage:    ctrl.ac.CanCreatePageOnNamespace(ctx, ns),
+	}, nil
+}
+
+func (ctrl Namespace) makeFilterPayload(ctx context.Context, nn types.NamespaceSet, f types.NamespaceFilter, err error) (*namespaceSetPayload, error) {
+	if err != nil {
+		return nil, err
+	}
+
+	nsp := &namespaceSetPayload{Filter: f, Set: make([]*namespacePayload, len(nn))}
+
+	for i := range nn {
+		nsp.Set[i], _ = ctrl.makePayload(ctx, nn[i], nil)
+	}
+
+	return nsp, nil
+}
+
+func (ctrl Namespace) gatherNodes(ctx context.Context, namespaceID uint64) (resources envoyx.NodeSet, err error) {
+	var (
+		nsII envoyx.Identifiers
+		aux  envoyx.NodeSet
+	)
+
+	// Prepare resources
+	aux, nsII, err = ctrl.exportCompose(ctx, namespaceID)
+	if err != nil {
+		return
+	}
+	resources = append(resources, aux...)
+
+	// Tweak exported resources
+	resources = ctrl.tweakExport(ctx, resources, nsII)
+
+	// Role placeholders for RBAC
+	aux, err = ctrl.preparePlaceholders(ctx)
+	if err != nil {
+		return
+	}
+	resources = append(resources, aux...)
+
+	// RBAC
+	aux, err = ctrl.exportRBAC(ctx, resources)
+	if err != nil {
+		return
+	}
+	resources = append(resources, aux...)
+
+	// Translations
+	aux, err = ctrl.exportResourceTranslations(ctx, resources)
+	if err != nil {
+		return
+	}
+	resources = append(resources, aux...)
+
+	return
+}
+
+func (ctrl Namespace) exportCompose(ctx context.Context, namespaceID uint64) (resources envoyx.NodeSet, nsII envoyx.Identifiers, err error) {
+	// - namespace
+	n, err := ctrl.namespace.FindByID(ctx, namespaceID)
+	if err != nil {
+		return
+	}
+
+	// @todo this isn't ok, will do for now
+	if !ctrl.ac.CanExportNamespace(ctx, n) {
+		err = fmt.Errorf("not allowed to export namespace %s", n.Name)
+		return
+	}
+
+	nsNode, err := composeEnvoy.NamespaceToEnvoyNode(n)
+	if err != nil {
+		return
+	}
+	nsII = nsNode.Identifiers
+	resources = append(resources, nsNode)
+
+	// - modules
+	mm, _, err := ctrl.module.Find(ctx, types.ModuleFilter{NamespaceID: n.ID})
+	if err != nil {
+		return
+	}
+	for _, m := range mm {
+		var aux *envoyx.Node
+		aux, err = composeEnvoy.ModuleToEnvoyNode(m)
+		if err != nil {
+			return
+		}
+		resources = append(resources, aux)
+
+		for _, f := range m.Fields {
+			aux, err = composeEnvoy.ModuleFieldToEnvoyNode(f)
+			if err != nil {
+				return
+			}
+			resources = append(resources, aux)
+		}
+	}
+
+	// - pages
+	pp, _, err := ctrl.page.Find(ctx, types.PageFilter{NamespaceID: n.ID})
+	if err != nil {
+		return
+	}
+	for _, p := range pp {
+		var aux *envoyx.Node
+		aux, err = composeEnvoy.PageToEnvoyNode(p)
+		if err != nil {
+			return
+		}
+		resources = append(resources, aux)
+	}
+
+	// - page layouts
+	ll, _, err := ctrl.pageLayout.Find(ctx, types.PageLayoutFilter{NamespaceID: n.ID})
+	if err != nil {
+		return
+	}
+	for _, l := range ll {
+		var aux *envoyx.Node
+		aux, err = composeEnvoy.PageLayoutToEnvoyNode(l)
+		if err != nil {
+			return
+		}
+		resources = append(resources, aux)
+	}
+
+	// - charts
+	cc, _, err := ctrl.chart.Find(ctx, types.ChartFilter{NamespaceID: n.ID})
+	if err != nil {
+		return
+	}
+	for _, c := range cc {
+		var aux *envoyx.Node
+		aux, err = composeEnvoy.ChartToEnvoyNode(c)
+		if err != nil {
+			return
+		}
+		resources = append(resources, aux)
+	}
+
+	return
+}
+
+func (ctrl Namespace) exportRBAC(ctx context.Context, base envoyx.NodeSet) (resources envoyx.NodeSet, err error) {
+	// Prepare RBAC Rules
+	rawRules := rbac.Global().Rules()
+
+	resources, err = envoyx.RBACRulesForNodes(rawRules, base...)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+func (ctrl Namespace) exportResourceTranslations(ctx context.Context, base envoyx.NodeSet) (resources envoyx.NodeSet, err error) {
+	var (
+		lsvc         = locale.Global()
+		tags         = lsvc.Tags()
+		translations = make([]*locale.ResourceTranslation, 0, 128)
+
+		resKeyTrans map[string]map[string]*locale.ResourceTranslation
+	)
+
+	for _, t := range tags {
+		resKeyTrans, err = lsvc.LoadResourceTranslations(ctx, t)
+		if err != nil {
+			return
+		}
+
+		for _, keyTrans := range resKeyTrans {
+			for _, trans := range keyTrans {
+				translations = append(translations, trans)
+			}
+		}
+	}
+
+	resources, err = envoyx.ResourceTranslationsForNodes(systemTypes.FromLocale(translations), base...)
+	return
+}
+
+func (ctrl Namespace) tweakExport(ctx context.Context, nodes envoyx.NodeSet, nsII envoyx.Identifiers) envoyx.NodeSet {
+	nsRef := envoyx.Ref{
+		ResourceType: types.NamespaceResourceType,
+		Identifiers:  nsII,
+		Scope: envoyx.Scope{
+			ResourceType: types.NamespaceResourceType,
+			Identifiers:  nsII,
+		},
+	}
+	nsNode := envoyx.NodeForRef(nsRef, nodes...)
+
+	// - remove logo and icon references as attachments are not exported by default
+	// @todo code in attachment exporting, most likely when we do attachment handling rework
+	ns := nsNode.Resource.(*types.Namespace)
+	ns.Meta.Icon = ""
+	ns.Meta.IconID = 0
+	ns.Meta.Logo = ""
+	ns.Meta.LogoID = 0
+	ns.Meta.LogoEnabled = false
+
+	// - prune resources we won't preserve
+	pref := envoyx.Ref{
+		ResourceType: automationTypes.WorkflowResourceType,
+	}
+	for _, n := range nodes {
+		n.Prune(pref)
+	}
+
+	return nodes
+}
+
+func (ctrl Namespace) preparePlaceholders(ctx context.Context) (resources envoyx.NodeSet, err error) {
+	rr, _, err := ctrl.role.Find(ctx, systemTypes.RoleFilter{})
+	if err != nil {
+		return
+	}
+	var aux *envoyx.Node
+	for _, role := range rr {
+		aux, err = systemEnvoy.RoleToEnvoyNode(role)
+		if err != nil {
+			return
+		}
+
+		aux.Placeholder = true
+		resources = append(resources, aux)
+	}
+
+	return
+}

server/compose/rest/notification.go

@@ -0,0 +1,62 @@
+package rest
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/cortezaproject/corteza/server/compose/rest/request"
+	"github.com/cortezaproject/corteza/server/compose/service"
+	"github.com/cortezaproject/corteza/server/compose/types"
+)
+
+type (
+	Notification struct {
+		svc notificationService
+	}
+
+	contentPayload struct {
+		Plain string `json:"plain"`
+		HTML  string `json:"html"`
+	}
+
+	notificationService interface {
+		SendEmail(context.Context, *types.EmailNotification) error
+	}
+)
+
+func (Notification) New() *Notification {
+	return &Notification{
+		svc: service.DefaultNotification,
+	}
+}
+
+// EmailSend assembles Email Message and pushes message to notification service
+func (ctrl *Notification) EmailSend(ctx context.Context, r *request.NotificationEmailSend) (interface{}, error) {
+	ntf := &types.EmailNotification{
+		To:                r.To,
+		Cc:                r.Cc,
+		ReplyTo:           r.ReplyTo,
+		Subject:           r.Subject,
+		RemoteAttachments: r.RemoteAttachments,
+	}
+
+	var cp = contentPayload{}
+	if err := r.Content.Unmarshal(&cp); err != nil {
+		return false, fmt.Errorf("could not unmarshal content: %w", err)
+	} else {
+		if len(cp.HTML) > 0 {
+			ntf.ContentHTML = cp.HTML
+
+		}
+
+		if len(cp.Plain) > 0 {
+			ntf.ContentPlain = cp.Plain
+		}
+	}
+
+	if err := ctrl.svc.SendEmail(ctx, ntf); err != nil {
+		return false, err
+	} else {
+		return true, nil
+	}
+}

server/compose/rest/page.go

@@ -0,0 +1,338 @@
+package rest
+
+import (
+	"context"
+	"strings"
+
+	"github.com/cortezaproject/corteza/server/compose/rest/request"
+	"github.com/cortezaproject/corteza/server/compose/service"
+	"github.com/cortezaproject/corteza/server/compose/service/event"
+	"github.com/cortezaproject/corteza/server/compose/types"
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/cortezaproject/corteza/server/pkg/corredor"
+	"github.com/cortezaproject/corteza/server/pkg/filter"
+	"github.com/cortezaproject/corteza/server/pkg/payload"
+)
+
+type (
+	pagePayload struct {
+		*types.Page
+
+		Children []*pagePayload `json:"children,omitempty"`
+
+		CanGrant      bool `json:"canGrant"`
+		CanUpdatePage bool `json:"canUpdatePage"`
+		CanDeletePage bool `json:"canDeletePage"`
+	}
+
+	pageSetPayload struct {
+		Filter types.PageFilter `json:"filter"`
+		Set    []*pagePayload   `json:"set"`
+	}
+
+	pageIconPayload struct {
+		*types.PageConfigIcon
+	}
+
+	Page struct {
+		page interface {
+			FindByID(ctx context.Context, namespaceID, pageID uint64) (*types.Page, error)
+			FindByHandle(ctx context.Context, namespaceID uint64, handle string) (*types.Page, error)
+			FindByPageID(ctx context.Context, namespaceID, pageID uint64) (*types.Page, error)
+			FindBySelfID(ctx context.Context, namespaceID, selfID uint64) (pages types.PageSet, f types.PageFilter, err error)
+			Find(ctx context.Context, filter types.PageFilter) (set types.PageSet, f types.PageFilter, err error)
+			Tree(ctx context.Context, namespaceID uint64) (pages types.PageSet, err error)
+
+			Create(ctx context.Context, page *types.Page) (*types.Page, error)
+			Update(ctx context.Context, page *types.Page) (*types.Page, error)
+			DeleteByID(ctx context.Context, namespaceID, pageID uint64, pds types.PageChildrenDeleteStrategy) error
+
+			UpdateIcon(ctx context.Context, namespaceID, pageID uint64, icon *types.PageConfigIcon) (out *types.PageConfigIcon, err error)
+
+			Reorder(ctx context.Context, namespaceID, selfID uint64, pageIDs []uint64) error
+		}
+		locale     service.ResourceTranslationsManagerService
+		namespace  service.NamespaceService
+		attachment service.AttachmentService
+		ac         pageAccessController
+	}
+
+	pageAccessController interface {
+		CanGrant(context.Context) bool
+
+		CanUpdatePage(context.Context, *types.Page) bool
+		CanDeletePage(context.Context, *types.Page) bool
+	}
+)
+
+func (Page) New() *Page {
+	return &Page{
+		page:       service.DefaultPage,
+		locale:     service.DefaultResourceTranslation,
+		namespace:  service.DefaultNamespace,
+		attachment: service.DefaultAttachment,
+		ac:         service.DefaultAccessControl,
+	}
+}
+
+func (ctrl *Page) List(ctx context.Context, r *request.PageList) (interface{}, error) {
+	var (
+		err error
+		f   = types.PageFilter{
+			NamespaceID: r.NamespaceID,
+			ModuleID:    r.ModuleID,
+			ParentID:    r.SelfID,
+			Labels:      r.Labels,
+
+			Handle: r.Handle,
+			Query:  r.Query,
+		}
+	)
+
+	if f.Paging, err = filter.NewPaging(r.Limit, r.PageCursor); err != nil {
+		return nil, err
+	}
+
+	if f.Sorting, err = filter.NewSorting(r.Sort); err != nil {
+		return nil, err
+	}
+
+	set, filter, err := ctrl.page.Find(ctx, f)
+
+	return ctrl.makeFilterPayload(ctx, set, filter, err)
+}
+
+func (ctrl *Page) Tree(ctx context.Context, r *request.PageTree) (interface{}, error) {
+	tree, err := ctrl.page.Tree(ctx, r.NamespaceID)
+	return ctrl.makeTreePayload(ctx, tree, err)
+}
+
+func (ctrl *Page) Create(ctx context.Context, r *request.PageCreate) (interface{}, error) {
+	var (
+		err error
+		mod = &types.Page{
+			NamespaceID: r.NamespaceID,
+			SelfID:      r.SelfID,
+			ModuleID:    r.ModuleID,
+			Title:       r.Title,
+			Handle:      r.Handle,
+			Description: r.Description,
+			Visible:     r.Visible,
+			Weight:      r.Weight,
+			Labels:      r.Labels,
+			Meta:        r.Meta,
+		}
+	)
+
+	if len(r.Config) > 2 {
+		if err = r.Config.Unmarshal(&mod.Config); err != nil {
+			return nil, err
+		}
+	}
+
+	if len(r.Blocks) > 2 {
+		if err = r.Blocks.Unmarshal(&mod.Blocks); err != nil {
+			return nil, err
+		}
+	}
+
+	mod, err = ctrl.page.Create(ctx, mod)
+	return ctrl.makePayload(ctx, mod, err)
+}
+
+func (ctrl *Page) Read(ctx context.Context, r *request.PageRead) (interface{}, error) {
+	mod, err := ctrl.page.FindByID(ctx, r.NamespaceID, r.PageID)
+	return ctrl.makePayload(ctx, mod, err)
+}
+
+func (ctrl *Page) ListTranslations(ctx context.Context, r *request.PageListTranslations) (interface{}, error) {
+	return ctrl.locale.Page(ctx, r.NamespaceID, r.PageID)
+}
+
+func (ctrl *Page) UpdateTranslations(ctx context.Context, r *request.PageUpdateTranslations) (interface{}, error) {
+	return api.OK(), ctrl.locale.Upsert(ctx, r.Translations)
+}
+
+func (ctrl *Page) Reorder(ctx context.Context, r *request.PageReorder) (interface{}, error) {
+	return api.OK(), ctrl.page.Reorder(ctx, r.NamespaceID, r.SelfID, payload.ParseUint64s(r.PageIDs))
+}
+
+func (ctrl *Page) Update(ctx context.Context, r *request.PageUpdate) (interface{}, error) {
+	var (
+		err error
+		mod = &types.Page{
+			NamespaceID: r.NamespaceID,
+			ID:          r.PageID,
+			SelfID:      r.SelfID,
+			ModuleID:    r.ModuleID,
+			Title:       r.Title,
+			Handle:      r.Handle,
+			Description: r.Description,
+			Visible:     r.Visible,
+			Weight:      r.Weight,
+			Labels:      r.Labels,
+			Meta:        r.Meta,
+			UpdatedAt:   r.UpdatedAt,
+		}
+	)
+
+	if len(r.Config) > 2 {
+		// Process config if it was included in the request
+		// if not, do not assume that config has been removed!
+		if err = r.Config.Unmarshal(&mod.Config); err != nil {
+			return nil, err
+		}
+	}
+
+	if len(r.Blocks) > 2 {
+		// Process blocks if they were included in the request
+		// if not, do not assume that blocks were removed!
+		if err = r.Blocks.Unmarshal(&mod.Blocks); err != nil {
+			return nil, err
+		}
+	}
+
+	mod, err = ctrl.page.Update(ctx, mod)
+	return ctrl.makePayload(ctx, mod, err)
+}
+
+func (ctrl *Page) Delete(ctx context.Context, r *request.PageDelete) (interface{}, error) {
+	var strategy types.PageChildrenDeleteStrategy
+
+	switch aux := types.PageChildrenDeleteStrategy(r.Strategy); aux {
+	case types.PageChildrenOnDeleteForce,
+		types.PageChildrenOnDeleteRebase,
+		types.PageChildrenOnDeleteCascade:
+		strategy = aux
+	default:
+		strategy = types.PageChildrenOnDeleteAbort
+	}
+
+	return api.OK(), ctrl.page.DeleteByID(ctx, r.NamespaceID, r.PageID, strategy)
+}
+
+func (ctrl *Page) Upload(ctx context.Context, r *request.PageUpload) (interface{}, error) {
+	file, err := r.Upload.Open()
+	if err != nil {
+		return nil, err
+	}
+
+	defer file.Close()
+
+	a, err := ctrl.attachment.CreatePageAttachment(
+		ctx,
+		r.NamespaceID,
+		r.Upload.Filename,
+		r.Upload.Size,
+		file,
+		r.PageID,
+	)
+
+	return makeAttachmentPayload(ctx, a, err)
+}
+
+func (ctrl *Page) TriggerScript(ctx context.Context, r *request.PageTriggerScript) (rsp interface{}, err error) {
+	var (
+		page      *types.Page
+		namespace *types.Namespace
+	)
+
+	if page, err = ctrl.page.FindByID(ctx, r.NamespaceID, r.PageID); err != nil {
+		return
+	}
+	if namespace, err = ctrl.namespace.FindByID(ctx, r.NamespaceID); err != nil {
+		return
+	}
+
+	// @todo implement same behaviour as we have on record - page+oldPage
+	err = corredor.Service().Exec(ctx, r.Script, corredor.ExtendScriptArgs(event.PageOnManual(page, page, namespace, nil), r.Args))
+	return ctrl.makePayload(ctx, page, err)
+}
+
+func (ctrl *Page) UpdateIcon(ctx context.Context, r *request.PageUpdateIcon) (interface{}, error) {
+	var (
+		err  error
+		icon = &types.PageConfigIcon{
+			Type:  r.Type,
+			Src:   r.Source,
+			Style: func() map[string]string {
+				style := make(map[string]string, len(r.Style))
+				for k, v := range r.Style {
+					if v.Val != "" {
+						style[k] = v.Val
+					} else if len(v.Values) > 0 {
+						style[k] = strings.Join(v.Values, ",")
+					}
+				}
+				return style
+			}(),
+
+		}
+	)
+
+	icon, err = ctrl.page.UpdateIcon(ctx, r.NamespaceID, r.PageID, icon)
+	return ctrl.makeIconPayload(ctx, icon, err)
+}
+
+func (ctrl Page) makePayload(ctx context.Context, c *types.Page, err error) (*pagePayload, error) {
+	if err != nil || c == nil {
+		return nil, err
+	}
+
+	return &pagePayload{
+		Page: c,
+
+		CanGrant: ctrl.ac.CanGrant(ctx),
+
+		CanUpdatePage: ctrl.ac.CanUpdatePage(ctx, c),
+		CanDeletePage: ctrl.ac.CanDeletePage(ctx, c),
+	}, nil
+}
+
+func (ctrl Page) makeIconPayload(_ context.Context, i *types.PageConfigIcon, err error) (*pageIconPayload, error) {
+	if err != nil || i == nil {
+		return nil, err
+	}
+
+	return &pageIconPayload{
+		PageConfigIcon: i,
+	}, nil
+}
+
+func (ctrl Page) makeTreePayload(ctx context.Context, pp types.PageSet, err error) ([]*pagePayload, error) {
+	if err != nil {
+		return nil, err
+	}
+
+	set := make([]*pagePayload, len(pp))
+
+	for i := range pp {
+		set[i], err = ctrl.makePayload(ctx, pp[i], nil)
+		if err != nil {
+			return nil, err
+		}
+
+		if len(pp[i].Children) > 0 {
+			set[i].Children, err = ctrl.makeTreePayload(ctx, pp[i].Children, nil)
+			if err != nil {
+				return nil, err
+			}
+		}
+	}
+
+	return set, nil
+}
+
+func (ctrl Page) makeFilterPayload(ctx context.Context, nn types.PageSet, f types.PageFilter, err error) (*pageSetPayload, error) {
+	if err != nil {
+		return nil, err
+	}
+
+	modp := &pageSetPayload{Filter: f, Set: make([]*pagePayload, len(nn))}
+
+	for i := range nn {
+		modp.Set[i], _ = ctrl.makePayload(ctx, nn[i], nil)
+	}
+
+	return modp, nil
+}

server/compose/rest/page_layout.go

@@ -0,0 +1,224 @@
+package rest
+
+import (
+	"context"
+
+	"github.com/cortezaproject/corteza/server/compose/rest/request"
+	"github.com/cortezaproject/corteza/server/compose/service"
+	"github.com/cortezaproject/corteza/server/compose/types"
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/cortezaproject/corteza/server/pkg/filter"
+	"github.com/cortezaproject/corteza/server/pkg/payload"
+)
+
+type (
+	pageLayoutPayload struct {
+		*types.PageLayout
+
+		// CanGrant      bool `json:"canGrant"`
+		// CanUpdatePageLayout bool `json:"canUpdatePageLayout"`
+		// CanDeletePageLayout bool `json:"canDeletePageLayout"`
+	}
+
+	pageLayoutSetPayload struct {
+		Filter types.PageLayoutFilter `json:"filter"`
+		Set    []*pageLayoutPayload   `json:"set"`
+	}
+
+	PageLayout struct {
+		pageLayout interface {
+			FindByID(ctx context.Context, namespaceID, pageLayoutID uint64) (*types.PageLayout, error)
+			FindByHandle(ctx context.Context, namespaceID uint64, handle string) (*types.PageLayout, error)
+			FindByPageLayoutID(ctx context.Context, namespaceID, pageLayoutID uint64) (*types.PageLayout, error)
+			Find(ctx context.Context, filter types.PageLayoutFilter) (set types.PageLayoutSet, f types.PageLayoutFilter, err error)
+
+			Create(ctx context.Context, pageLayout *types.PageLayout) (*types.PageLayout, error)
+			Reorder(ctx context.Context, namespaceID uint64, pageID uint64, pageLayoutIDs []uint64) error
+			Update(ctx context.Context, pageLayout *types.PageLayout) (*types.PageLayout, error)
+			DeleteByID(ctx context.Context, namespaceID, pageID, pageLayoutID uint64) error
+			UndeleteByID(ctx context.Context, namespaceID, pageID, pageLayoutID uint64) error
+		}
+		locale    service.ResourceTranslationsManagerService
+		namespace service.NamespaceService
+		ac        pageLayoutAccessController
+	}
+
+	pageLayoutAccessController interface {
+		// @todo
+	}
+)
+
+func (PageLayout) New() *PageLayout {
+	return &PageLayout{
+		pageLayout: service.DefaultPageLayout,
+		locale:     service.DefaultResourceTranslation,
+		namespace:  service.DefaultNamespace,
+		ac:         service.DefaultAccessControl,
+	}
+}
+
+func (ctrl *PageLayout) List(ctx context.Context, r *request.PageLayoutList) (interface{}, error) {
+	var (
+		err error
+		f   = types.PageLayoutFilter{
+			NamespaceID: r.NamespaceID,
+			PageID:      r.PageID,
+			Labels:      r.Labels,
+
+			Handle: r.Handle,
+			Query:  r.Query,
+		}
+	)
+
+	if f.Paging, err = filter.NewPaging(r.Limit, r.PageCursor); err != nil {
+		return nil, err
+	}
+
+	if f.Sorting, err = filter.NewSorting(r.Sort); err != nil {
+		return nil, err
+	}
+
+	set, filter, err := ctrl.pageLayout.Find(ctx, f)
+	return ctrl.makeFilterPayload(ctx, set, filter, err)
+}
+
+func (ctrl *PageLayout) ListNamespace(ctx context.Context, r *request.PageLayoutListNamespace) (interface{}, error) {
+	var (
+		err error
+		f   = types.PageLayoutFilter{
+			NamespaceID: r.NamespaceID,
+			Labels:      r.Labels,
+
+			Handle: r.Handle,
+			Query:  r.Query,
+		}
+	)
+
+	if f.Paging, err = filter.NewPaging(r.Limit, r.PageCursor); err != nil {
+		return nil, err
+	}
+
+	if f.Sorting, err = filter.NewSorting(r.Sort); err != nil {
+		return nil, err
+	}
+
+	set, filter, err := ctrl.pageLayout.Find(ctx, f)
+	return ctrl.makeFilterPayload(ctx, set, filter, err)
+}
+
+func (ctrl *PageLayout) Create(ctx context.Context, r *request.PageLayoutCreate) (interface{}, error) {
+	var (
+		err    error
+		layout = &types.PageLayout{
+			PageID:      r.PageID,
+			ParentID:    r.ParentID,
+			Weight:      r.Weight,
+			NamespaceID: r.NamespaceID,
+			Handle:      r.Handle,
+			Meta:        r.Meta,
+			Labels:      r.Labels,
+			OwnedBy:     r.OwnedBy,
+		}
+	)
+
+	if len(r.Config) > 2 {
+		if err = r.Config.Unmarshal(&layout.Config); err != nil {
+			return nil, err
+		}
+	}
+
+	if len(r.Blocks) > 2 {
+		if err = r.Blocks.Unmarshal(&layout.Blocks); err != nil {
+			return nil, err
+		}
+	}
+
+	layout, err = ctrl.pageLayout.Create(ctx, layout)
+	return ctrl.makePayload(ctx, layout, err)
+}
+
+func (ctrl *PageLayout) Read(ctx context.Context, r *request.PageLayoutRead) (interface{}, error) {
+	mod, err := ctrl.pageLayout.FindByID(ctx, r.NamespaceID, r.PageLayoutID)
+	return ctrl.makePayload(ctx, mod, err)
+}
+
+func (ctrl *PageLayout) ListTranslations(ctx context.Context, r *request.PageLayoutListTranslations) (interface{}, error) {
+	return ctrl.locale.PageLayout(ctx, r.NamespaceID, r.PageID, r.PageLayoutID)
+}
+
+func (ctrl *PageLayout) UpdateTranslations(ctx context.Context, r *request.PageLayoutUpdateTranslations) (interface{}, error) {
+	return api.OK(), ctrl.locale.Upsert(ctx, r.Translations)
+}
+
+func (ctrl *PageLayout) Reorder(ctx context.Context, r *request.PageLayoutReorder) (interface{}, error) {
+	return api.OK(), ctrl.pageLayout.Reorder(ctx, r.NamespaceID, r.PageID, payload.ParseUint64s(r.PageIDs))
+}
+
+func (ctrl *PageLayout) Update(ctx context.Context, r *request.PageLayoutUpdate) (interface{}, error) {
+	var (
+		err error
+		mod = &types.PageLayout{
+			ID:          r.PageLayoutID,
+			PageID:      r.PageID,
+			Weight:      r.Weight,
+			ParentID:    r.ParentID,
+			NamespaceID: r.NamespaceID,
+			Handle:      r.Handle,
+			Meta:        r.Meta,
+			Labels:      r.Labels,
+			OwnedBy:     r.OwnedBy,
+			UpdatedAt:   r.UpdatedAt,
+		}
+	)
+
+	if len(r.Config) > 2 {
+		// Process config if it was included in the request
+		// if not, do not assume that config has been removed!
+		if err = r.Config.Unmarshal(&mod.Config); err != nil {
+			return nil, err
+		}
+	}
+
+	if len(r.Blocks) > 2 {
+		// Process blocks if they were included in the request
+		// if not, do not assume that blocks were removed!
+		if err = r.Blocks.Unmarshal(&mod.Blocks); err != nil {
+			return nil, err
+		}
+	}
+
+	mod, err = ctrl.pageLayout.Update(ctx, mod)
+	return ctrl.makePayload(ctx, mod, err)
+}
+
+func (ctrl *PageLayout) Delete(ctx context.Context, r *request.PageLayoutDelete) (interface{}, error) {
+	return api.OK(), ctrl.pageLayout.DeleteByID(ctx, r.NamespaceID, r.PageID, r.PageLayoutID)
+}
+
+func (ctrl *PageLayout) Undelete(ctx context.Context, r *request.PageLayoutUndelete) (interface{}, error) {
+	return api.OK(), ctrl.pageLayout.UndeleteByID(ctx, r.NamespaceID, r.PageID, r.PageLayoutID)
+}
+
+func (ctrl PageLayout) makePayload(ctx context.Context, c *types.PageLayout, err error) (*pageLayoutPayload, error) {
+	if err != nil || c == nil {
+		return nil, err
+	}
+
+	return &pageLayoutPayload{
+		PageLayout: c,
+	}, nil
+}
+
+func (ctrl PageLayout) makeFilterPayload(ctx context.Context, nn types.PageLayoutSet, f types.PageLayoutFilter, err error) (*pageLayoutSetPayload, error) {
+	if err != nil {
+		return nil, err
+	}
+
+	modp := &pageLayoutSetPayload{Filter: f, Set: make([]*pageLayoutPayload, len(nn))}
+
+	for i := range nn {
+		modp.Set[i], _ = ctrl.makePayload(ctx, nn[i], nil)
+	}
+
+	return modp, nil
+}

server/compose/rest/permissions.go

@@ -0,0 +1,69 @@
+package rest
+
+import (
+	"context"
+	"github.com/cortezaproject/corteza/server/compose/rest/request"
+	"github.com/cortezaproject/corteza/server/compose/service"
+	"github.com/cortezaproject/corteza/server/compose/types"
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/cortezaproject/corteza/server/pkg/rbac"
+)
+
+type (
+	Permissions struct {
+		ac permissionsAccessController
+	}
+
+	permissionsAccessController interface {
+		Effective(context.Context, ...rbac.Resource) rbac.EffectiveSet
+		Trace(context.Context, uint64, []uint64, ...string) ([]*rbac.Trace, error)
+		List() []map[string]string
+		FindRulesByRoleID(context.Context, uint64) (rbac.RuleSet, error)
+		FindRules(ctx context.Context, roleID uint64, rr ...string) (rbac.RuleSet, error)
+		Grant(ctx context.Context, rr ...*rbac.Rule) error
+	}
+)
+
+func (Permissions) New() *Permissions {
+	return &Permissions{
+		ac: service.DefaultAccessControl,
+	}
+}
+
+func (ctrl Permissions) Effective(ctx context.Context, r *request.PermissionsEffective) (interface{}, error) {
+	return ctrl.ac.Effective(ctx, types.Component{}), nil
+}
+
+func (ctrl Permissions) Trace(ctx context.Context, r *request.PermissionsTrace) (interface{}, error) {
+	return ctrl.ac.Trace(ctx, r.UserID, r.RoleID, r.Resource...)
+}
+
+func (ctrl Permissions) List(ctx context.Context, r *request.PermissionsList) (interface{}, error) {
+	return ctrl.ac.List(), nil
+}
+
+func (ctrl Permissions) Read(ctx context.Context, r *request.PermissionsRead) (interface{}, error) {
+	return ctrl.ac.FindRules(ctx, r.RoleID, r.Resource...)
+}
+
+func (ctrl Permissions) Delete(ctx context.Context, r *request.PermissionsDelete) (interface{}, error) {
+	rr, err := ctrl.ac.FindRulesByRoleID(ctx, r.RoleID)
+	if err != nil {
+		return nil, err
+	}
+
+	for _, r := range rr {
+		r.Access = rbac.Inherit
+	}
+
+	return api.OK(), ctrl.ac.Grant(ctx, rr...)
+}
+
+func (ctrl Permissions) Update(ctx context.Context, r *request.PermissionsUpdate) (interface{}, error) {
+	for _, rule := range r.Rules {
+		// Make sure everything is properly set
+		rule.RoleID = r.RoleID
+	}
+
+	return api.OK(), ctrl.ac.Grant(ctx, r.Rules...)
+}

server/compose/rest/request/attachment.go

@@ -0,0 +1,751 @@
+package request
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/cortezaproject/corteza/server/pkg/payload"
+	"github.com/go-chi/chi/v5"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"strings"
+)
+
+// dummy vars to prevent
+// unused imports complain
+var (
+	_ = chi.URLParam
+	_ = multipart.ErrMessageTooLarge
+	_ = payload.ParseUint64s
+	_ = strings.ToLower
+	_ = io.EOF
+	_ = fmt.Errorf
+	_ = json.NewEncoder
+)
+
+type (
+	// Internal API interface
+	AttachmentList struct {
+		// Kind PATH parameter
+		//
+		// Attachment kind
+		Kind string
+
+		// NamespaceID PATH parameter
+		//
+		// Namespace ID
+		NamespaceID uint64 `json:",string"`
+
+		// Sign GET parameter
+		//
+		// Signature
+		Sign string
+
+		// UserID GET parameter
+		//
+		// User ID
+		UserID uint64 `json:",string"`
+
+		// PageID GET parameter
+		//
+		// Filter attachments by page ID
+		PageID uint64 `json:",string"`
+
+		// ModuleID GET parameter
+		//
+		// Filter attachments by module ID
+		ModuleID uint64 `json:",string"`
+
+		// RecordID GET parameter
+		//
+		// Filter attachments by record ID
+		RecordID uint64 `json:",string"`
+
+		// FieldName GET parameter
+		//
+		// Filter attachments by field name
+		FieldName string
+
+		// Limit GET parameter
+		//
+		// Limit
+		Limit uint
+
+		// PageCursor GET parameter
+		//
+		// Page cursor
+		PageCursor string
+	}
+
+	AttachmentRead struct {
+		// Kind PATH parameter
+		//
+		// Attachment kind
+		Kind string
+
+		// NamespaceID PATH parameter
+		//
+		// Namespace ID
+		NamespaceID uint64 `json:",string"`
+
+		// AttachmentID PATH parameter
+		//
+		// Attachment ID
+		AttachmentID uint64 `json:",string"`
+
+		// Sign GET parameter
+		//
+		// Signature
+		Sign string
+
+		// UserID GET parameter
+		//
+		// User ID
+		UserID uint64 `json:",string"`
+	}
+
+	AttachmentDelete struct {
+		// Kind PATH parameter
+		//
+		// Attachment kind
+		Kind string
+
+		// NamespaceID PATH parameter
+		//
+		// Namespace ID
+		NamespaceID uint64 `json:",string"`
+
+		// AttachmentID PATH parameter
+		//
+		// Attachment ID
+		AttachmentID uint64 `json:",string"`
+
+		// Sign GET parameter
+		//
+		// Signature
+		Sign string
+
+		// UserID GET parameter
+		//
+		// User ID
+		UserID uint64 `json:",string"`
+	}
+
+	AttachmentOriginal struct {
+		// Kind PATH parameter
+		//
+		// Attachment kind
+		Kind string
+
+		// NamespaceID PATH parameter
+		//
+		// Namespace ID
+		NamespaceID uint64 `json:",string"`
+
+		// AttachmentID PATH parameter
+		//
+		// Attachment ID
+		AttachmentID uint64 `json:",string"`
+
+		// Name PATH parameter
+		//
+		// File name
+		Name string
+
+		// Sign GET parameter
+		//
+		// Signature
+		Sign string
+
+		// UserID GET parameter
+		//
+		// User ID
+		UserID uint64 `json:",string"`
+
+		// Download GET parameter
+		//
+		// Force file download
+		Download bool
+	}
+
+	AttachmentPreview struct {
+		// Kind PATH parameter
+		//
+		// Attachment kind
+		Kind string
+
+		// NamespaceID PATH parameter
+		//
+		// Namespace ID
+		NamespaceID uint64 `json:",string"`
+
+		// AttachmentID PATH parameter
+		//
+		// Attachment ID
+		AttachmentID uint64 `json:",string"`
+
+		// Ext PATH parameter
+		//
+		// Preview extension/format
+		Ext string
+
+		// Sign GET parameter
+		//
+		// Signature
+		Sign string
+
+		// UserID GET parameter
+		//
+		// User ID
+		UserID uint64 `json:",string"`
+	}
+)
+
+// NewAttachmentList request
+func NewAttachmentList() *AttachmentList {
+	return &AttachmentList{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AttachmentList) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"kind":        r.Kind,
+		"namespaceID": r.NamespaceID,
+		"sign":        r.Sign,
+		"userID":      r.UserID,
+		"pageID":      r.PageID,
+		"moduleID":    r.ModuleID,
+		"recordID":    r.RecordID,
+		"fieldName":   r.FieldName,
+		"limit":       r.Limit,
+		"pageCursor":  r.PageCursor,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AttachmentList) GetKind() string {
+	return r.Kind
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AttachmentList) GetNamespaceID() uint64 {
+	return r.NamespaceID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AttachmentList) GetSign() string {
+	return r.Sign
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AttachmentList) GetUserID() uint64 {
+	return r.UserID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AttachmentList) GetPageID() uint64 {
+	return r.PageID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AttachmentList) GetModuleID() uint64 {
+	return r.ModuleID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AttachmentList) GetRecordID() uint64 {
+	return r.RecordID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AttachmentList) GetFieldName() string {
+	return r.FieldName
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AttachmentList) GetLimit() uint {
+	return r.Limit
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AttachmentList) GetPageCursor() string {
+	return r.PageCursor
+}
+
+// Fill processes request and fills internal variables
+func (r *AttachmentList) Fill(req *http.Request) (err error) {
+
+	{
+		// GET params
+		tmp := req.URL.Query()
+
+		if val, ok := tmp["sign"]; ok && len(val) > 0 {
+			r.Sign, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["userID"]; ok && len(val) > 0 {
+			r.UserID, err = payload.ParseUint64(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["pageID"]; ok && len(val) > 0 {
+			r.PageID, err = payload.ParseUint64(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["moduleID"]; ok && len(val) > 0 {
+			r.ModuleID, err = payload.ParseUint64(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["recordID"]; ok && len(val) > 0 {
+			r.RecordID, err = payload.ParseUint64(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["fieldName"]; ok && len(val) > 0 {
+			r.FieldName, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["limit"]; ok && len(val) > 0 {
+			r.Limit, err = payload.ParseUint(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["pageCursor"]; ok && len(val) > 0 {
+			r.PageCursor, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "kind")
+		r.Kind, err = val, nil
+		if err != nil {
+			return err
+		}
+
+		val = chi.URLParam(req, "namespaceID")
+		r.NamespaceID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewAttachmentRead request
+func NewAttachmentRead() *AttachmentRead {
+	return &AttachmentRead{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AttachmentRead) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"kind":         r.Kind,
+		"namespaceID":  r.NamespaceID,
+		"attachmentID": r.AttachmentID,
+		"sign":         r.Sign,
+		"userID":       r.UserID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AttachmentRead) GetKind() string {
+	return r.Kind
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AttachmentRead) GetNamespaceID() uint64 {
+	return r.NamespaceID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AttachmentRead) GetAttachmentID() uint64 {
+	return r.AttachmentID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AttachmentRead) GetSign() string {
+	return r.Sign
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AttachmentRead) GetUserID() uint64 {
+	return r.UserID
+}
+
+// Fill processes request and fills internal variables
+func (r *AttachmentRead) Fill(req *http.Request) (err error) {
+
+	{
+		// GET params
+		tmp := req.URL.Query()
+
+		if val, ok := tmp["sign"]; ok && len(val) > 0 {
+			r.Sign, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["userID"]; ok && len(val) > 0 {
+			r.UserID, err = payload.ParseUint64(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "kind")
+		r.Kind, err = val, nil
+		if err != nil {
+			return err
+		}
+
+		val = chi.URLParam(req, "namespaceID")
+		r.NamespaceID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+		val = chi.URLParam(req, "attachmentID")
+		r.AttachmentID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewAttachmentDelete request
+func NewAttachmentDelete() *AttachmentDelete {
+	return &AttachmentDelete{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AttachmentDelete) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"kind":         r.Kind,
+		"namespaceID":  r.NamespaceID,
+		"attachmentID": r.AttachmentID,
+		"sign":         r.Sign,
+		"userID":       r.UserID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AttachmentDelete) GetKind() string {
+	return r.Kind
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AttachmentDelete) GetNamespaceID() uint64 {
+	return r.NamespaceID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AttachmentDelete) GetAttachmentID() uint64 {
+	return r.AttachmentID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AttachmentDelete) GetSign() string {
+	return r.Sign
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AttachmentDelete) GetUserID() uint64 {
+	return r.UserID
+}
+
+// Fill processes request and fills internal variables
+func (r *AttachmentDelete) Fill(req *http.Request) (err error) {
+
+	{
+		// GET params
+		tmp := req.URL.Query()
+
+		if val, ok := tmp["sign"]; ok && len(val) > 0 {
+			r.Sign, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["userID"]; ok && len(val) > 0 {
+			r.UserID, err = payload.ParseUint64(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "kind")
+		r.Kind, err = val, nil
+		if err != nil {
+			return err
+		}
+
+		val = chi.URLParam(req, "namespaceID")
+		r.NamespaceID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+		val = chi.URLParam(req, "attachmentID")
+		r.AttachmentID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewAttachmentOriginal request
+func NewAttachmentOriginal() *AttachmentOriginal {
+	return &AttachmentOriginal{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AttachmentOriginal) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"kind":         r.Kind,
+		"namespaceID":  r.NamespaceID,
+		"attachmentID": r.AttachmentID,
+		"name":         r.Name,
+		"sign":         r.Sign,
+		"userID":       r.UserID,
+		"download":     r.Download,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AttachmentOriginal) GetKind() string {
+	return r.Kind
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AttachmentOriginal) GetNamespaceID() uint64 {
+	return r.NamespaceID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AttachmentOriginal) GetAttachmentID() uint64 {
+	return r.AttachmentID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AttachmentOriginal) GetName() string {
+	return r.Name
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AttachmentOriginal) GetSign() string {
+	return r.Sign
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AttachmentOriginal) GetUserID() uint64 {
+	return r.UserID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AttachmentOriginal) GetDownload() bool {
+	return r.Download
+}
+
+// Fill processes request and fills internal variables
+func (r *AttachmentOriginal) Fill(req *http.Request) (err error) {
+
+	{
+		// GET params
+		tmp := req.URL.Query()
+
+		if val, ok := tmp["sign"]; ok && len(val) > 0 {
+			r.Sign, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["userID"]; ok && len(val) > 0 {
+			r.UserID, err = payload.ParseUint64(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["download"]; ok && len(val) > 0 {
+			r.Download, err = payload.ParseBool(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "kind")
+		r.Kind, err = val, nil
+		if err != nil {
+			return err
+		}
+
+		val = chi.URLParam(req, "namespaceID")
+		r.NamespaceID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+		val = chi.URLParam(req, "attachmentID")
+		r.AttachmentID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+		val = chi.URLParam(req, "name")
+		r.Name, err = val, nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewAttachmentPreview request
+func NewAttachmentPreview() *AttachmentPreview {
+	return &AttachmentPreview{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AttachmentPreview) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"kind":         r.Kind,
+		"namespaceID":  r.NamespaceID,
+		"attachmentID": r.AttachmentID,
+		"ext":          r.Ext,
+		"sign":         r.Sign,
+		"userID":       r.UserID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AttachmentPreview) GetKind() string {
+	return r.Kind
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AttachmentPreview) GetNamespaceID() uint64 {
+	return r.NamespaceID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AttachmentPreview) GetAttachmentID() uint64 {
+	return r.AttachmentID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AttachmentPreview) GetExt() string {
+	return r.Ext
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AttachmentPreview) GetSign() string {
+	return r.Sign
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AttachmentPreview) GetUserID() uint64 {
+	return r.UserID
+}
+
+// Fill processes request and fills internal variables
+func (r *AttachmentPreview) Fill(req *http.Request) (err error) {
+
+	{
+		// GET params
+		tmp := req.URL.Query()
+
+		if val, ok := tmp["sign"]; ok && len(val) > 0 {
+			r.Sign, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["userID"]; ok && len(val) > 0 {
+			r.UserID, err = payload.ParseUint64(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "kind")
+		r.Kind, err = val, nil
+		if err != nil {
+			return err
+		}
+
+		val = chi.URLParam(req, "namespaceID")
+		r.NamespaceID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+		val = chi.URLParam(req, "attachmentID")
+		r.AttachmentID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+		val = chi.URLParam(req, "ext")
+		r.Ext, err = val, nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}

server/compose/rest/request/automation.go

@@ -0,0 +1,360 @@
+package request
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/cortezaproject/corteza/server/pkg/payload"
+	"github.com/go-chi/chi/v5"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"strings"
+)
+
+// dummy vars to prevent
+// unused imports complain
+var (
+	_ = chi.URLParam
+	_ = multipart.ErrMessageTooLarge
+	_ = payload.ParseUint64s
+	_ = strings.ToLower
+	_ = io.EOF
+	_ = fmt.Errorf
+	_ = json.NewEncoder
+)
+
+type (
+	// Internal API interface
+	AutomationList struct {
+		// ResourceTypePrefixes GET parameter
+		//
+		// Filter by resource prefix
+		ResourceTypePrefixes []string
+
+		// ResourceTypes GET parameter
+		//
+		// Filter by resource type
+		ResourceTypes []string
+
+		// EventTypes GET parameter
+		//
+		// Filter by event type
+		EventTypes []string
+
+		// ExcludeInvalid GET parameter
+		//
+		// Exclude scripts that cannot be used (errors)
+		ExcludeInvalid bool
+
+		// ExcludeClientScripts GET parameter
+		//
+		// Do not include client scripts
+		ExcludeClientScripts bool
+
+		// ExcludeServerScripts GET parameter
+		//
+		// Do not include server scripts
+		ExcludeServerScripts bool
+	}
+
+	AutomationBundle struct {
+		// Bundle PATH parameter
+		//
+		// Name of the bundle
+		Bundle string
+
+		// Type PATH parameter
+		//
+		// Bundle type
+		Type string
+
+		// Ext PATH parameter
+		//
+		// Bundle extension
+		Ext string
+	}
+
+	AutomationTriggerScript struct {
+		// Script POST parameter
+		//
+		// Script to execute
+		Script string
+
+		// Args POST parameter
+		//
+		// Arguments to pass to the script
+		Args map[string]interface{}
+	}
+)
+
+// NewAutomationList request
+func NewAutomationList() *AutomationList {
+	return &AutomationList{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AutomationList) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"resourceTypePrefixes": r.ResourceTypePrefixes,
+		"resourceTypes":        r.ResourceTypes,
+		"eventTypes":           r.EventTypes,
+		"excludeInvalid":       r.ExcludeInvalid,
+		"excludeClientScripts": r.ExcludeClientScripts,
+		"excludeServerScripts": r.ExcludeServerScripts,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AutomationList) GetResourceTypePrefixes() []string {
+	return r.ResourceTypePrefixes
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AutomationList) GetResourceTypes() []string {
+	return r.ResourceTypes
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AutomationList) GetEventTypes() []string {
+	return r.EventTypes
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AutomationList) GetExcludeInvalid() bool {
+	return r.ExcludeInvalid
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AutomationList) GetExcludeClientScripts() bool {
+	return r.ExcludeClientScripts
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AutomationList) GetExcludeServerScripts() bool {
+	return r.ExcludeServerScripts
+}
+
+// Fill processes request and fills internal variables
+func (r *AutomationList) Fill(req *http.Request) (err error) {
+
+	{
+		// GET params
+		tmp := req.URL.Query()
+
+		if val, ok := tmp["resourceTypePrefixes[]"]; ok {
+			r.ResourceTypePrefixes, err = val, nil
+			if err != nil {
+				return err
+			}
+		} else if val, ok := tmp["resourceTypePrefixes"]; ok {
+			r.ResourceTypePrefixes, err = val, nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["resourceTypes[]"]; ok {
+			r.ResourceTypes, err = val, nil
+			if err != nil {
+				return err
+			}
+		} else if val, ok := tmp["resourceTypes"]; ok {
+			r.ResourceTypes, err = val, nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["eventTypes[]"]; ok {
+			r.EventTypes, err = val, nil
+			if err != nil {
+				return err
+			}
+		} else if val, ok := tmp["eventTypes"]; ok {
+			r.EventTypes, err = val, nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["excludeInvalid"]; ok && len(val) > 0 {
+			r.ExcludeInvalid, err = payload.ParseBool(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["excludeClientScripts"]; ok && len(val) > 0 {
+			r.ExcludeClientScripts, err = payload.ParseBool(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["excludeServerScripts"]; ok && len(val) > 0 {
+			r.ExcludeServerScripts, err = payload.ParseBool(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	return err
+}
+
+// NewAutomationBundle request
+func NewAutomationBundle() *AutomationBundle {
+	return &AutomationBundle{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AutomationBundle) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"bundle": r.Bundle,
+		"type":   r.Type,
+		"ext":    r.Ext,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AutomationBundle) GetBundle() string {
+	return r.Bundle
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AutomationBundle) GetType() string {
+	return r.Type
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AutomationBundle) GetExt() string {
+	return r.Ext
+}
+
+// Fill processes request and fills internal variables
+func (r *AutomationBundle) Fill(req *http.Request) (err error) {
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "bundle")
+		r.Bundle, err = val, nil
+		if err != nil {
+			return err
+		}
+
+		val = chi.URLParam(req, "type")
+		r.Type, err = val, nil
+		if err != nil {
+			return err
+		}
+
+		val = chi.URLParam(req, "ext")
+		r.Ext, err = val, nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewAutomationTriggerScript request
+func NewAutomationTriggerScript() *AutomationTriggerScript {
+	return &AutomationTriggerScript{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AutomationTriggerScript) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"script": r.Script,
+		"args":   r.Args,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AutomationTriggerScript) GetScript() string {
+	return r.Script
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AutomationTriggerScript) GetArgs() map[string]interface{} {
+	return r.Args
+}
+
+// Fill processes request and fills internal variables
+func (r *AutomationTriggerScript) Fill(req *http.Request) (err error) {
+
+	if strings.HasPrefix(strings.ToLower(req.Header.Get("content-type")), "application/json") {
+		err = json.NewDecoder(req.Body).Decode(r)
+
+		switch {
+		case err == io.EOF:
+			err = nil
+		case err != nil:
+			return fmt.Errorf("error parsing http request body: %w", err)
+		}
+	}
+
+	{
+		// Caching 32MB to memory, the rest to disk
+		if err = req.ParseMultipartForm(32 << 20); err != nil && err != http.ErrNotMultipart {
+			return err
+		} else if err == nil {
+			// Multipart params
+
+			if val, ok := req.MultipartForm.Value["script"]; ok && len(val) > 0 {
+				r.Script, err = val[0], nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["args[]"]; ok {
+				r.Args, err = parseMapStringInterface(val)
+				if err != nil {
+					return err
+				}
+			} else if val, ok := req.MultipartForm.Value["args"]; ok {
+				r.Args, err = parseMapStringInterface(val)
+				if err != nil {
+					return err
+				}
+			}
+		}
+	}
+
+	{
+		if err = req.ParseForm(); err != nil {
+			return err
+		}
+
+		// POST params
+
+		if val, ok := req.Form["script"]; ok && len(val) > 0 {
+			r.Script, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["args[]"]; ok {
+			r.Args, err = parseMapStringInterface(val)
+			if err != nil {
+				return err
+			}
+		} else if val, ok := req.Form["args"]; ok {
+			r.Args, err = parseMapStringInterface(val)
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	return err
+}

server/compose/rest/request/chart.go

@@ -0,0 +1,897 @@
+package request
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/cortezaproject/corteza/server/pkg/label"
+	labelTypes "github.com/cortezaproject/corteza/server/pkg/label/types"
+	"github.com/cortezaproject/corteza/server/pkg/locale"
+	"github.com/cortezaproject/corteza/server/pkg/payload"
+	"github.com/go-chi/chi/v5"
+	sqlxTypes "github.com/jmoiron/sqlx/types"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"strings"
+	"time"
+)
+
+// dummy vars to prevent
+// unused imports complain
+var (
+	_ = chi.URLParam
+	_ = multipart.ErrMessageTooLarge
+	_ = payload.ParseUint64s
+	_ = strings.ToLower
+	_ = io.EOF
+	_ = fmt.Errorf
+	_ = json.NewEncoder
+)
+
+type (
+	// Internal API interface
+	ChartList struct {
+		// NamespaceID PATH parameter
+		//
+		// Namespace ID
+		NamespaceID uint64 `json:",string"`
+
+		// Query GET parameter
+		//
+		// Search query to match against charts
+		Query string
+
+		// Handle GET parameter
+		//
+		// Search charts by handle
+		Handle string
+
+		// Labels GET parameter
+		//
+		// Labels
+		Labels map[string]labelTypes.LabelValue
+
+		// Limit GET parameter
+		//
+		// Limit
+		Limit uint
+
+		// IncTotal GET parameter
+		//
+		// Include total counter
+		IncTotal bool
+
+		// PageCursor GET parameter
+		//
+		// Page cursor
+		PageCursor string
+
+		// Sort GET parameter
+		//
+		// Sort items
+		Sort string
+	}
+
+	ChartCreate struct {
+		// NamespaceID PATH parameter
+		//
+		// Namespace ID
+		NamespaceID uint64 `json:",string"`
+
+		// Config POST parameter
+		//
+		// Chart JSON
+		Config sqlxTypes.JSONText
+
+		// Name POST parameter
+		//
+		// Chart name
+		Name string
+
+		// Handle POST parameter
+		//
+		// Chart handle
+		Handle string
+
+		// Labels POST parameter
+		//
+		// Labels
+		Labels map[string]labelTypes.LabelValue
+	}
+
+	ChartRead struct {
+		// NamespaceID PATH parameter
+		//
+		// Namespace ID
+		NamespaceID uint64 `json:",string"`
+
+		// ChartID PATH parameter
+		//
+		// Chart ID
+		ChartID uint64 `json:",string"`
+	}
+
+	ChartUpdate struct {
+		// NamespaceID PATH parameter
+		//
+		// Namespace ID
+		NamespaceID uint64 `json:",string"`
+
+		// ChartID PATH parameter
+		//
+		// Chart ID
+		ChartID uint64 `json:",string"`
+
+		// Config POST parameter
+		//
+		// Chart JSON
+		Config sqlxTypes.JSONText
+
+		// Name POST parameter
+		//
+		// Chart name
+		Name string
+
+		// Handle POST parameter
+		//
+		// Chart handle
+		Handle string
+
+		// Labels POST parameter
+		//
+		// Labels
+		Labels map[string]labelTypes.LabelValue
+
+		// UpdatedAt POST parameter
+		//
+		// Last update (or creation) date
+		UpdatedAt *time.Time
+	}
+
+	ChartDelete struct {
+		// NamespaceID PATH parameter
+		//
+		// Namespace ID
+		NamespaceID uint64 `json:",string"`
+
+		// ChartID PATH parameter
+		//
+		// Chart ID
+		ChartID uint64 `json:",string"`
+	}
+
+	ChartListTranslations struct {
+		// NamespaceID PATH parameter
+		//
+		// Namespace ID
+		NamespaceID uint64 `json:",string"`
+
+		// ChartID PATH parameter
+		//
+		// ID
+		ChartID uint64 `json:",string"`
+	}
+
+	ChartUpdateTranslations struct {
+		// NamespaceID PATH parameter
+		//
+		// Namespace ID
+		NamespaceID uint64 `json:",string"`
+
+		// ChartID PATH parameter
+		//
+		// ID
+		ChartID uint64 `json:",string"`
+
+		// Translations POST parameter
+		//
+		// Resource translation to upsert
+		Translations locale.ResourceTranslationSet
+	}
+)
+
+// NewChartList request
+func NewChartList() *ChartList {
+	return &ChartList{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ChartList) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"namespaceID": r.NamespaceID,
+		"query":       r.Query,
+		"handle":      r.Handle,
+		"labels":      r.Labels,
+		"limit":       r.Limit,
+		"incTotal":    r.IncTotal,
+		"pageCursor":  r.PageCursor,
+		"sort":        r.Sort,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ChartList) GetNamespaceID() uint64 {
+	return r.NamespaceID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ChartList) GetQuery() string {
+	return r.Query
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ChartList) GetHandle() string {
+	return r.Handle
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ChartList) GetLabels() map[string]labelTypes.LabelValue {
+	return r.Labels
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ChartList) GetLimit() uint {
+	return r.Limit
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ChartList) GetIncTotal() bool {
+	return r.IncTotal
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ChartList) GetPageCursor() string {
+	return r.PageCursor
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ChartList) GetSort() string {
+	return r.Sort
+}
+
+// Fill processes request and fills internal variables
+func (r *ChartList) Fill(req *http.Request) (err error) {
+
+	{
+		// GET params
+		tmp := req.URL.Query()
+
+		if val, ok := tmp["query"]; ok && len(val) > 0 {
+			r.Query, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["handle"]; ok && len(val) > 0 {
+			r.Handle, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["labels[]"]; ok {
+			r.Labels, err = label.ParseStrings(val)
+			if err != nil {
+				return err
+			}
+		} else if val, ok := tmp["labels"]; ok {
+			r.Labels, err = label.ParseStrings(val)
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["limit"]; ok && len(val) > 0 {
+			r.Limit, err = payload.ParseUint(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["incTotal"]; ok && len(val) > 0 {
+			r.IncTotal, err = payload.ParseBool(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["pageCursor"]; ok && len(val) > 0 {
+			r.PageCursor, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["sort"]; ok && len(val) > 0 {
+			r.Sort, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "namespaceID")
+		r.NamespaceID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewChartCreate request
+func NewChartCreate() *ChartCreate {
+	return &ChartCreate{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ChartCreate) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"namespaceID": r.NamespaceID,
+		"config":      r.Config,
+		"name":        r.Name,
+		"handle":      r.Handle,
+		"labels":      r.Labels,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ChartCreate) GetNamespaceID() uint64 {
+	return r.NamespaceID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ChartCreate) GetConfig() sqlxTypes.JSONText {
+	return r.Config
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ChartCreate) GetName() string {
+	return r.Name
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ChartCreate) GetHandle() string {
+	return r.Handle
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ChartCreate) GetLabels() map[string]labelTypes.LabelValue {
+	return r.Labels
+}
+
+// Fill processes request and fills internal variables
+func (r *ChartCreate) Fill(req *http.Request) (err error) {
+
+	if strings.HasPrefix(strings.ToLower(req.Header.Get("content-type")), "application/json") {
+		err = json.NewDecoder(req.Body).Decode(r)
+
+		switch {
+		case err == io.EOF:
+			err = nil
+		case err != nil:
+			return fmt.Errorf("error parsing http request body: %w", err)
+		}
+	}
+
+	{
+		// Caching 32MB to memory, the rest to disk
+		if err = req.ParseMultipartForm(32 << 20); err != nil && err != http.ErrNotMultipart {
+			return err
+		} else if err == nil {
+			// Multipart params
+
+			if val, ok := req.MultipartForm.Value["config"]; ok && len(val) > 0 {
+				r.Config, err = payload.ParseJSONTextWithErr(val[0])
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["name"]; ok && len(val) > 0 {
+				r.Name, err = val[0], nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["handle"]; ok && len(val) > 0 {
+				r.Handle, err = val[0], nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["labels[]"]; ok {
+				r.Labels, err = label.ParseStrings(val)
+				if err != nil {
+					return err
+				}
+			} else if val, ok := req.MultipartForm.Value["labels"]; ok {
+				r.Labels, err = label.ParseStrings(val)
+				if err != nil {
+					return err
+				}
+			}
+		}
+	}
+
+	{
+		if err = req.ParseForm(); err != nil {
+			return err
+		}
+
+		// POST params
+
+		if val, ok := req.Form["config"]; ok && len(val) > 0 {
+			r.Config, err = payload.ParseJSONTextWithErr(val[0])
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["name"]; ok && len(val) > 0 {
+			r.Name, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["handle"]; ok && len(val) > 0 {
+			r.Handle, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["labels[]"]; ok {
+			r.Labels, err = label.ParseStrings(val)
+			if err != nil {
+				return err
+			}
+		} else if val, ok := req.Form["labels"]; ok {
+			r.Labels, err = label.ParseStrings(val)
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "namespaceID")
+		r.NamespaceID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewChartRead request
+func NewChartRead() *ChartRead {
+	return &ChartRead{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ChartRead) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"namespaceID": r.NamespaceID,
+		"chartID":     r.ChartID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ChartRead) GetNamespaceID() uint64 {
+	return r.NamespaceID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ChartRead) GetChartID() uint64 {
+	return r.ChartID
+}
+
+// Fill processes request and fills internal variables
+func (r *ChartRead) Fill(req *http.Request) (err error) {
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "namespaceID")
+		r.NamespaceID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+		val = chi.URLParam(req, "chartID")
+		r.ChartID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewChartUpdate request
+func NewChartUpdate() *ChartUpdate {
+	return &ChartUpdate{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ChartUpdate) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"namespaceID": r.NamespaceID,
+		"chartID":     r.ChartID,
+		"config":      r.Config,
+		"name":        r.Name,
+		"handle":      r.Handle,
+		"labels":      r.Labels,
+		"updatedAt":   r.UpdatedAt,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ChartUpdate) GetNamespaceID() uint64 {
+	return r.NamespaceID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ChartUpdate) GetChartID() uint64 {
+	return r.ChartID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ChartUpdate) GetConfig() sqlxTypes.JSONText {
+	return r.Config
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ChartUpdate) GetName() string {
+	return r.Name
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ChartUpdate) GetHandle() string {
+	return r.Handle
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ChartUpdate) GetLabels() map[string]labelTypes.LabelValue {
+	return r.Labels
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ChartUpdate) GetUpdatedAt() *time.Time {
+	return r.UpdatedAt
+}
+
+// Fill processes request and fills internal variables
+func (r *ChartUpdate) Fill(req *http.Request) (err error) {
+
+	if strings.HasPrefix(strings.ToLower(req.Header.Get("content-type")), "application/json") {
+		err = json.NewDecoder(req.Body).Decode(r)
+
+		switch {
+		case err == io.EOF:
+			err = nil
+		case err != nil:
+			return fmt.Errorf("error parsing http request body: %w", err)
+		}
+	}
+
+	{
+		// Caching 32MB to memory, the rest to disk
+		if err = req.ParseMultipartForm(32 << 20); err != nil && err != http.ErrNotMultipart {
+			return err
+		} else if err == nil {
+			// Multipart params
+
+			if val, ok := req.MultipartForm.Value["config"]; ok && len(val) > 0 {
+				r.Config, err = payload.ParseJSONTextWithErr(val[0])
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["name"]; ok && len(val) > 0 {
+				r.Name, err = val[0], nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["handle"]; ok && len(val) > 0 {
+				r.Handle, err = val[0], nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["labels[]"]; ok {
+				r.Labels, err = label.ParseStrings(val)
+				if err != nil {
+					return err
+				}
+			} else if val, ok := req.MultipartForm.Value["labels"]; ok {
+				r.Labels, err = label.ParseStrings(val)
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["updatedAt"]; ok && len(val) > 0 {
+				r.UpdatedAt, err = payload.ParseISODatePtrWithErr(val[0])
+				if err != nil {
+					return err
+				}
+			}
+		}
+	}
+
+	{
+		if err = req.ParseForm(); err != nil {
+			return err
+		}
+
+		// POST params
+
+		if val, ok := req.Form["config"]; ok && len(val) > 0 {
+			r.Config, err = payload.ParseJSONTextWithErr(val[0])
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["name"]; ok && len(val) > 0 {
+			r.Name, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["handle"]; ok && len(val) > 0 {
+			r.Handle, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["labels[]"]; ok {
+			r.Labels, err = label.ParseStrings(val)
+			if err != nil {
+				return err
+			}
+		} else if val, ok := req.Form["labels"]; ok {
+			r.Labels, err = label.ParseStrings(val)
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["updatedAt"]; ok && len(val) > 0 {
+			r.UpdatedAt, err = payload.ParseISODatePtrWithErr(val[0])
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "namespaceID")
+		r.NamespaceID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+		val = chi.URLParam(req, "chartID")
+		r.ChartID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewChartDelete request
+func NewChartDelete() *ChartDelete {
+	return &ChartDelete{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ChartDelete) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"namespaceID": r.NamespaceID,
+		"chartID":     r.ChartID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ChartDelete) GetNamespaceID() uint64 {
+	return r.NamespaceID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ChartDelete) GetChartID() uint64 {
+	return r.ChartID
+}
+
+// Fill processes request and fills internal variables
+func (r *ChartDelete) Fill(req *http.Request) (err error) {
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "namespaceID")
+		r.NamespaceID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+		val = chi.URLParam(req, "chartID")
+		r.ChartID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewChartListTranslations request
+func NewChartListTranslations() *ChartListTranslations {
+	return &ChartListTranslations{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ChartListTranslations) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"namespaceID": r.NamespaceID,
+		"chartID":     r.ChartID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ChartListTranslations) GetNamespaceID() uint64 {
+	return r.NamespaceID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ChartListTranslations) GetChartID() uint64 {
+	return r.ChartID
+}
+
+// Fill processes request and fills internal variables
+func (r *ChartListTranslations) Fill(req *http.Request) (err error) {
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "namespaceID")
+		r.NamespaceID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+		val = chi.URLParam(req, "chartID")
+		r.ChartID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewChartUpdateTranslations request
+func NewChartUpdateTranslations() *ChartUpdateTranslations {
+	return &ChartUpdateTranslations{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ChartUpdateTranslations) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"namespaceID":  r.NamespaceID,
+		"chartID":      r.ChartID,
+		"translations": r.Translations,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ChartUpdateTranslations) GetNamespaceID() uint64 {
+	return r.NamespaceID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ChartUpdateTranslations) GetChartID() uint64 {
+	return r.ChartID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ChartUpdateTranslations) GetTranslations() locale.ResourceTranslationSet {
+	return r.Translations
+}
+
+// Fill processes request and fills internal variables
+func (r *ChartUpdateTranslations) Fill(req *http.Request) (err error) {
+
+	if strings.HasPrefix(strings.ToLower(req.Header.Get("content-type")), "application/json") {
+		err = json.NewDecoder(req.Body).Decode(r)
+
+		switch {
+		case err == io.EOF:
+			err = nil
+		case err != nil:
+			return fmt.Errorf("error parsing http request body: %w", err)
+		}
+	}
+
+	{
+		// Caching 32MB to memory, the rest to disk
+		if err = req.ParseMultipartForm(32 << 20); err != nil && err != http.ErrNotMultipart {
+			return err
+		} else if err == nil {
+			// Multipart params
+
+		}
+	}
+
+	{
+		if err = req.ParseForm(); err != nil {
+			return err
+		}
+
+		// POST params
+
+		//if val, ok := req.Form["translations[]"]; ok && len(val) > 0  {
+		//    r.Translations, err = locale.ResourceTranslationSet(val), nil
+		//    if err != nil {
+		//        return err
+		//    }
+		//}
+	}
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "namespaceID")
+		r.NamespaceID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+		val = chi.URLParam(req, "chartID")
+		r.ChartID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}

server/compose/rest/request/dataPrivacy.go

@@ -0,0 +1,197 @@
+package request
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/cortezaproject/corteza/server/pkg/payload"
+	"github.com/go-chi/chi/v5"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"strings"
+)
+
+// dummy vars to prevent
+// unused imports complain
+var (
+	_ = chi.URLParam
+	_ = multipart.ErrMessageTooLarge
+	_ = payload.ParseUint64s
+	_ = strings.ToLower
+	_ = io.EOF
+	_ = fmt.Errorf
+	_ = json.NewEncoder
+)
+
+type (
+	// Internal API interface
+	DataPrivacyRecordList struct {
+		// SensitivityLevelID GET parameter
+		//
+		// Sensitivity Level ID
+		SensitivityLevelID uint64 `json:",string"`
+
+		// ConnectionID GET parameter
+		//
+		// Filter by connection ID
+		ConnectionID []string
+	}
+
+	DataPrivacyModuleList struct {
+		// ConnectionID GET parameter
+		//
+		// Filter by connection ID
+		ConnectionID []string
+
+		// Limit GET parameter
+		//
+		// Limit
+		Limit uint
+
+		// PageCursor GET parameter
+		//
+		// Page cursor
+		PageCursor string
+
+		// Sort GET parameter
+		//
+		// Sort items
+		Sort string
+	}
+)
+
+// NewDataPrivacyRecordList request
+func NewDataPrivacyRecordList() *DataPrivacyRecordList {
+	return &DataPrivacyRecordList{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DataPrivacyRecordList) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"sensitivityLevelID": r.SensitivityLevelID,
+		"connectionID":       r.ConnectionID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DataPrivacyRecordList) GetSensitivityLevelID() uint64 {
+	return r.SensitivityLevelID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DataPrivacyRecordList) GetConnectionID() []string {
+	return r.ConnectionID
+}
+
+// Fill processes request and fills internal variables
+func (r *DataPrivacyRecordList) Fill(req *http.Request) (err error) {
+
+	{
+		// GET params
+		tmp := req.URL.Query()
+
+		if val, ok := tmp["sensitivityLevelID"]; ok && len(val) > 0 {
+			r.SensitivityLevelID, err = payload.ParseUint64(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["connectionID[]"]; ok {
+			r.ConnectionID, err = val, nil
+			if err != nil {
+				return err
+			}
+		} else if val, ok := tmp["connectionID"]; ok {
+			r.ConnectionID, err = val, nil
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	return err
+}
+
+// NewDataPrivacyModuleList request
+func NewDataPrivacyModuleList() *DataPrivacyModuleList {
+	return &DataPrivacyModuleList{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DataPrivacyModuleList) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"connectionID": r.ConnectionID,
+		"limit":        r.Limit,
+		"pageCursor":   r.PageCursor,
+		"sort":         r.Sort,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DataPrivacyModuleList) GetConnectionID() []string {
+	return r.ConnectionID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DataPrivacyModuleList) GetLimit() uint {
+	return r.Limit
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DataPrivacyModuleList) GetPageCursor() string {
+	return r.PageCursor
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DataPrivacyModuleList) GetSort() string {
+	return r.Sort
+}
+
+// Fill processes request and fills internal variables
+func (r *DataPrivacyModuleList) Fill(req *http.Request) (err error) {
+
+	{
+		// GET params
+		tmp := req.URL.Query()
+
+		if val, ok := tmp["connectionID[]"]; ok {
+			r.ConnectionID, err = val, nil
+			if err != nil {
+				return err
+			}
+		} else if val, ok := tmp["connectionID"]; ok {
+			r.ConnectionID, err = val, nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["limit"]; ok && len(val) > 0 {
+			r.Limit, err = payload.ParseUint(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["pageCursor"]; ok && len(val) > 0 {
+			r.PageCursor, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["sort"]; ok && len(val) > 0 {
+			r.Sort, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	return err
+}

server/compose/rest/request/icon.go

@@ -0,0 +1,235 @@
+package request
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/cortezaproject/corteza/server/pkg/payload"
+	"github.com/go-chi/chi/v5"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"strings"
+)
+
+// dummy vars to prevent
+// unused imports complain
+var (
+	_ = chi.URLParam
+	_ = multipart.ErrMessageTooLarge
+	_ = payload.ParseUint64s
+	_ = strings.ToLower
+	_ = io.EOF
+	_ = fmt.Errorf
+	_ = json.NewEncoder
+)
+
+type (
+	// Internal API interface
+	IconList struct {
+		// Limit GET parameter
+		//
+		// Limit
+		Limit uint
+
+		// IncTotal GET parameter
+		//
+		// Include total counter
+		IncTotal bool
+
+		// PageCursor GET parameter
+		//
+		// Page cursor
+		PageCursor string
+
+		// Sort GET parameter
+		//
+		// Sort items
+		Sort string
+	}
+
+	IconUpload struct {
+		// Icon POST parameter
+		//
+		// Icon to upload
+		Icon *multipart.FileHeader
+	}
+
+	IconDelete struct {
+		// IconID PATH parameter
+		//
+		// Icon ID
+		IconID uint64 `json:",string"`
+	}
+)
+
+// NewIconList request
+func NewIconList() *IconList {
+	return &IconList{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r IconList) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"limit":      r.Limit,
+		"incTotal":   r.IncTotal,
+		"pageCursor": r.PageCursor,
+		"sort":       r.Sort,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r IconList) GetLimit() uint {
+	return r.Limit
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r IconList) GetIncTotal() bool {
+	return r.IncTotal
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r IconList) GetPageCursor() string {
+	return r.PageCursor
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r IconList) GetSort() string {
+	return r.Sort
+}
+
+// Fill processes request and fills internal variables
+func (r *IconList) Fill(req *http.Request) (err error) {
+
+	{
+		// GET params
+		tmp := req.URL.Query()
+
+		if val, ok := tmp["limit"]; ok && len(val) > 0 {
+			r.Limit, err = payload.ParseUint(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["incTotal"]; ok && len(val) > 0 {
+			r.IncTotal, err = payload.ParseBool(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["pageCursor"]; ok && len(val) > 0 {
+			r.PageCursor, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["sort"]; ok && len(val) > 0 {
+			r.Sort, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	return err
+}
+
+// NewIconUpload request
+func NewIconUpload() *IconUpload {
+	return &IconUpload{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r IconUpload) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"icon": r.Icon,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r IconUpload) GetIcon() *multipart.FileHeader {
+	return r.Icon
+}
+
+// Fill processes request and fills internal variables
+func (r *IconUpload) Fill(req *http.Request) (err error) {
+
+	if strings.HasPrefix(strings.ToLower(req.Header.Get("content-type")), "application/json") {
+		err = json.NewDecoder(req.Body).Decode(r)
+
+		switch {
+		case err == io.EOF:
+			err = nil
+		case err != nil:
+			return fmt.Errorf("error parsing http request body: %w", err)
+		}
+	}
+
+	{
+		// Caching 32MB to memory, the rest to disk
+		if err = req.ParseMultipartForm(32 << 20); err != nil && err != http.ErrNotMultipart {
+			return err
+		} else if err == nil {
+			// Multipart params
+
+			// Ignoring icon as its handled in the POST params section
+		}
+	}
+
+	{
+		if err = req.ParseForm(); err != nil {
+			return err
+		}
+
+		// POST params
+
+		if _, r.Icon, err = req.FormFile("icon"); err != nil {
+			return fmt.Errorf("error processing uploaded file: %w", err)
+		}
+
+	}
+
+	return err
+}
+
+// NewIconDelete request
+func NewIconDelete() *IconDelete {
+	return &IconDelete{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r IconDelete) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"iconID": r.IconID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r IconDelete) GetIconID() uint64 {
+	return r.IconID
+}
+
+// Fill processes request and fills internal variables
+func (r *IconDelete) Fill(req *http.Request) (err error) {
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "iconID")
+		r.IconID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}

server/compose/rest/request/notification.go

@@ -0,0 +1,213 @@
+package request
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/cortezaproject/corteza/server/pkg/payload"
+	"github.com/go-chi/chi/v5"
+	sqlxTypes "github.com/jmoiron/sqlx/types"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"strings"
+)
+
+// dummy vars to prevent
+// unused imports complain
+var (
+	_ = chi.URLParam
+	_ = multipart.ErrMessageTooLarge
+	_ = payload.ParseUint64s
+	_ = strings.ToLower
+	_ = io.EOF
+	_ = fmt.Errorf
+	_ = json.NewEncoder
+)
+
+type (
+	// Internal API interface
+	NotificationEmailSend struct {
+		// To POST parameter
+		//
+		// Email addresses
+		To []string
+
+		// Cc POST parameter
+		//
+		// Email addresses
+		Cc []string
+
+		// ReplyTo POST parameter
+		//
+		// Email address in reply-to field
+		ReplyTo string
+
+		// Subject POST parameter
+		//
+		// Email subject
+		Subject string
+
+		// Content POST parameter
+		//
+		// Message content
+		Content sqlxTypes.JSONText
+
+		// RemoteAttachments POST parameter
+		//
+		// Remote files to attach to the email
+		RemoteAttachments []string
+	}
+)
+
+// NewNotificationEmailSend request
+func NewNotificationEmailSend() *NotificationEmailSend {
+	return &NotificationEmailSend{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NotificationEmailSend) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"to":                r.To,
+		"cc":                r.Cc,
+		"replyTo":           r.ReplyTo,
+		"subject":           r.Subject,
+		"content":           r.Content,
+		"remoteAttachments": r.RemoteAttachments,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NotificationEmailSend) GetTo() []string {
+	return r.To
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NotificationEmailSend) GetCc() []string {
+	return r.Cc
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NotificationEmailSend) GetReplyTo() string {
+	return r.ReplyTo
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NotificationEmailSend) GetSubject() string {
+	return r.Subject
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NotificationEmailSend) GetContent() sqlxTypes.JSONText {
+	return r.Content
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NotificationEmailSend) GetRemoteAttachments() []string {
+	return r.RemoteAttachments
+}
+
+// Fill processes request and fills internal variables
+func (r *NotificationEmailSend) Fill(req *http.Request) (err error) {
+
+	if strings.HasPrefix(strings.ToLower(req.Header.Get("content-type")), "application/json") {
+		err = json.NewDecoder(req.Body).Decode(r)
+
+		switch {
+		case err == io.EOF:
+			err = nil
+		case err != nil:
+			return fmt.Errorf("error parsing http request body: %w", err)
+		}
+	}
+
+	{
+		// Caching 32MB to memory, the rest to disk
+		if err = req.ParseMultipartForm(32 << 20); err != nil && err != http.ErrNotMultipart {
+			return err
+		} else if err == nil {
+			// Multipart params
+
+			if val, ok := req.MultipartForm.Value["replyTo"]; ok && len(val) > 0 {
+				r.ReplyTo, err = val[0], nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["subject"]; ok && len(val) > 0 {
+				r.Subject, err = val[0], nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["content"]; ok && len(val) > 0 {
+				r.Content, err = payload.ParseJSONTextWithErr(val[0])
+				if err != nil {
+					return err
+				}
+			}
+
+		}
+	}
+
+	{
+		if err = req.ParseForm(); err != nil {
+			return err
+		}
+
+		// POST params
+
+		//if val, ok := req.Form["to[]"]; ok && len(val) > 0  {
+		//    r.To, err = val, nil
+		//    if err != nil {
+		//        return err
+		//    }
+		//}
+
+		//if val, ok := req.Form["cc[]"]; ok && len(val) > 0  {
+		//    r.Cc, err = val, nil
+		//    if err != nil {
+		//        return err
+		//    }
+		//}
+
+		if val, ok := req.Form["replyTo"]; ok && len(val) > 0 {
+			r.ReplyTo, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["subject"]; ok && len(val) > 0 {
+			r.Subject, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["content"]; ok && len(val) > 0 {
+			r.Content, err = payload.ParseJSONTextWithErr(val[0])
+			if err != nil {
+				return err
+			}
+		}
+
+		//if val, ok := req.Form["remoteAttachments[]"]; ok && len(val) > 0  {
+		//    r.RemoteAttachments, err = val, nil
+		//    if err != nil {
+		//        return err
+		//    }
+		//}
+	}
+
+	return err
+}

server/compose/rest/request/permissions.go

@@ -0,0 +1,384 @@
+package request
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/cortezaproject/corteza/server/pkg/payload"
+	"github.com/cortezaproject/corteza/server/pkg/rbac"
+	"github.com/go-chi/chi/v5"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"strings"
+)
+
+// dummy vars to prevent
+// unused imports complain
+var (
+	_ = chi.URLParam
+	_ = multipart.ErrMessageTooLarge
+	_ = payload.ParseUint64s
+	_ = strings.ToLower
+	_ = io.EOF
+	_ = fmt.Errorf
+	_ = json.NewEncoder
+)
+
+type (
+	// Internal API interface
+	PermissionsList struct {
+	}
+
+	PermissionsEffective struct {
+		// Resource GET parameter
+		//
+		// Show only rules for a specific resource
+		Resource string
+	}
+
+	PermissionsTrace struct {
+		// Resource GET parameter
+		//
+		// Show only rules for a specific resource
+		Resource []string
+
+		// UserID GET parameter
+		//
+		//
+		UserID uint64 `json:",string"`
+
+		// RoleID GET parameter
+		//
+		//
+		RoleID []uint64
+	}
+
+	PermissionsRead struct {
+		// RoleID PATH parameter
+		//
+		// Role ID
+		RoleID uint64 `json:",string"`
+
+		// Resource GET parameter
+		//
+		// Show only rules for a specific resource
+		Resource []string
+	}
+
+	PermissionsDelete struct {
+		// RoleID PATH parameter
+		//
+		// Role ID
+		RoleID uint64 `json:",string"`
+	}
+
+	PermissionsUpdate struct {
+		// RoleID PATH parameter
+		//
+		// Role ID
+		RoleID uint64 `json:",string"`
+
+		// Rules POST parameter
+		//
+		// List of permission rules to set
+		Rules rbac.RuleSet
+	}
+)
+
+// NewPermissionsList request
+func NewPermissionsList() *PermissionsList {
+	return &PermissionsList{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r PermissionsList) Auditable() map[string]interface{} {
+	return map[string]interface{}{}
+}
+
+// Fill processes request and fills internal variables
+func (r *PermissionsList) Fill(req *http.Request) (err error) {
+
+	return err
+}
+
+// NewPermissionsEffective request
+func NewPermissionsEffective() *PermissionsEffective {
+	return &PermissionsEffective{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r PermissionsEffective) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"resource": r.Resource,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r PermissionsEffective) GetResource() string {
+	return r.Resource
+}
+
+// Fill processes request and fills internal variables
+func (r *PermissionsEffective) Fill(req *http.Request) (err error) {
+
+	{
+		// GET params
+		tmp := req.URL.Query()
+
+		if val, ok := tmp["resource"]; ok && len(val) > 0 {
+			r.Resource, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	return err
+}
+
+// NewPermissionsTrace request
+func NewPermissionsTrace() *PermissionsTrace {
+	return &PermissionsTrace{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r PermissionsTrace) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"resource": r.Resource,
+		"userID":   r.UserID,
+		"roleID":   r.RoleID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r PermissionsTrace) GetResource() []string {
+	return r.Resource
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r PermissionsTrace) GetUserID() uint64 {
+	return r.UserID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r PermissionsTrace) GetRoleID() []uint64 {
+	return r.RoleID
+}
+
+// Fill processes request and fills internal variables
+func (r *PermissionsTrace) Fill(req *http.Request) (err error) {
+
+	{
+		// GET params
+		tmp := req.URL.Query()
+
+		if val, ok := tmp["resource[]"]; ok {
+			r.Resource, err = val, nil
+			if err != nil {
+				return err
+			}
+		} else if val, ok := tmp["resource"]; ok {
+			r.Resource, err = val, nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["userID"]; ok && len(val) > 0 {
+			r.UserID, err = payload.ParseUint64(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["roleID[]"]; ok {
+			r.RoleID, err = payload.ParseUint64s(val), nil
+			if err != nil {
+				return err
+			}
+		} else if val, ok := tmp["roleID"]; ok {
+			r.RoleID, err = payload.ParseUint64s(val), nil
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	return err
+}
+
+// NewPermissionsRead request
+func NewPermissionsRead() *PermissionsRead {
+	return &PermissionsRead{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r PermissionsRead) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"roleID":   r.RoleID,
+		"resource": r.Resource,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r PermissionsRead) GetRoleID() uint64 {
+	return r.RoleID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r PermissionsRead) GetResource() []string {
+	return r.Resource
+}
+
+// Fill processes request and fills internal variables
+func (r *PermissionsRead) Fill(req *http.Request) (err error) {
+
+	{
+		// GET params
+		tmp := req.URL.Query()
+
+		if val, ok := tmp["resource[]"]; ok {
+			r.Resource, err = val, nil
+			if err != nil {
+				return err
+			}
+		} else if val, ok := tmp["resource"]; ok {
+			r.Resource, err = val, nil
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "roleID")
+		r.RoleID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewPermissionsDelete request
+func NewPermissionsDelete() *PermissionsDelete {
+	return &PermissionsDelete{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r PermissionsDelete) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"roleID": r.RoleID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r PermissionsDelete) GetRoleID() uint64 {
+	return r.RoleID
+}
+
+// Fill processes request and fills internal variables
+func (r *PermissionsDelete) Fill(req *http.Request) (err error) {
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "roleID")
+		r.RoleID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewPermissionsUpdate request
+func NewPermissionsUpdate() *PermissionsUpdate {
+	return &PermissionsUpdate{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r PermissionsUpdate) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"roleID": r.RoleID,
+		"rules":  r.Rules,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r PermissionsUpdate) GetRoleID() uint64 {
+	return r.RoleID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r PermissionsUpdate) GetRules() rbac.RuleSet {
+	return r.Rules
+}
+
+// Fill processes request and fills internal variables
+func (r *PermissionsUpdate) Fill(req *http.Request) (err error) {
+
+	if strings.HasPrefix(strings.ToLower(req.Header.Get("content-type")), "application/json") {
+		err = json.NewDecoder(req.Body).Decode(r)
+
+		switch {
+		case err == io.EOF:
+			err = nil
+		case err != nil:
+			return fmt.Errorf("error parsing http request body: %w", err)
+		}
+	}
+
+	{
+		// Caching 32MB to memory, the rest to disk
+		if err = req.ParseMultipartForm(32 << 20); err != nil && err != http.ErrNotMultipart {
+			return err
+		} else if err == nil {
+			// Multipart params
+
+		}
+	}
+
+	{
+		if err = req.ParseForm(); err != nil {
+			return err
+		}
+
+		// POST params
+
+		//if val, ok := req.Form["rules[]"]; ok && len(val) > 0  {
+		//    r.Rules, err = rbac.RuleSet(val), nil
+		//    if err != nil {
+		//        return err
+		//    }
+		//}
+	}
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "roleID")
+		r.RoleID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}

server/compose/rest/request/util.go

@@ -0,0 +1,44 @@
+package request
+
+//lint:file-ignore U1000 Ignore unused code, part of request pkg toolset
+
+import (
+	"encoding/json"
+	"strconv"
+	"strings"
+)
+
+type (
+	ProcedureArgs []ProcedureArg
+
+	ProcedureArg struct {
+		Name  string `json:"name"`
+		Value string `json:"value"`
+	}
+)
+
+func (args ProcedureArgs) GetUint64(name string) uint64 {
+	u, _ := strconv.ParseUint(args.Get(name), 10, 64)
+	return u
+}
+
+func (args ProcedureArgs) Get(name string) string {
+	name = strings.ToLower(name)
+	for _, arg := range args {
+		if strings.ToLower(arg.Name) == name {
+			return arg.Value
+		}
+	}
+
+	return ""
+}
+
+func parseMapStringInterface(ss []string) (map[string]interface{}, error) {
+	if len(ss) == 0 {
+		return nil, nil
+	}
+
+	out := make(map[string]interface{})
+
+	return out, json.Unmarshal([]byte(ss[0]), out)
+}

server/compose/rest/router.go

@@ -0,0 +1,49 @@
+package rest
+
+import (
+	"github.com/go-chi/chi/v5"
+
+	"github.com/cortezaproject/corteza/server/compose/rest/handlers"
+	"github.com/cortezaproject/corteza/server/pkg/auth"
+)
+
+func MountRoutes() func(r chi.Router) {
+	return func(r chi.Router) {
+		var (
+			namespace    = Namespace{}.New()
+			module       = Module{}.New()
+			record       = Record{}.New()
+			page         = Page{}.New()
+			pageIcon     = Icon{}.New()
+			pageLayout   = PageLayout{}.New()
+			chart        = Chart{}.New()
+			notification = Notification{}.New()
+			attachment   = Attachment{}.New()
+			automation   = Automation{}.New()
+			dataPrivacy  = DataPrivacy{}.New()
+		)
+
+		// Initialize handlers & controllers.
+		r.Group(func(r chi.Router) {
+			// Use alternative handlers that support file serving
+			handlers.NewAttachment(attachment).MountRoutes(r)
+		})
+
+		// Protect all _private_ routes
+		r.Group(func(r chi.Router) {
+			r.Use(auth.HttpTokenValidator("api"))
+
+			handlers.NewPermissions(Permissions{}.New()).MountRoutes(r)
+			handlers.NewNamespace(namespace).MountRoutes(r)
+			handlers.NewPage(page).MountRoutes(r)
+			handlers.NewIcon(pageIcon).MountRoutes(r)
+			handlers.NewPageLayout(pageLayout).MountRoutes(r)
+			handlers.NewAutomation(automation).MountRoutes(r)
+			handlers.NewModule(module).MountRoutes(r)
+			handlers.NewRecord(record).MountRoutes(r)
+			handlers.NewChart(chart).MountRoutes(r)
+			handlers.NewNotification(notification).MountRoutes(r)
+			handlers.NewDataPrivacy(dataPrivacy).MountRoutes(r)
+		})
+	}
+}