use existing dashboards path

as discussed on the pr conversations, we are now using existing
dashboards path and most of the existing methods.

- GET /api/v1/dashboards?source=<src>
- POST /api/v1/dashboards/{id}/reset
Update works same it just bypass the lock/unlock check

Behavior of seeding remains intact

docs/api/openapi.yml

@@ -2223,6 +2223,8 @@ components:
           type: boolean
         org_id:
           type: string
+        source:
+          type: string
         updatedAt:
           format: date-time
           type: string

ee/modules/dashboard/impldashboard/module.go

@@ -138,6 +138,11 @@ func (module *module) Delete(ctx context.Context, orgID valuer.UUID, id valuer.U
 		return err
 	}
 
+	// Do not delete system dashboard, we can only reset system dashbard to default.
+	if dashboard.Source != "" {
+		return errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "cannot delete system dashboard with source %s, use reset instead", dashboard.Source)
+	}
+
 	if dashboard.Locked {
 		return errors.New(errors.TypeInvalidInput, errors.CodeInvalidInput, "dashboard is locked, please unlock the dashboard to be delete it")
 	}
@@ -213,6 +218,14 @@ func (module *module) Update(ctx context.Context, orgID valuer.UUID, id valuer.U
 	return module.pkgDashboardModule.Update(ctx, orgID, id, updatedBy, data, diff)
 }
 
+func (module *module) Reset(ctx context.Context, orgID valuer.UUID, source dashboardtypes.Source, updatedBy string) (*dashboardtypes.Dashboard, error) {
+	return module.pkgDashboardModule.Reset(ctx, orgID, source, updatedBy)
+}
+
+func (module *module) SetDefaultConfig(ctx context.Context, orgID valuer.UUID) error {
+	return module.pkgDashboardModule.SetDefaultConfig(ctx, orgID)
+}
+
 func (module *module) LockUnlock(ctx context.Context, orgID valuer.UUID, id valuer.UUID, updatedBy string, isAdmin bool, lock bool) error {
 	return module.pkgDashboardModule.LockUnlock(ctx, orgID, id, updatedBy, isAdmin, lock)
 }

frontend/src/api/generated/services/sigNoz.schemas.ts

