Add support for Function and Trigger domain objects (#1060)

Vast commit, includes:

 * Introduces the Trigger domain entity.
 * Introduces the Fns domain entity.
 * V2 of the API for interacting with the new entities in swaggerv2.yml
 * Adds v2 end points for Apps to support PUT updates.
 * Rewrites the datastore level tests into a new pattern.
 * V2 routes use entity ID over name as the path parameter.

api/datastore/datastore.go

@@ -5,6 +5,7 @@ import (
 	"net/url"
 
 	"fmt"
+
 	"github.com/fnproject/fn/api/common"
 	"github.com/fnproject/fn/api/datastore/internal/datastoreutil"
 	"github.com/fnproject/fn/api/models"

api/datastore/internal/datastoreutil/metrics.go

@@ -6,7 +6,6 @@ import (
 	"go.opencensus.io/trace"
 
 	"github.com/fnproject/fn/api/models"
-	"github.com/jmoiron/sqlx"
 )
 
 func MetricDS(ds models.Datastore) models.Datastore {
@@ -83,8 +82,66 @@ func (m *metricds) RemoveRoute(ctx context.Context, appID string, routePath stri
 	return m.ds.RemoveRoute(ctx, appID, routePath)
 }
 
-// instant & no context ;)
-func (m *metricds) GetDatabase() *sqlx.DB { return m.ds.GetDatabase() }
+func (m *metricds) InsertTrigger(ctx context.Context, trigger *models.Trigger) (*models.Trigger, error) {
+	ctx, span := trace.StartSpan(ctx, "ds_insert_trigger")
+	defer span.End()
+	return m.ds.InsertTrigger(ctx, trigger)
+
+}
+
+func (m *metricds) UpdateTrigger(ctx context.Context, trigger *models.Trigger) (*models.Trigger, error) {
+	ctx, span := trace.StartSpan(ctx, "ds_update_trigger")
+	defer span.End()
+	return m.ds.UpdateTrigger(ctx, trigger)
+}
+
+func (m *metricds) RemoveTrigger(ctx context.Context, triggerID string) error {
+	ctx, span := trace.StartSpan(ctx, "ds_remove_trigger")
+	defer span.End()
+	return m.ds.RemoveTrigger(ctx, triggerID)
+}
+
+func (m *metricds) GetTriggerByID(ctx context.Context, triggerID string) (*models.Trigger, error) {
+	ctx, span := trace.StartSpan(ctx, "ds_get_trigger_by_id")
+	defer span.End()
+	return m.ds.GetTriggerByID(ctx, triggerID)
+}
+
+func (m *metricds) GetTriggers(ctx context.Context, filter *models.TriggerFilter) ([]*models.Trigger, error) {
+	ctx, span := trace.StartSpan(ctx, "ds_get_triggers")
+	defer span.End()
+	return m.ds.GetTriggers(ctx, filter)
+}
+
+func (m *metricds) InsertFn(ctx context.Context, fn *models.Fn) (*models.Fn, error) {
+	ctx, span := trace.StartSpan(ctx, "ds_insert_func")
+	defer span.End()
+	return m.ds.InsertFn(ctx, fn)
+}
+
+func (m *metricds) UpdateFn(ctx context.Context, fn *models.Fn) (*models.Fn, error) {
+	ctx, span := trace.StartSpan(ctx, "ds_insert_func")
+	defer span.End()
+	return m.ds.UpdateFn(ctx, fn)
+}
+
+func (m *metricds) GetFns(ctx context.Context, filter *models.FnFilter) ([]*models.Fn, error) {
+	ctx, span := trace.StartSpan(ctx, "ds_get_funcs")
+	defer span.End()
+	return m.ds.GetFns(ctx, filter)
+}
+
+func (m *metricds) GetFnByID(ctx context.Context, fnID string) (*models.Fn, error) {
+	ctx, span := trace.StartSpan(ctx, "ds_get_func")
+	defer span.End()
+	return m.ds.GetFnByID(ctx, fnID)
+}
+
+func (m *metricds) RemoveFn(ctx context.Context, fnID string) error {
+	ctx, span := trace.StartSpan(ctx, "ds_remove_func")
+	defer span.End()
+	return m.ds.RemoveFn(ctx, fnID)
+}
 
 // Close calls Close on the underlying Datastore
 func (m *metricds) Close() error {

api/datastore/internal/datastoreutil/validator.go

@@ -2,8 +2,7 @@ package datastoreutil
 
 import (
 	"context"
-
-	"github.com/jmoiron/sqlx"
+	"time"
 
 	"github.com/fnproject/fn/api/models"
 )
@@ -26,7 +25,7 @@ func (v *validator) GetAppID(ctx context.Context, appName string) (string, error
 
 func (v *validator) GetAppByID(ctx context.Context, appID string) (*models.App, error) {
 	if appID == "" {
-		return nil, models.ErrDatastoreEmptyAppID
+		return nil, models.ErrAppsMissingID
 	}
 
 	return v.Datastore.GetAppByID(ctx, appID)
@@ -41,8 +40,9 @@ func (v *validator) InsertApp(ctx context.Context, app *models.App) (*models.App
 	if app == nil {
 		return nil, models.ErrDatastoreEmptyApp
 	}
-
-	app.SetDefaults()
+	if app.ID != "" {
+		return nil, models.ErrAppIDProvided
+	}
 	if err := app.Validate(); err != nil {
 		return nil, err
 	}
@@ -56,7 +56,7 @@ func (v *validator) UpdateApp(ctx context.Context, app *models.App) (*models.App
 		return nil, models.ErrDatastoreEmptyApp
 	}
 	if app.ID == "" {
-		return nil, models.ErrDatastoreEmptyAppID
+		return nil, models.ErrAppsMissingID
 	}
 
 	return v.Datastore.UpdateApp(ctx, app)
@@ -65,7 +65,7 @@ func (v *validator) UpdateApp(ctx context.Context, app *models.App) (*models.App
 // name will never be empty.
 func (v *validator) RemoveApp(ctx context.Context, appID string) error {
 	if appID == "" {
-		return models.ErrDatastoreEmptyAppID
+		return models.ErrAppsMissingID
 	}
 
 	return v.Datastore.RemoveApp(ctx, appID)
@@ -74,7 +74,7 @@ func (v *validator) RemoveApp(ctx context.Context, appID string) error {
 // appName and routePath will never be empty.
 func (v *validator) GetRoute(ctx context.Context, appID, routePath string) (*models.Route, error) {
 	if appID == "" {
-		return nil, models.ErrDatastoreEmptyAppID
+		return nil, models.ErrRoutesMissingAppID
 	}
 	if routePath == "" {
 		return nil, models.ErrRoutesMissingPath
@@ -86,7 +86,7 @@ func (v *validator) GetRoute(ctx context.Context, appID, routePath string) (*mod
 // appName will never be empty
 func (v *validator) GetRoutesByApp(ctx context.Context, appID string, routeFilter *models.RouteFilter) (routes []*models.Route, err error) {
 	if appID == "" {
-		return nil, models.ErrDatastoreEmptyAppID
+		return nil, models.ErrRoutesMissingAppID
 	}
 
 	return v.Datastore.GetRoutesByApp(ctx, appID, routeFilter)
@@ -98,7 +98,6 @@ func (v *validator) InsertRoute(ctx context.Context, route *models.Route) (*mode
 		return nil, models.ErrDatastoreEmptyRoute
 	}
 
-	route.SetDefaults()
 	if err := route.Validate(); err != nil {
 		return nil, err
 	}
@@ -123,7 +122,7 @@ func (v *validator) UpdateRoute(ctx context.Context, newroute *models.Route) (*m
 // appName and routePath will never be empty.
 func (v *validator) RemoveRoute(ctx context.Context, appID string, routePath string) error {
 	if appID == "" {
-		return models.ErrDatastoreEmptyAppID
+		return models.ErrRoutesMissingAppID
 	}
 	if routePath == "" {
 		return models.ErrRoutesMissingPath
@@ -132,7 +131,82 @@ func (v *validator) RemoveRoute(ctx context.Context, appID string, routePath str
 	return v.Datastore.RemoveRoute(ctx, appID, routePath)
 }
 
-// GetDatabase returns the underlying sqlx database implementation
-func (v *validator) GetDatabase() *sqlx.DB {
-	return v.Datastore.GetDatabase()
+func (v *validator) InsertTrigger(ctx context.Context, t *models.Trigger) (*models.Trigger, error) {
+
+	if t.ID != "" {
+		return nil, models.ErrTriggerIDProvided
+	}
+
+	if !time.Time(t.CreatedAt).IsZero() {
+		return nil, models.ErrCreatedAtProvided
+	}
+	if !time.Time(t.UpdatedAt).IsZero() {
+		return nil, models.ErrUpdatedAtProvided
+	}
+
+	return v.Datastore.InsertTrigger(ctx, t)
+}
+
+func (v *validator) UpdateTrigger(ctx context.Context, trigger *models.Trigger) (*models.Trigger, error) {
+	return v.Datastore.UpdateTrigger(ctx, trigger)
+}
+
+func (v *validator) GetTriggers(ctx context.Context, filter *models.TriggerFilter) ([]*models.Trigger, error) {
+
+	if filter.AppID == "" {
+		return nil, models.ErrTriggerMissingAppID
+	}
+
+	return v.Datastore.GetTriggers(ctx, filter)
+}
+func (v *validator) RemoveTrigger(ctx context.Context, triggerID string) error {
+	if triggerID == "" {
+		return models.ErrMissingID
+	}
+
+	return v.Datastore.RemoveTrigger(ctx, triggerID)
+}
+
+func (v *validator) InsertFn(ctx context.Context, fn *models.Fn) (*models.Fn, error) {
+	if fn == nil {
+		return nil, models.ErrDatastoreEmptyFn
+	}
+	if fn.ID != "" {
+		return nil, models.ErrFnsIDProvided
+	}
+	if fn.AppID == "" {
+		return nil, models.ErrFnsMissingAppID
+	}
+	if fn.Name == "" {
+		return nil, models.ErrFnsMissingName
+	}
+	return v.Datastore.InsertFn(ctx, fn)
+}
+
+func (v *validator) UpdateFn(ctx context.Context, fn *models.Fn) (*models.Fn, error) {
+	return v.Datastore.UpdateFn(ctx, fn)
+}
+
+func (v *validator) GetFnByID(ctx context.Context, fnID string) (*models.Fn, error) {
+	if fnID == "" {
+		return nil, models.ErrDatastoreEmptyFnID
+	}
+
+	return v.Datastore.GetFnByID(ctx, fnID)
+}
+
+func (v *validator) GetFns(ctx context.Context, filter *models.FnFilter) ([]*models.Fn, error) {
+
+	if filter.AppID == "" {
+		return nil, models.ErrFnsMissingAppID
+	}
+
+	return v.Datastore.GetFns(ctx, filter)
+}
+
+func (v *validator) RemoveFn(ctx context.Context, fnID string) error {
+	if fnID == "" {
+		return models.ErrDatastoreEmptyFnID
+	}
+	return v.Datastore.RemoveFn(ctx, fnID)
 }

api/datastore/mock.go

@@ -5,15 +5,20 @@ import (
 	"sort"
 	"strings"
 
+	"time"
+
+	"github.com/fnproject/fn/api/common"
 	"github.com/fnproject/fn/api/datastore/internal/datastoreutil"
+	"github.com/fnproject/fn/api/id"
 	"github.com/fnproject/fn/api/logs"
 	"github.com/fnproject/fn/api/models"
-	"github.com/jmoiron/sqlx"
 )
 
 type mock struct {
-	Apps   []*models.App
-	Routes []*models.Route
+	Apps     []*models.App
+	Routes   []*models.Route
+	Fns      []*models.Fn
+	Triggers []*models.Trigger
 
 	models.LogStore
 }
@@ -31,6 +36,11 @@ func NewMockInit(args ...interface{}) models.Datastore {
 			mocker.Apps = x
 		case []*models.Route:
 			mocker.Routes = x
+		case []*models.Fn:
+			mocker.Fns = x
+		case []*models.Trigger:
+			mocker.Triggers = x
+
 		default:
 			panic("not accounted for data type sent to mock init. add it")
 		}
@@ -52,7 +62,7 @@ func (m *mock) GetAppID(ctx context.Context, appName string) (string, error) {
 func (m *mock) GetAppByID(ctx context.Context, appID string) (*models.App, error) {
 	for _, a := range m.Apps {
 		if a.ID == appID {
-			return a, nil
+			return a.Clone(), nil
 		}
 	}
 
@@ -74,47 +84,101 @@ func (m *mock) GetApps(ctx context.Context, appFilter *models.AppFilter) ([]*mod
 		if len(apps) == appFilter.PerPage {
 			break
 		}
+		if len(appFilter.NameIn) > 0 {
+			var found bool
+			for _, fn := range appFilter.NameIn {
+				if fn == a.Name {
+					found = true
+					break
+				}
+			}
+			if !found {
+				continue
+			}
+		}
 		if strings.Compare(appFilter.Cursor, a.Name) < 0 {
-			apps = append(apps, a)
+			apps = append(apps, a.Clone())
 		}
 	}
 
 	return apps, nil
 }
 
-func (m *mock) InsertApp(ctx context.Context, app *models.App) (*models.App, error) {
-	if a, _ := m.GetAppByID(ctx, app.ID); a != nil {
-		return nil, models.ErrAppsAlreadyExists
+func (m *mock) InsertApp(ctx context.Context, newApp *models.App) (*models.App, error) {
+	for _, a := range m.Apps {
+		if newApp.Name == a.Name {
+			return nil, models.ErrAppsAlreadyExists
+		}
 	}
+
+	app := newApp.Clone()
+	app.CreatedAt = common.DateTime(time.Now())
+	app.UpdatedAt = app.CreatedAt
+	app.ID = id.New().String()
+
 	m.Apps = append(m.Apps, app)
-	return app, nil
+	return app.Clone(), nil
 }
 
 func (m *mock) UpdateApp(ctx context.Context, app *models.App) (*models.App, error) {
-	a, err := m.GetAppByID(ctx, app.ID)
-	if err != nil {
-		return nil, err
-	}
-	a.Update(app)
 
-	return a.Clone(), nil
+	appID := app.ID
+	for idx, a := range m.Apps {
+		if a.ID == appID {
+			if app.Name != "" && app.Name != a.Name {
+				return nil, models.ErrAppsNameImmutable
+			}
+			c := a.Clone()
+			c.Update(app)
+			err := c.Validate()
+			if err != nil {
+				return nil, err
+			}
+			m.Apps[idx] = c
+			return c.Clone(), nil
+		}
+	}
+
+	return nil, models.ErrAppsNotFound
+
 }
 
 func (m *mock) RemoveApp(ctx context.Context, appID string) error {
 	m.batchDeleteRoutes(ctx, appID)
+
 	for i, a := range m.Apps {
 		if a.ID == appID {
-			m.Apps = append(m.Apps[:i], m.Apps[i+1:]...)
+			var newFns []*models.Fn
+			var newTriggers []*models.Trigger
+			newApps := append(m.Apps[0:i], m.Apps[i+1:]...)
+
+			for _, fn := range m.Fns {
+				if fn.AppID != appID {
+					newFns = append(newFns, fn)
+				}
+			}
+
+			for _, t := range m.Triggers {
+				if t.AppID != appID {
+					newTriggers = append(newTriggers, t)
+				}
+			}
+
+			m.Apps = newApps
+			m.Triggers = newTriggers
+			m.Fns = newFns
 			return nil
+
 		}
 	}
+
 	return models.ErrAppsNotFound
 }
 
 func (m *mock) GetRoute(ctx context.Context, appID, routePath string) (*models.Route, error) {
 	for _, r := range m.Routes {
 		if r.AppID == appID && r.Path == routePath {
-			return r, nil
+			return r.Clone(), nil
 		}
 	}
 	return nil, models.ErrRoutesNotFound
@@ -140,13 +204,19 @@ func (m *mock) GetRoutesByApp(ctx context.Context, appID string, routeFilter *mo
 			(routeFilter.Image == "" || routeFilter.Image == r.Image) &&
 			strings.Compare(routeFilter.Cursor, r.Path) < 0 {
 
-			routes = append(routes, r)
+			routes = append(routes, r.Clone())
 		}
 	}
 	return
 }
 
 func (m *mock) InsertRoute(ctx context.Context, route *models.Route) (*models.Route, error) {
+
+	c := route.Clone()
+	c.SetDefaults()
+	c.CreatedAt = common.DateTime(time.Now())
+	c.UpdatedAt = c.CreatedAt
+
 	if _, err := m.GetAppByID(ctx, route.AppID); err != nil {
 		return nil, err
 	}
@@ -154,8 +224,8 @@ func (m *mock) InsertRoute(ctx context.Context, route *models.Route) (*models.Ro
 	if r, _ := m.GetRoute(ctx, route.AppID, route.Path); r != nil {
 		return nil, models.ErrRoutesAlreadyExists
 	}
-	m.Routes = append(m.Routes, route)
-	return route, nil
+	m.Routes = append(m.Routes, c)
+	return c.Clone(), nil
 }
 
 func (m *mock) UpdateRoute(ctx context.Context, route *models.Route) (*models.Route, error) {
@@ -184,7 +254,7 @@ func (m *mock) RemoveRoute(ctx context.Context, appID, routePath string) error {
 }
 
 func (m *mock) batchDeleteRoutes(ctx context.Context, appID string) error {
-	newRoutes := []*models.Route{}
+	var newRoutes []*models.Route
 	for _, c := range m.Routes {
 		if c.AppID != appID {
 			newRoutes = append(newRoutes, c)
@@ -194,9 +264,223 @@ func (m *mock) batchDeleteRoutes(ctx context.Context, appID string) error {
 	return nil
 }
 
-// GetDatabase returns nil here since shouldn't really be used
-func (m *mock) GetDatabase() *sqlx.DB {
-	return nil
+func (m *mock) InsertFn(ctx context.Context, fn *models.Fn) (*models.Fn, error) {
+	_, err := m.GetAppByID(ctx, fn.AppID)
+	if err != nil {
+		return nil, err
+	}
+
+	for _, f := range m.Fns {
+		if f.ID == fn.ID ||
+			(f.AppID == fn.AppID &&
+				f.Name == fn.Name) {
+			return nil, models.ErrFnsExists
+		}
+	}
+	cl := fn.Clone()
+	cl.ID = id.New().String()
+	cl.CreatedAt = common.DateTime(time.Now())
+	cl.UpdatedAt = cl.CreatedAt
+	err = fn.Validate()
+	if err != nil {
+		return nil, err
+	}
+
+	m.Fns = append(m.Fns, cl)
+
+	return cl.Clone(), nil
+}
+
+func (m *mock) UpdateFn(ctx context.Context, fn *models.Fn) (*models.Fn, error) {
+	// update if exists
+	for _, f := range m.Fns {
+		if f.ID == fn.ID {
+			clone := f.Clone()
+			clone.Update(fn)
+			err := clone.Validate()
+			if err != nil {
+				return nil, err
+			}
+			*f = *clone
+			return f, nil
+		}
+	}
+
+	return nil, models.ErrFnsNotFound
+}
+
+type sortF []*models.Fn
+
+func (s sortF) Len() int           { return len(s) }
+func (s sortF) Less(i, j int) bool { return strings.Compare(s[i].Name, s[j].Name) < 0 }
+func (s sortF) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
+
+func (m *mock) GetFns(ctx context.Context, filter *models.FnFilter) ([]*models.Fn, error) {
+	// sort them all first for cursoring (this is for testing, n is small & mock is not concurrent..)
+	sort.Sort(sortF(m.Fns))
+
+	funcs := []*models.Fn{}
+
+	for _, f := range m.Fns {
+		if filter.PerPage > 0 && len(funcs) == filter.PerPage {
+			break
+		}
+
+		if strings.Compare(filter.Cursor, f.Name) < 0 &&
+			(filter.AppID == "" || filter.AppID == f.AppID) &&
+			(filter.Name == "" || filter.Name == f.Name) {
+			funcs = append(funcs, f)
+		}
+
+	}
+	return funcs, nil
+}
+
+func (m *mock) GetFnByID(ctx context.Context, fnID string) (*models.Fn, error) {
+	for _, f := range m.Fns {
+		if f.ID == fnID {
+			return f, nil
+		}
+	}
+
+	return nil, models.ErrFnsNotFound
+}
+
+func (m *mock) RemoveFn(ctx context.Context, fnID string) error {
+	for i, f := range m.Fns {
+		if f.ID == fnID {
+			m.Fns = append(m.Fns[:i], m.Fns[i+1:]...)
+			var newTriggers []*models.Trigger
+			for _, t := range m.Triggers {
+				if t.FnID != f.ID {
+					newTriggers = append(newTriggers, t)
+				}
+			}
+
+			m.Triggers = newTriggers
+			return nil
+		}
+	}
+
+	return models.ErrFnsNotFound
+}
+
+func (m *mock) InsertTrigger(ctx context.Context, trigger *models.Trigger) (*models.Trigger, error) {
+	_, err := m.GetAppByID(ctx, trigger.AppID)
+	if err != nil {
+		return nil, err
+	}
+	fn, err := m.GetFnByID(ctx, trigger.FnID)
+	if err != nil {
+		return nil, err
+	}
+
+	if fn.AppID != trigger.AppID {
+		return nil, models.ErrTriggerFnIDNotSameApp
+	}
+
+	for _, t := range m.Triggers {
+		if t.ID == trigger.ID ||
+			(t.AppID == trigger.AppID &&
+				t.FnID == trigger.FnID &&
+				t.Name == trigger.Name) {
+			return nil, models.ErrTriggerExists
+		}
+	}
+
+	cl := trigger.Clone()
+	cl.CreatedAt = common.DateTime(time.Now())
+	cl.UpdatedAt = cl.CreatedAt
+	cl.ID = id.New().String()
+
+	err = trigger.Validate()
+	if err != nil {
+		return nil, err
+	}
+	m.Triggers = append(m.Triggers, cl)
+	return cl.Clone(), nil
+}
+
+func (m *mock) UpdateTrigger(ctx context.Context, trigger *models.Trigger) (*models.Trigger, error) {
+	for _, t := range m.Triggers {
+		if t.ID == trigger.ID {
+			cl := t.Clone()
+			cl.Update(trigger)
+			err := cl.Validate()
+			if err != nil {
+				return nil, err
+			}
+			*t = *cl
+			return cl.Clone(), nil
+		}
+	}
+	return nil, models.ErrTriggerNotFound
+}
+
+func (m *mock) GetTrigger(ctx context.Context, appId, fnId, triggerName string) (*models.Trigger, error) {
+	for _, t := range m.Triggers {
+		if t.AppID == appId && t.FnID == fnId && t.Name == triggerName {
+			return t.Clone(), nil
+		}
+	}
+	return nil, models.ErrTriggerNotFound
+}
+
+func (m *mock) GetTriggerByID(ctx context.Context, triggerId string) (*models.Trigger, error) {
+	for _, t := range m.Triggers {
+		if t.ID == triggerId {
+			return t.Clone(), nil
+		}
+	}
+	return nil, models.ErrTriggerNotFound
+}
+
+type sortT []*models.Trigger
+
+func (s sortT) Len() int           { return len(s) }
+func (s sortT) Less(i, j int) bool { return strings.Compare(s[i].ID, s[j].ID) < 0 }
+func (s sortT) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
+
+func (m *mock) GetTriggers(ctx context.Context, filter *models.TriggerFilter) ([]*models.Trigger, error) {
+	sort.Sort(sortT(m.Triggers))
+
+	res := []*models.Trigger{}
+	for _, t := range m.Triggers {
+		if filter.PerPage > 0 && len(res) == filter.PerPage {
+			break
+		}
+
+		matched := true
+		if filter.Cursor != "" && t.ID <= filter.Cursor {
+			matched = false
+		}
+
+		if t.AppID != filter.AppID {
+			matched = false
+		}
+		if filter.FnID != "" && filter.FnID != t.FnID {
+			matched = false
+		}
+
+		if filter.Name != "" && filter.Name != t.Name {
+			matched = false
+		}
+
+		if matched {
+			res = append(res, t)
+		}
+	}
+	return res, nil
+}
+
+func (m *mock) RemoveTrigger(ctx context.Context, triggerID string) error {
+	for i, t := range m.Triggers {
+		if t.ID == triggerID {
+			m.Triggers = append(m.Triggers[:i], m.Triggers[i+1:]...)
+			return nil
+		}
+	}
+	return models.ErrTriggerNotFound
 }
 
 func (m *mock) Close() error {

api/datastore/mock_test.go

@@ -11,5 +11,5 @@ func TestDatastore(t *testing.T) {
 	f := func(t *testing.T) models.Datastore {
 		return NewMock()
 	}
-	datastoretest.Test(t, f)
+	datastoretest.RunAllTests(t, f, datastoretest.NewBasicResourceProvider())
 }

api/datastore/sql/migrations/16_add_fns.go

@@ -0,0 +1,41 @@
+package migrations
+
+import (
+	"context"
+
+	"github.com/fnproject/fn/api/datastore/sql/migratex"
+	"github.com/jmoiron/sqlx"
+)
+
+func up16(ctx context.Context, tx *sqlx.Tx) error {
+	createQuery := `CREATE TABLE IF NOT EXISTS fns (
+	id varchar(256) NOT NULL PRIMARY KEY,
+	name varchar(256) NOT NULL,
+	app_id varchar(256) NOT NULL,
+	image varchar(256) NOT NULL,
+	format varchar(16) NOT NULL,
+	memory int NOT NULL,
+	timeout int NOT NULL,
+	idle_timeout int NOT NULL,
+	config text NOT NULL,
+	annotations text NOT NULL,
+	created_at varchar(256) NOT NULL,
+	updated_at varchar(256) NOT NULL,
+    CONSTRAINT name_app_id_unique UNIQUE (app_id, name)
+);`
+	_, err := tx.ExecContext(ctx, createQuery)
+	return err
+}
+
+func down16(ctx context.Context, tx *sqlx.Tx) error {
+	_, err := tx.ExecContext(ctx, "DROP TABLE fns;")
+	return err
+}
+
+func init() {
+	Migrations = append(Migrations, &migratex.MigFields{
+		VersionFunc: vfunc(16),
+		UpFunc:      up16,
+		DownFunc:    down16,
+	})
+}

api/datastore/sql/sql.go

@@ -20,6 +20,7 @@ import (
 
 	"github.com/fnproject/fn/api/datastore"
 	"github.com/fnproject/fn/api/datastore/sql/dbhelper"
+	"github.com/fnproject/fn/api/id"
 	"github.com/fnproject/fn/api/logs"
 	"github.com/sirupsen/logrus"
 )
@@ -77,11 +78,40 @@ var tables = [...]string{`CREATE TABLE IF NOT EXISTS routes (
 	PRIMARY KEY (id)
 );`,
 
+	`CREATE TABLE IF NOT EXISTS triggers (
+	id varchar(256) NOT NULL PRIMARY KEY,
+	name varchar(256) NOT NULL,
+	app_id varchar(256) NOT NULL,
+	fn_id varchar(256) NOT NULL,
+	created_at varchar(256) NOT NULL,
+	updated_at varchar(256) NOT NULL,
+	type varchar(256) NOT NULL,
+	source varchar(256) NOT NULL,
+    annotations text NOT NULL,
+    CONSTRAINT name_app_id_fn_id_unique UNIQUE (app_id, fn_id,name)
+);`,
+
 	`CREATE TABLE IF NOT EXISTS logs (
 	id varchar(256) NOT NULL PRIMARY KEY,
 	app_id varchar(256) NOT NULL,
 	log text NOT NULL
 );`,
+
+	`CREATE TABLE IF NOT EXISTS fns (
+	id varchar(256) NOT NULL PRIMARY KEY,
+	name varchar(256) NOT NULL,
+	app_id varchar(256) NOT NULL,
+	image varchar(256) NOT NULL,
+	format varchar(16) NOT NULL,
+	memory int NOT NULL,
+	timeout int NOT NULL,
+	idle_timeout int NOT NULL,
+	config text NOT NULL,
+	annotations text NOT NULL,
+	created_at varchar(256) NOT NULL,
+	updated_at varchar(256) NOT NULL,
+    CONSTRAINT name_app_id_unique UNIQUE (app_id, name)
+);`,
 }
 
 const (
@@ -90,6 +120,12 @@ const (
 	appIDSelector     = `SELECT id, name, config, annotations, syslog_url, created_at, updated_at FROM apps WHERE id=?`
 	ensureAppSelector = `SELECT id FROM apps WHERE name=?`
 
+	fnSelector   = `SELECT id,name,app_id,image,format,memory,timeout,idle_timeout,config,annotations,created_at,updated_at FROM fns`
+	fnIDSelector = fnSelector + ` WHERE id=?`
+
+	triggerSelector   = `SELECT id,name,app_id,fn_id,type,source,annotations,created_at,updated_at FROM triggers`
+	triggerIDSelector = triggerSelector + ` WHERE id=?`
+
 	EnvDBPingMaxRetries = "FN_DS_DB_PING_MAX_RETRIES"
 )
 
@@ -301,6 +337,18 @@ func (ds *SQLStore) clear() error {
 			return err
 		}
 
+		query = tx.Rebind(`DELETE FROM triggers`)
+		_, err = tx.Exec(query)
+		if err != nil {
+			return err
+		}
+
+		query = tx.Rebind(`DELETE FROM fns`)
+		_, err = tx.Exec(query)
+		if err != nil {
+			return err
+		}
+
 		query = tx.Rebind(`DELETE FROM logs`)
 		_, err = tx.Exec(query)
 		return err
@@ -323,7 +371,17 @@ func (ds *SQLStore) GetAppID(ctx context.Context, appName string) (string, error
 	return app.ID, nil
 }
 
-func (ds *SQLStore) InsertApp(ctx context.Context, app *models.App) (*models.App, error) {
+func (ds *SQLStore) InsertApp(ctx context.Context, newApp *models.App) (*models.App, error) {
+	app := newApp.Clone()
+	app.CreatedAt = common.DateTime(time.Now())
+	app.UpdatedAt = app.CreatedAt
+	app.ID = id.New().String()
+
+	if app.Config == nil {
+		// keeps the json from being nil
+		app.Config = map[string]string{}
+	}
+
 	query := ds.db.Rebind(`INSERT INTO apps (
 		id,
 		name,
@@ -355,6 +413,7 @@ func (ds *SQLStore) InsertApp(ctx context.Context, app *models.App) (*models.App
 
 func (ds *SQLStore) UpdateApp(ctx context.Context, newapp *models.App) (*models.App, error) {
 	var app models.App
+
 	err := ds.Tx(func(tx *sqlx.Tx) error {
 		// NOTE: must query whole object since we're returning app, Update logic
 		// must only modify modifiable fields (as seen here). need to fix brittle..
@@ -370,6 +429,9 @@ func (ds *SQLStore) UpdateApp(ctx context.Context, newapp *models.App) (*models.
 			return err
 		}
 
+		if newapp.Name != "" && app.Name != newapp.Name {
+			return models.ErrAppsNameImmutable
+		}
 		app.Update(newapp)
 		err = app.Validate()
 		if err != nil {
@@ -416,6 +478,8 @@ func (ds *SQLStore) RemoveApp(ctx context.Context, appID string) error {
 			`DELETE FROM logs WHERE app_id=?`,
 			`DELETE FROM calls WHERE app_id=?`,
 			`DELETE FROM routes WHERE app_id=?`,
+			`DELETE FROM fns WHERE app_id=?`,
+			`DELETE FROM triggers WHERE app_id=?`,
 		}
 		for _, stmt := range deletes {
 			_, err := tx.ExecContext(ctx, tx.Rebind(stmt), appID)
@@ -445,15 +509,17 @@ func (ds *SQLStore) GetAppByID(ctx context.Context, appID string) (*models.App,
 
 // GetApps retrieves an array of apps according to a specific filter.
 func (ds *SQLStore) GetApps(ctx context.Context, filter *models.AppFilter) ([]*models.App, error) {
-	res := []*models.App{}
+	var res []*models.App
+
 	if filter.NameIn != nil && len(filter.NameIn) == 0 { // this basically makes sure it doesn't return ALL apps
 		return res, nil
 	}
+
 	query, args, err := buildFilterAppQuery(filter)
 	if err != nil {
 		return nil, err
 	}
-	query = ds.db.Rebind(fmt.Sprintf("SELECT DISTINCT name, config, annotations, syslog_url, created_at, updated_at FROM apps %s", query))
+	query = ds.db.Rebind(fmt.Sprintf("SELECT DISTINCT id, name, config, annotations, syslog_url, created_at, updated_at FROM apps %s", query))
 	rows, err := ds.db.QueryxContext(ctx, query, args...)
 	if err != nil {
 		return nil, err
@@ -478,7 +544,11 @@ func (ds *SQLStore) GetApps(ctx context.Context, filter *models.AppFilter) ([]*m
 	return res, nil
 }
 
-func (ds *SQLStore) InsertRoute(ctx context.Context, route *models.Route) (*models.Route, error) {
+func (ds *SQLStore) InsertRoute(ctx context.Context, newRoute *models.Route) (*models.Route, error) {
+	route := newRoute.Clone()
+	route.CreatedAt = common.DateTime(time.Now())
+	route.UpdatedAt = route.CreatedAt
+
 	err := ds.Tx(func(tx *sqlx.Tx) error {
 		query := tx.Rebind(`SELECT 1 FROM apps WHERE id=?`)
 		r := tx.QueryRowContext(ctx, query, route.AppID)
@@ -658,6 +728,7 @@ func (ds *SQLStore) GetRoutesByApp(ctx context.Context, appID string, filter *mo
 		}
 		res = append(res, &route)
 	}
+
 	if err := rows.Err(); err != nil {
 		if err == sql.ErrNoRows {
 			return res, nil // no error for empty list
@@ -667,6 +738,190 @@ func (ds *SQLStore) GetRoutesByApp(ctx context.Context, appID string, filter *mo
 	return res, nil
 }
 
+func (ds *SQLStore) InsertFn(ctx context.Context, newFn *models.Fn) (*models.Fn, error) {
+	fn := newFn.Clone()
+	fn.ID = id.New().String()
+	fn.CreatedAt = common.DateTime(time.Now())
+	fn.UpdatedAt = fn.CreatedAt
+
+	err := newFn.Validate()
+	if err != nil {
+		return nil, err
+	}
+
+	err = ds.Tx(func(tx *sqlx.Tx) error {
+
+		query := tx.Rebind(`SELECT 1 FROM apps WHERE id=?`)
+		r := tx.QueryRowContext(ctx, query, fn.AppID)
+		if err := r.Scan(new(int)); err != nil {
+			if err == sql.ErrNoRows {
+				return models.ErrAppsNotFound
+			}
+		}
+
+		query = tx.Rebind(`INSERT INTO fns (
+				id,
+				name,
+				app_id,
+				image,
+				format,
+				memory,
+				timeout,
+				idle_timeout,
+				config,
+				annotations,
+				created_at,
+				updated_at
+			)
+			VALUES (
+				:id,
+				:name,
+				:app_id,
+				:image,
+				:format,
+				:memory,
+				:timeout,
+				:idle_timeout,
+				:config,
+				:annotations,
+				:created_at,
+				:updated_at
+			);`)
+
+		_, err = tx.NamedExecContext(ctx, query, fn)
+		return err
+	})
+
+	if err != nil {
+		if ds.helper.IsDuplicateKeyError(err) {
+			return nil, models.ErrFnsExists
+		}
+		return nil, err
+	}
+	return fn, nil
+}
+
+func (ds *SQLStore) UpdateFn(ctx context.Context, fn *models.Fn) (*models.Fn, error) {
+	err := ds.Tx(func(tx *sqlx.Tx) error {
+
+		var dst models.Fn
+		query := tx.Rebind(fnIDSelector)
+		row := tx.QueryRowxContext(ctx, query, fn.ID)
+		err := row.StructScan(&dst)
+
+		if err == sql.ErrNoRows {
+			return models.ErrFnsNotFound
+		} else if err != nil {
+			return err
+		}
+
+		dst.Update(fn)
+		err = dst.Validate()
+		if err != nil {
+			return err
+		}
+		fn = &dst // set for query & to return
+
+		query = tx.Rebind(`UPDATE fns SET
+				name = :name,
+				image = :image,
+				format = :format,
+				memory = :memory,
+				timeout = :timeout,
+				idle_timeout = :idle_timeout,
+				config = :config,
+				annotations = :annotations,
+				updated_at = :updated_at
+			    WHERE id=:id;`)
+
+		_, err = tx.NamedExecContext(ctx, query, fn)
+		return err
+	})
+
+	if err != nil {
+		return nil, err
+	}
+	return fn, nil
+}
+
+func (ds *SQLStore) GetFns(ctx context.Context, filter *models.FnFilter) ([]*models.Fn, error) {
+	var res []*models.Fn // for json empty list
+	if filter == nil {
+		filter = new(models.FnFilter)
+	}
+
+	filterQuery, args := buildFilterFnQuery(filter)
+
+	query := fmt.Sprintf("%s %s", fnSelector, filterQuery)
+	query = ds.db.Rebind(query)
+	rows, err := ds.db.QueryxContext(ctx, query, args...)
+	if err != nil {
+		if err == sql.ErrNoRows {
+			return res, nil // no error for empty list
+		}
+		return nil, err
+	}
+	defer rows.Close()
+
+	for rows.Next() {
+		var fn models.Fn
+		err := rows.StructScan(&fn)
+		if err != nil {
+			continue
+		}
+		res = append(res, &fn)
+	}
+	if err := rows.Err(); err != nil {
+		if err == sql.ErrNoRows {
+			return res, nil // no error for empty list
+		}
+	}
+
+	return res, nil
+}
+
+func (ds *SQLStore) GetFnByID(ctx context.Context, fnID string) (*models.Fn, error) {
+	query := ds.db.Rebind(fmt.Sprintf("%s WHERE id=?", fnSelector))
+	row := ds.db.QueryRowxContext(ctx, query, fnID)
+
+	var fn models.Fn
+	err := row.StructScan(&fn)
+	if err == sql.ErrNoRows {
+		return nil, models.ErrFnsNotFound
+	} else if err != nil {
+		return nil, err
+	}
+	return &fn, nil
+}
+
+func (ds *SQLStore) RemoveFn(ctx context.Context, fnID string) error {
+
+	return ds.Tx(func(tx *sqlx.Tx) error {
+
+		query := tx.Rebind(fmt.Sprintf("%s WHERE id=?", fnSelector))
+		row := tx.QueryRowxContext(ctx, query, fnID)
+
+		var fn models.Fn
+		err := row.StructScan(&fn)
+		if err == sql.ErrNoRows {
+			return models.ErrFnsNotFound
+		}
+
+		query = tx.Rebind(`DELETE FROM triggers WHERE fn_id=?`)
+		_, err = tx.ExecContext(ctx, query, fnID)
+
+		if err != nil {
+			return err
+		}
+
+		query = tx.Rebind(`DELETE FROM fns WHERE id=?`)
+		_, err = tx.ExecContext(ctx, query, fnID)
+
+		return err
+	})
+
+}
+
 func (ds *SQLStore) Tx(f func(*sqlx.Tx) error) error {
 	tx, err := ds.db.Beginx()
 	if err != nil {
@@ -791,20 +1046,9 @@ func buildFilterRouteQuery(filter *models.RouteFilter) (string, []interface{}) {
 	var b bytes.Buffer
 	var args []interface{}
 
-	where := func(colOp, val string) {
-		if val != "" {
-			args = append(args, val)
-			if len(args) == 1 {
-				fmt.Fprintf(&b, `WHERE %s`, colOp)
-			} else {
-				fmt.Fprintf(&b, ` AND %s`, colOp)
-			}
-		}
-	}
-
-	where("app_id=? ", filter.AppID)
-	where("image=?", filter.Image)
-	where("path>?", filter.Cursor)
+	args = where(&b, args, "app_id=? ", filter.AppID)
+	args = where(&b, args, "image=?", filter.Image)
+	args = where(&b, args, "path>?", filter.Cursor)
 	// where("path LIKE ?%", filter.PathPrefix) TODO needs escaping
 
 	fmt.Fprintf(&b, ` ORDER BY path ASC`) // TODO assert this is indexed
@@ -822,32 +1066,9 @@ func buildFilterAppQuery(filter *models.AppFilter) (string, []interface{}, error
 
 	var b bytes.Buffer
 
-	// todo: this same thing is in several places in here, DRY it up across this file
-	where := func(colOp, val interface{}) {
-		if val == nil {
-			return
-		}
-		switch v := val.(type) {
-		case string:
-			if v == "" {
-				return
-			}
-		case []string:
-			if len(v) == 0 {
-				return
-			}
-		}
-		args = append(args, val)
-		if len(args) == 1 {
-			fmt.Fprintf(&b, `WHERE %s`, colOp)
-		} else {
-			fmt.Fprintf(&b, ` AND %s`, colOp)
-		}
-	}
-
 	// where("name LIKE ?%", filter.Name) // TODO needs escaping?
-	where("name>?", filter.Cursor)
-	where("name IN (?)", filter.NameIn)
+	args = where(&b, args, "name>?", filter.Cursor)
+	args = where(&b, args, "name IN (?)", filter.NameIn)
 
 	fmt.Fprintf(&b, ` ORDER BY name ASC`) // TODO assert this is indexed
 	fmt.Fprintf(&b, ` LIMIT ?`)
@@ -865,26 +1086,15 @@ func buildFilterCallQuery(filter *models.CallFilter) (string, []interface{}) {
 	var b bytes.Buffer
 	var args []interface{}
 
-	where := func(colOp, val string) {
-		if val != "" {
-			args = append(args, val)
-			if len(args) == 1 {
-				fmt.Fprintf(&b, `WHERE %s?`, colOp)
-			} else {
-				fmt.Fprintf(&b, ` AND %s?`, colOp)
-			}
-		}
-	}
-
-	where("id<", filter.Cursor)
+	args = where(&b, args, "id<?", filter.Cursor)
 	if !time.Time(filter.ToTime).IsZero() {
-		where("created_at<", filter.ToTime.String())
+		args = where(&b, args, "created_at<?", filter.ToTime.String())
 	}
 	if !time.Time(filter.FromTime).IsZero() {
-		where("created_at>", filter.FromTime.String())
+		args = where(&b, args, "created_at>?", filter.FromTime.String())
 	}
-	where("app_id=", filter.AppID)
-	where("path=", filter.Path)
+	args = where(&b, args, "app_id=?", filter.AppID)
+	args = where(&b, args, "path=?", filter.Path)
 
 	fmt.Fprintf(&b, ` ORDER BY id DESC`) // TODO assert this is indexed
 	fmt.Fprintf(&b, ` LIMIT ?`)
@@ -893,9 +1103,276 @@ func buildFilterCallQuery(filter *models.CallFilter) (string, []interface{}) {
 	return b.String(), args
 }
 
-// GetDatabase returns the underlying sqlx database implementation
-func (ds *SQLStore) GetDatabase() *sqlx.DB {
-	return ds.db
+func buildFilterFnQuery(filter *models.FnFilter) (string, []interface{}) {
+	if filter == nil {
+		return "", nil
+	}
+	var b bytes.Buffer
+	var args []interface{}
+
+	// where(fmt.Sprintf("image LIKE '%s%%'"), filter.Image) // TODO needs escaping, prob we want prefix query to ignore tags
+	args = where(&b, args, "app_id=? ", filter.AppID)
+	args = where(&b, args, "name>?", filter.Cursor)
+
+	fmt.Fprintf(&b, ` ORDER BY name ASC`)
+	if filter.PerPage > 0 {
+		fmt.Fprintf(&b, ` LIMIT ?`)
+		args = append(args, filter.PerPage)
+	}
+	return b.String(), args
+}
+
+func where(b *bytes.Buffer, args []interface{}, colOp string, val interface{}) []interface{} {
+	if val == nil {
+		return args
+	}
+	switch v := val.(type) {
+	case string:
+		if v == "" {
+			return args
+		}
+	case []string:
+		if len(v) == 0 {
+			return args
+		}
+	}
+	args = append(args, val)
+	if len(args) == 1 {
+		fmt.Fprintf(b, `WHERE %s`, colOp)
+	} else {
+		fmt.Fprintf(b, ` AND %s`, colOp)
+	}
+	return args
+}
+
+func (ds *SQLStore) InsertTrigger(ctx context.Context, newTrigger *models.Trigger) (*models.Trigger, error) {
+
+	trigger := newTrigger.Clone()
+
+	trigger.CreatedAt = common.DateTime(time.Now())
+	trigger.UpdatedAt = trigger.CreatedAt
+	trigger.ID = id.New().String()
+
+	err := trigger.Validate()
+	if err != nil {
+		return nil, err
+	}
+
+	err = ds.Tx(func(tx *sqlx.Tx) error {
+		query := tx.Rebind(`SELECT 1 FROM apps WHERE id=?`)
+		r := tx.QueryRowContext(ctx, query, trigger.AppID)
+		if err := r.Scan(new(int)); err != nil {
+			if err == sql.ErrNoRows {
+				return models.ErrAppsNotFound
+			}
+		}
+
+		query = tx.Rebind(`SELECT app_id FROM fns WHERE id=?`)
+		r = tx.QueryRowContext(ctx, query, trigger.FnID)
+		var app_id string
+		if err := r.Scan(&app_id); err != nil {
+			if err == sql.ErrNoRows {
+				return models.ErrFnsNotFound
+			}
+		}
+		if app_id != trigger.AppID {
+			return models.ErrTriggerFnIDNotSameApp
+		}
+
+		query = tx.Rebind(`INSERT INTO triggers (
+			id,
+			name,
+		  	app_id,
+			fn_id,
+			created_at,
+			updated_at,
+			type,
+		  	source,
+		  	annotations
+		)
+		VALUES (
+			:id,
+			:name,
+			:app_id,
+			:fn_id,
+			:created_at,
+			:updated_at,
+			:type,
+			:source,
+			:annotations
+		);`)
+
+		_, err = tx.NamedExecContext(ctx, query, trigger)
+		return err
+	})
+
+	if err != nil {
+		if ds.helper.IsDuplicateKeyError(err) {
+			return nil, models.ErrTriggerExists
+		}
+		return nil, err
+	}
+
+	return trigger, err
+}
+
+func (ds *SQLStore) UpdateTrigger(ctx context.Context, trigger *models.Trigger) (*models.Trigger, error) {
+	err := ds.Tx(func(tx *sqlx.Tx) error {
+
+		var dst models.Trigger
+		query := tx.Rebind(triggerIDSelector)
+		row := tx.QueryRowxContext(ctx, query, trigger.ID)
+		err := row.StructScan(&dst)
+
+		if err != nil && err != sql.ErrNoRows {
+			return err
+		} else if err == sql.ErrNoRows {
+			return models.ErrTriggerNotFound
+		}
+
+		dst.Update(trigger)
+		err = dst.Validate()
+		if err != nil {
+			return err
+		}
+		trigger = &dst // set for query & to return
+
+		query = tx.Rebind(`UPDATE triggers SET
+			name = :name,
+			fn_id = :fn_id,
+			updated_at = :updated_at,
+			source = :source,
+			annotations = :annotations
+			WHERE id = :id;`)
+		_, err = tx.NamedExecContext(ctx, query, trigger)
+		return err
+	})
+
+	if err != nil {
+		return nil, err
+	}
+	return trigger, nil
+}
+
+func (ds *SQLStore) GetTrigger(ctx context.Context, appId, fnId, triggerName string) (*models.Trigger, error) {
+	var trigger models.Trigger
+	query := ds.db.Rebind(fmt.Sprintf("%s WHERE name=? AND app_id=? AND fn_id=?", fnSelector))
+	row := ds.db.QueryRowxContext(ctx, query, triggerName, appId, fnId)
+
+	err := row.StructScan(&trigger)
+	if err == sql.ErrNoRows {
+		return nil, models.ErrTriggerNotFound
+	}
+	if err != nil {
+		return nil, err
+	}
+
+	return &trigger, nil
+}
+
+func (ds *SQLStore) RemoveTrigger(ctx context.Context, triggerId string) error {
+	query := ds.db.Rebind(`DELETE FROM triggers WHERE id = ?;`)
+	res, err := ds.db.ExecContext(ctx, query, triggerId)
+	if err != nil {
+		return err
+	}
+
+	n, err := res.RowsAffected()
+	if err != nil {
+		return err
+	}
+
+	if n == 0 {
+		return models.ErrTriggerNotFound
+	}
+
+	return nil
+}
+
+func (ds *SQLStore) GetTriggerByID(ctx context.Context, triggerID string) (*models.Trigger, error) {
+	var trigger models.Trigger
+	query := ds.db.Rebind(triggerIDSelector)
+	row := ds.db.QueryRowxContext(ctx, query, triggerID)
+
+	err := row.StructScan(&trigger)
+	if err == sql.ErrNoRows {
+		return nil, models.ErrTriggerNotFound
+	}
+	if err != nil {
+		return nil, err
+	}
+
+	return &trigger, nil
+}
+
+func buildFilterTriggerQuery(filter *models.TriggerFilter) (string, []interface{}) {
+	var b bytes.Buffer
+	var args []interface{}
+
+	fmt.Fprintf(&b, `app_id = ?`)
+	args = append(args, filter.AppID)
+
+	if filter.FnID != "" {
+		fmt.Fprintf(&b, ` AND fn_id = ?`)
+		args = append(args, filter.FnID)
+	}
+
+	if filter.Name != "" {
+		fmt.Fprintf(&b, ` AND name = ?`)
+		args = append(args, filter.Name)
+	}
+
+	if filter.Cursor != "" {
+		fmt.Fprintf(&b, ` AND id > ?`)
+		args = append(args, filter.Cursor)
+	}
+
+	fmt.Fprintf(&b, ` ORDER BY name ASC`)
+
+	if filter.PerPage != 0 {
+		fmt.Fprintf(&b, ` LIMIT ?`)
+		args = append(args, filter.PerPage)
+	}
+
+	return b.String(), args
+}
+
+func (ds *SQLStore) GetTriggers(ctx context.Context, filter *models.TriggerFilter) ([]*models.Trigger, error) {
+	var res []*models.Trigger // for json empty list
+	if filter == nil {
+		filter = new(models.TriggerFilter)
+	}
+
+	filterQuery, args := buildFilterTriggerQuery(filter)
+
+	logrus.Error(filterQuery, args)
+
+	query := fmt.Sprintf("%s WHERE %s", triggerSelector, filterQuery)
+	query = ds.db.Rebind(query)
+	rows, err := ds.db.QueryxContext(ctx, query, args...)
+	if err != nil {
+		if err == sql.ErrNoRows {
+			return res, nil // no error for empty list
+		}
+		return nil, err
+	}
+	defer rows.Close()
+
+	for rows.Next() {
+		var trigger models.Trigger
+		err := rows.StructScan(&trigger)
+		if err != nil {
+			continue
+		}
+		res = append(res, &trigger)
+	}
+	if err := rows.Err(); err != nil {
+		if err == sql.ErrNoRows {
+			return res, nil // no error for empty list
+		}
+	}
+
+	return res, nil
 }
 
 // Close closes the database, releasing any open resources.

api/datastore/sql/sql_test.go

@@ -65,7 +65,9 @@ func TestDatastore(t *testing.T) {
 		ds := f(t)
 		return datastoreutil.NewValidator(ds)
 	}
-	datastoretest.Test(t, f2)
+	t.Run(u.Scheme, func(t *testing.T) {
+		datastoretest.RunAllTests(t, f2, datastoretest.NewBasicResourceProvider())
+	})
 
 	// also logs
 	logstoretest.Test(t, f(t))
@@ -96,7 +98,7 @@ func TestDatastore(t *testing.T) {
 		}
 
 		// test fresh w/o migrations
-		datastoretest.Test(t, f2)
+		t.Run(u.Scheme, func(t *testing.T) { datastoretest.RunAllTests(t, f2, datastoretest.NewBasicResourceProvider()) })
 
 		// also test sql implements logstore
 		logstoretest.Test(t, f(t))
@@ -119,7 +121,7 @@ func TestDatastore(t *testing.T) {
 		}
 
 		// test that migrations work & things work with them
-		datastoretest.Test(t, f2)
+		t.Run(u.Scheme, func(t *testing.T) { datastoretest.RunAllTests(t, f2, datastoretest.NewBasicResourceProvider()) })
 
 		// also test sql implements logstore
 		logstoretest.Test(t, f(t))