@@ -4186,6 +4186,10 @@ export interface DashboardtypesDashboardDTO {
 	 * @type string
 	 */
 	org_id?: string;
+	/**
+	 * @type string
+	 */
+	source?: string;
 	/**
 	 * @type string
 	 * @format date-time

pkg/modules/dashboard/dashboard.go

@@ -42,6 +42,11 @@ type Module interface {
 
 	Update(ctx context.Context, orgID valuer.UUID, id valuer.UUID, updatedBy string, data dashboardtypes.UpdatableDashboard, diff int) (*dashboardtypes.Dashboard, error)
 
+	// Reset puts back default value for system dashboard.
+	Reset(ctx context.Context, orgID valuer.UUID, source dashboardtypes.Source, updatedBy string) (*dashboardtypes.Dashboard, error)
+	
+	SetDefaultConfig(ctx context.Context, orgID valuer.UUID) error
+
 	LockUnlock(ctx context.Context, orgID valuer.UUID, id valuer.UUID, updatedBy string, isAdmin bool, lock bool) error
 
 	Delete(ctx context.Context, orgID valuer.UUID, id valuer.UUID) error
@@ -71,4 +76,6 @@ type Handler interface {
 	LockUnlock(http.ResponseWriter, *http.Request)
 
 	Delete(http.ResponseWriter, *http.Request)
+
+	Reset(http.ResponseWriter, *http.Request)
 }

pkg/modules/dashboard/impldashboard/handler.go

@@ -185,6 +185,49 @@ func (handler *handler) LockUnlock(rw http.ResponseWriter, r *http.Request) {
 
 }
 
+// Reset only resets system dashboard (source != "") to default values.
+func (handler *handler) Reset(rw http.ResponseWriter, r *http.Request) {
+	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
+	defer cancel()
+
+	claims, err := authtypes.ClaimsFromContext(ctx)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	orgID, err := valuer.NewUUID(claims.OrgID)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	id, err := valuer.NewUUID(mux.Vars(r)["id"])
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	dashboard, err := handler.module.Get(ctx, orgID, id)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	if dashboard.Source == "" {
+		render.Error(rw, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "dashboard with id %s is not a system dashboard, reset is unsupported", id))
+		return
+	}
+
+	resetDashboard, err := handler.module.Reset(ctx, orgID, dashboardtypes.Source(dashboard.Source), claims.Email)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
+
+	render.Success(rw, http.StatusOK, resetDashboard)
+}
+
 func (handler *handler) Delete(rw http.ResponseWriter, r *http.Request) {
 	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
 	defer cancel()

pkg/modules/dashboard/impldashboard/module.go

@@ -38,7 +38,7 @@ func NewModule(store dashboardtypes.Store, settings factory.ProviderSettings, an
 }
 
 func (module *module) Create(ctx context.Context, orgID valuer.UUID, createdBy string, creator valuer.UUID, postableDashboard dashboardtypes.PostableDashboard) (*dashboardtypes.Dashboard, error) {
-	dashboard, err := dashboardtypes.NewDashboard(orgID, createdBy, postableDashboard)
+	dashboard, err := dashboardtypes.NewDashboard(orgID, createdBy, postableDashboard, "")
 	if err != nil {
 		return nil, err
 	}
@@ -66,6 +66,15 @@ func (module *module) Get(ctx context.Context, orgID valuer.UUID, id valuer.UUID
 	return dashboardtypes.NewDashboardFromStorableDashboard(storableDashboard), nil
 }
 
+func (module *module) GetBySource(ctx context.Context, orgID valuer.UUID, source dashboardtypes.Source) (*dashboardtypes.Dashboard, error) {
+	storableDashboard, err := module.store.GetBySource(ctx, orgID, string(source))
+	if err != nil {
+		return nil, err
+	}
+
+	return dashboardtypes.NewDashboardFromStorableDashboard(storableDashboard), nil
+}
+
 func (module *module) List(ctx context.Context, orgID valuer.UUID) ([]*dashboardtypes.Dashboard, error) {
 	storableDashboards, err := module.store.List(ctx, orgID)
 	if err != nil {
@@ -81,9 +90,12 @@ func (module *module) Update(ctx context.Context, orgID valuer.UUID, id valuer.U
 		return nil, err
 	}
 
-	err = dashboard.Update(ctx, updatableDashboard, updatedBy, diff)
-	if err != nil {
-		return nil, err
+	if dashboard.Source != "" {
+		dashboard.OverwriteData(updatableDashboard, updatedBy)
+	} else {
+		if err := dashboard.Update(ctx, updatableDashboard, updatedBy, diff); err != nil {
+			return nil, err
+		}
 	}
 
 	storableDashboard, err := dashboardtypes.NewStorableDashboardFromDashboard(dashboard)
@@ -91,14 +103,84 @@ func (module *module) Update(ctx context.Context, orgID valuer.UUID, id valuer.U
 		return nil, err
 	}
 
-	err = module.store.Update(ctx, orgID, storableDashboard)
-	if err != nil {
+	if err := module.store.Update(ctx, orgID, storableDashboard); err != nil {
 		return nil, err
 	}
 
 	return dashboard, nil
 }
 
+func (module *module) Reset(ctx context.Context, orgID valuer.UUID, source dashboardtypes.Source, updatedBy string) (*dashboardtypes.Dashboard, error) {
+	defaultDashboard, err := dashboardtypes.NewDefaultSystemDashboard(orgID, source)
+	if err != nil {
+		return nil, err
+	}
+
+	existing, err := module.GetBySource(ctx, orgID, source)
+	if err != nil && !errors.Ast(err, errors.TypeNotFound) {
+		return nil, err
+	}
+
+	if existing == nil {
+		defaultDashboard.CreatedBy = updatedBy
+		defaultDashboard.UpdatedBy = updatedBy
+
+		storable, err := dashboardtypes.NewStorableDashboardFromDashboard(defaultDashboard)
+		if err != nil {
+			return nil, err
+		}
+		if err := module.store.Create(ctx, storable); err != nil {
+			return nil, err
+		}
+		return defaultDashboard, nil
+	}
+
+	existing.OverwriteData(defaultDashboard.Data, updatedBy)
+
+	storable, err := dashboardtypes.NewStorableDashboardFromDashboard(existing)
+	if err != nil {
+		return nil, err
+	}
+	if err := module.store.Update(ctx, orgID, storable); err != nil {
+		return nil, err
+	}
+
+	return existing, nil
+}
+
+// SetDefaultConfig seeds default values for system dashboards for newly created orgs.
+func (module *module) SetDefaultConfig(ctx context.Context, orgID valuer.UUID) error {
+	for _, source := range dashboardtypes.SystemSources {
+		existing, err := module.GetBySource(ctx, orgID, source)
+		if err != nil && !errors.Ast(err, errors.TypeNotFound) {
+			return err
+		}
+		if existing != nil {
+			continue
+		}
+
+		dashboard, err := dashboardtypes.NewDefaultSystemDashboard(orgID, source)
+		if err != nil {
+			// No defaults set for the source skipping will pupulate in  default overview followup pr.
+			if errors.Ast(err, errors.TypeInvalidInput) {
+				continue
+			}
+			return err
+		}
+
+		storable, err := dashboardtypes.NewStorableDashboardFromDashboard(dashboard)
+		if err != nil {
+			return err
+		}
+
+		if err := module.store.Create(ctx, storable); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
 func (module *module) LockUnlock(ctx context.Context, orgID valuer.UUID, id valuer.UUID, updatedBy string, isAdmin bool, lock bool) error {
 	dashboard, err := module.Get(ctx, orgID, id)
 	if err != nil {
@@ -128,6 +210,11 @@ func (module *module) Delete(ctx context.Context, orgID valuer.UUID, id valuer.U
 		return err
 	}
 
+	// Can not delete system dashboard.
+	if dashboard.Source != "" {
+		return errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "cannot delete system dashboard with source %s, use reset instead", dashboard.Source)
+	}
+
 	if dashboard.Locked {
 		return errors.New(errors.TypeInvalidInput, errors.CodeInvalidInput, "dashboard is locked, please unlock the dashboard to be delete it")
 	}

pkg/modules/dashboard/impldashboard/store.go

@@ -21,7 +21,7 @@ func NewStore(sqlstore sqlstore.SQLStore) dashboardtypes.Store {
 func (store *store) Create(ctx context.Context, storabledashboard *dashboardtypes.StorableDashboard) error {
 	_, err := store.
 		sqlstore.
-		BunDB().
+		BunDBCtx(ctx).
 		NewInsert().
 		Model(storabledashboard).
 		Exec(ctx)
@@ -63,6 +63,23 @@ func (store *store) Get(ctx context.Context, orgID valuer.UUID, id valuer.UUID)
 	return storableDashboard, nil
 }
 
+func (store *store) GetBySource(ctx context.Context, orgID valuer.UUID, source string) (*dashboardtypes.StorableDashboard, error) {
+	storableDashboard := new(dashboardtypes.StorableDashboard)
+	err := store.
+		sqlstore.
+		BunDBCtx(ctx).
+		NewSelect().
+		Model(storableDashboard).
+		Where("org_id = ?", orgID).
+		Where("source = ?", source).
+		Scan(ctx)
+	if err != nil {
+		return nil, store.sqlstore.WrapNotFoundErrf(err, errors.CodeNotFound, "system dashboard with source %s doesn't exist", source)
+	}
+
+	return storableDashboard, nil
+}
+
 func (store *store) GetPublic(ctx context.Context, dashboardID string) (*dashboardtypes.StorablePublicDashboard, error) {
 	storable := new(dashboardtypes.StorablePublicDashboard)
 	err := store.
@@ -124,6 +141,7 @@ func (store *store) List(ctx context.Context, orgID valuer.UUID) ([]*dashboardty
 		NewSelect().
 		Model(&storableDashboards).
 		Where("org_id = ?", orgID).
+		Where("source = ?", "").
 		Scan(ctx)
 	if err != nil {
 		return nil, err
@@ -153,7 +171,7 @@ func (store *store) ListPublic(ctx context.Context, orgID valuer.UUID) ([]*dashb
 func (store *store) Update(ctx context.Context, orgID valuer.UUID, storableDashboard *dashboardtypes.StorableDashboard) error {
 	_, err := store.
 		sqlstore.
-		BunDB().
+		BunDBCtx(ctx).
 		NewUpdate().
 		Model(storableDashboard).
 		WherePK().

pkg/modules/organization/implorganization/setter.go

@@ -4,6 +4,7 @@ import (
 	"context"
 
 	"github.com/SigNoz/signoz/pkg/alertmanager"
+	"github.com/SigNoz/signoz/pkg/modules/dashboard"
 	"github.com/SigNoz/signoz/pkg/modules/organization"
 	"github.com/SigNoz/signoz/pkg/modules/quickfilter"
 	"github.com/SigNoz/signoz/pkg/types"
@@ -14,10 +15,11 @@ type setter struct {
 	store        types.OrganizationStore
 	alertmanager alertmanager.Alertmanager
 	quickfilter  quickfilter.Module
+	dashboard    dashboard.Module
 }
 
-func NewSetter(store types.OrganizationStore, alertmanager alertmanager.Alertmanager, quickfilter quickfilter.Module) organization.Setter {
-	return &setter{store: store, alertmanager: alertmanager, quickfilter: quickfilter}
+func NewSetter(store types.OrganizationStore, alertmanager alertmanager.Alertmanager, quickfilter quickfilter.Module, dashboard dashboard.Module) organization.Setter {
+	return &setter{store: store, alertmanager: alertmanager, quickfilter: quickfilter, dashboard: dashboard}
 }
 
 func (module *setter) Create(ctx context.Context, organization *types.Organization, createManagedRoles func(context.Context, valuer.UUID) error) error {
@@ -33,6 +35,10 @@ func (module *setter) Create(ctx context.Context, organization *types.Organizati
 		return err
 	}
 
+	if err := module.dashboard.SetDefaultConfig(ctx, organization.ID); err != nil {
+		return err
+	}
+
 	if err := createManagedRoles(ctx, organization.ID); err != nil {
 		return err
 	}

pkg/query-service/app/http_handler.go

@@ -511,6 +511,7 @@ func (aH *APIHandler) RegisterRoutes(router *mux.Router, am *middleware.AuthZ) {
 	router.HandleFunc("/api/v1/dashboards/{id}", am.EditAccess(aH.Signoz.Handlers.Dashboard.Update)).Methods(http.MethodPut)
 	router.HandleFunc("/api/v1/dashboards/{id}", am.EditAccess(aH.Signoz.Handlers.Dashboard.Delete)).Methods(http.MethodDelete)
 	router.HandleFunc("/api/v1/dashboards/{id}/lock", am.EditAccess(aH.Signoz.Handlers.Dashboard.LockUnlock)).Methods(http.MethodPut)
+	router.HandleFunc("/api/v1/dashboards/{id}/reset", am.AdminAccess(aH.Signoz.Handlers.Dashboard.Reset)).Methods(http.MethodPost)
 	router.HandleFunc("/api/v2/variables/query", am.ViewAccess(aH.queryDashboardVarsV2)).Methods(http.MethodPost)
 
 	router.HandleFunc("/api/v1/explorer/views", am.ViewAccess(aH.Signoz.Handlers.SavedView.List)).Methods(http.MethodGet)

pkg/signoz/module.go

@@ -106,7 +106,7 @@ func NewModules(
 	fl flagger.Flagger,
 ) Modules {
 	quickfilter := implquickfilter.NewModule(implquickfilter.NewStore(sqlstore))
-	orgSetter := implorganization.NewSetter(implorganization.NewStore(sqlstore), alertmanager, quickfilter)
+	orgSetter := implorganization.NewSetter(implorganization.NewStore(sqlstore), alertmanager, quickfilter, dashboard)
 	userSetter := impluser.NewSetter(impluser.NewStore(sqlstore, providerSettings), tokenizer, emailing, providerSettings, orgSetter, authz, analytics, config.User, userRoleStore, userGetter)
 	ruleStore := sqlrulestore.NewRuleStore(sqlstore, queryParser, providerSettings)
 

pkg/signoz/provider.go

@@ -196,6 +196,7 @@ func NewSQLMigrationProviderFactories(
 		sqlmigration.NewDropUserDeletedAtFactory(sqlstore, sqlschema),
 		sqlmigration.NewMigrateAWSAllRegionsFactory(sqlstore),
 		sqlmigration.NewAddServiceAccountManagedRoleTransactionsFactory(sqlstore),
+		sqlmigration.NewAddSystemDashboardFactory(sqlstore, sqlschema),
 	)
 }
 

pkg/sqlmigration/078_add_system_dashboard.go

@@ -0,0 +1,124 @@
+package sqlmigration
+
+import (
+	"context"
+
+	"github.com/uptrace/bun"
+	"github.com/uptrace/bun/migrate"
+
+	"github.com/SigNoz/signoz/pkg/factory"
+	"github.com/SigNoz/signoz/pkg/sqlschema"
+	"github.com/SigNoz/signoz/pkg/sqlstore"
+)
+
+type addSystemDashboard struct {
+	sqlstore  sqlstore.SQLStore
+	sqlschema sqlschema.SQLSchema
+}
+
+func NewAddSystemDashboardFactory(sqlstore sqlstore.SQLStore, sqlschema sqlschema.SQLSchema) factory.ProviderFactory[SQLMigration, Config] {
+	return factory.NewProviderFactory(factory.MustNewName("add_system_dashboard"), func(ctx context.Context, ps factory.ProviderSettings, c Config) (SQLMigration, error) {
+		return &addSystemDashboard{sqlstore: sqlstore, sqlschema: sqlschema}, nil
+	})
+}
+
+func (migration *addSystemDashboard) Register(migrations *migrate.Migrations) error {
+	if err := migrations.Register(migration.Up, migration.Down); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (migration *addSystemDashboard) Up(ctx context.Context, db *bun.DB) error {
+	// Disable foreign keys for the duration of the migration.
+	// pattern is used in migration 029_drop_groups.
+	if err := migration.sqlstore.Dialect().ToggleForeignKeyConstraint(ctx, db, false); err != nil {
+		return err
+	}
+
+	tx, err := db.BeginTx(ctx, nil)
+	if err != nil {
+		return err
+	}
+
+	defer func() {
+		_ = tx.Rollback()
+	}()
+
+	table, uniqueConstraints, err := migration.sqlschema.GetTable(ctx, "dashboard")
+	if err != nil {
+		return err
+	}
+
+	column := &sqlschema.Column{
+		Name:     sqlschema.ColumnName("source"),
+		DataType: sqlschema.DataTypeText,
+		Nullable: false,
+	}
+
+	sqls := migration.sqlschema.Operator().AddColumn(table, uniqueConstraints, column, "")
+	for _, sql := range sqls {
+		if _, err := tx.ExecContext(ctx, string(sql)); err != nil {
+			return err
+		}
+	}
+
+	// We activate this part of code once we add default value for the overview page.
+	// add source column to the dashboard table.
+	// do not iterate over orgs.
+	// var orgIDs []string
+	// if err := tx.NewSelect().Model((*types.Organization)(nil)).Column("id").Scan(ctx, &orgIDs); err != nil {
+	// 	return err
+	// }
+	//
+	// for _, rawOrgID := range orgIDs {
+	// 	orgID, err := valuer.NewUUID(rawOrgID)
+	// 	if err != nil {
+	// 		return err
+	// 	}
+	//
+	// 	for _, source := range dashboardtypes.SystemSources {
+	// 		count, err := tx.NewSelect().
+	// 			Model((*dashboardtypes.StorableDashboard)(nil)).
+	// 			Where("org_id = ?", orgID).
+	// 			Where("source = ?", string(source)).
+	// 			Count(ctx)
+	// 		if err != nil {
+	// 			return err
+	// 		}
+	// 		if count > 0 {
+	// 			continue
+	// 		}
+	//
+	// 		dashboard, err := dashboardtypes.NewDefaultSystemDashboard(orgID, source)
+	// 		if err != nil {
+	// 			return err
+	// 		}
+	//
+	// 		storable, err := dashboardtypes.NewStorableDashboardFromDashboard(dashboard)
+	// 		if err != nil {
+	// 			return err
+	// 		}
+	//
+	// 		if _, err := tx.NewInsert().Model(storable).Exec(ctx); err != nil {
+	// 			return err
+	// 		}
+	// 	}
+	// }
+
+	if err := tx.Commit(); err != nil {
+		return err
+	}
+
+	// Re-enable foreign keys.
+	if err := migration.sqlstore.Dialect().ToggleForeignKeyConstraint(ctx, db, true); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (migration *addSystemDashboard) Down(context.Context, *bun.DB) error {
+	return nil
+}

pkg/types/dashboardtypes/dashboard.go

@@ -30,6 +30,7 @@ type StorableDashboard struct {
 	Data   StorableDashboardData `bun:"data,type:text,notnull"`
 	Locked bool                  `bun:"locked,notnull,default:false"`
 	OrgID  valuer.UUID           `bun:"org_id,notnull"`
+	Source string                `bun:"source,type:text,notnull"`
 }
 
 type Dashboard struct {
@@ -40,6 +41,7 @@ type Dashboard struct {
 	Data   StorableDashboardData `json:"data"`
 	Locked bool                  `json:"locked"`
 	OrgID  valuer.UUID           `json:"org_id"`
+	Source string                `json:"source"`
 }
 
 type LockUnlockDashboard struct {
@@ -79,10 +81,11 @@ func NewStorableDashboardFromDashboard(dashboard *Dashboard) (*StorableDashboard
 		OrgID:  dashboard.OrgID,
 		Data:   dashboard.Data,
 		Locked: dashboard.Locked,
+		Source: dashboard.Source,
 	}, nil
 }
 
-func NewDashboard(orgID valuer.UUID, createdBy string, storableDashboardData StorableDashboardData) (*Dashboard, error) {
+func NewDashboard(orgID valuer.UUID, createdBy string, data StorableDashboardData, source Source) (*Dashboard, error) {
 	currentTime := time.Now()
 
 	return &Dashboard{
@@ -96,8 +99,8 @@ func NewDashboard(orgID valuer.UUID, createdBy string, storableDashboardData Sto
 			UpdatedBy: createdBy,
 		},
 		OrgID:  orgID,
-		Data:   storableDashboardData,
-		Locked: false,
+		Data:   data,
+		Source: string(source),
 	}, nil
 }
 
@@ -115,6 +118,7 @@ func NewDashboardFromStorableDashboard(storableDashboard *StorableDashboard) *Da
 		OrgID:  storableDashboard.OrgID,
 		Data:   storableDashboard.Data,
 		Locked: storableDashboard.Locked,
+		Source: storableDashboard.Source,
 	}
 }
 
@@ -147,6 +151,7 @@ func NewGettableDashboardFromDashboard(dashboard *Dashboard) (*GettableDashboard
 		OrgID:         dashboard.OrgID,
 		Data:          dashboard.Data,
 		Locked:        dashboard.Locked,
+		Source:        dashboard.Source,
 	}, nil
 }
 
@@ -278,6 +283,12 @@ func (dashboard *Dashboard) Update(ctx context.Context, updatableDashboard Updat
 	return nil
 }
 
+func (dashboard *Dashboard) OverwriteData(updatableDashboard UpdatableDashboard, updatedBy string) {
+	dashboard.UpdatedBy = updatedBy
+	dashboard.UpdatedAt = time.Now()
+	dashboard.Data = updatableDashboard
+}
+
 func (dashboard *Dashboard) CanLockUnlock(isAdmin bool, updatedBy string) error {
 	if dashboard.CreatedBy != updatedBy && !isAdmin {
 		return errors.Newf(errors.TypeForbidden, errors.CodeForbidden, "you are not authorized to lock/unlock this dashboard")

pkg/types/dashboardtypes/dashboard_test.go

@@ -66,7 +66,7 @@ func TestCanUpdate_MultipleDeletions_ByDiff(t *testing.T) {
 			initial := StorableDashboardData{
 				"widgets": makeTestWidgets("a", "b", "c"),
 			}
-			d, err := NewDashboard(orgID, "tester", initial)
+			d, err := NewDashboard(orgID, "tester", initial, "")
 			assert.NoError(t, err)
 
 			updated := StorableDashboardData{

pkg/types/dashboardtypes/defaults.go

@@ -0,0 +1,17 @@
+package dashboardtypes
+
+import (
+	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/valuer"
+)
+
+type Source string
+
+var SystemSources = []Source{}
+
+// This will be fixed with upcoming pr of dashboard default value.
+// No issue with migration or org creation; if reset endpoint is called we get a 400
+// invalid_input response and no action is taken on dashboard.data.
+func NewDefaultSystemDashboard(orgID valuer.UUID, source Source) (*Dashboard, error) {
+	return nil, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "no defaults registered for system dashboard source %s", source)
+}

pkg/types/dashboardtypes/store.go

@@ -13,6 +13,8 @@ type Store interface {
 
 	Get(context.Context, valuer.UUID, valuer.UUID) (*StorableDashboard, error)
 
+	GetBySource(context.Context, valuer.UUID, string) (*StorableDashboard, error)
+
 	GetPublic(context.Context, string) (*StorablePublicDashboard, error)
 
 	GetDashboardByOrgsAndPublicID(context.Context, []string, string) (*StorableDashboard, error)