Skip to content

SigNoz is an open-source, OpenTelemetry-native observability platform for your team and their AI agents. Get logs, metrics, and traces in one tool with features like APM, distributed tracing, log management, infra monitoring, etc. Combined with SigNoz MCP and a native AI teammate (in SigNoz Cloud) it helps you build more resilient apps.

5.3 KB
Raw Blame
package sqlmigration

import (
	"context"
	"database/sql"
	"time"

	"github.com/SigNoz/signoz/pkg/factory"
	"github.com/SigNoz/signoz/pkg/sqlstore"
	"github.com/SigNoz/signoz/pkg/types"
	"github.com/uptrace/bun"
	"github.com/uptrace/bun/migrate"
)

type migratePATToFactorAPIKey struct {
	store sqlstore.SQLStore
}

func NewMigratePATToFactorAPIKey(sqlstore sqlstore.SQLStore) factory.ProviderFactory[SQLMigration, Config] {
	return factory.NewProviderFactory(factory.MustNewName("migrate_pat_to_factor_api_key"), func(ctx context.Context, ps factory.ProviderSettings, c Config) (SQLMigration, error) {
		return newMigratePATToFactorAPIKey(ctx, ps, c, sqlstore)
	})
}

func newMigratePATToFactorAPIKey(_ context.Context, _ factory.ProviderSettings, _ Config, store sqlstore.SQLStore) (SQLMigration, error) {
	return &migratePATToFactorAPIKey{store: store}, nil
}

func (migration *migratePATToFactorAPIKey) Register(migrations *migrate.Migrations) error {
	if err := migrations.Register(migration.Up, migration.Down); err != nil {
		return err
	}

	return nil
}

type existingPersonalAccessToken33 struct {
	bun.BaseModel `bun:"table:personal_access_token"`

	types.Identifiable
	types.TimeAuditable
	OrgID           string `json:"orgId" bun:"org_id,type:text,notnull"`
	Role            string `json:"role" bun:"role,type:text,notnull,default:'ADMIN'"`
	UserID          string `json:"userId" bun:"user_id,type:text,notnull"`
	Token           string `json:"token" bun:"token,type:text,notnull,unique"`
	Name            string `json:"name" bun:"name,type:text,notnull"`
	ExpiresAt       int64  `json:"expiresAt" bun:"expires_at,notnull,default:0"`
	LastUsed        int64  `json:"lastUsed" bun:"last_used,notnull,default:0"`
	Revoked         bool   `json:"revoked" bun:"revoked,notnull,default:false"`
	UpdatedByUserID string `json:"updatedByUserId" bun:"updated_by_user_id,type:text,notnull,default:''"`
}

// we are removing the connection with org,
// the reason we are doing this is the api keys should just have
// one foreign key, we don't want a dangling state where, an API key
// belongs to one org and some user which doesn't belong to that org.
// so going ahead with directly attaching it to user will help dangling states.
type newFactorAPIKey33 struct {
	bun.BaseModel `bun:"table:factor_api_key"`

	types.Identifiable
	CreatedAt time.Time `bun:"created_at,notnull,nullzero,type:timestamptz" json:"createdAt"`
	UpdatedAt time.Time `bun:"updated_at,notnull,nullzero,type:timestamptz" json:"updatedAt"`
	CreatedBy string    `bun:"created_by,notnull" json:"createdBy"`
	UpdatedBy string    `bun:"updated_by,notnull" json:"updatedBy"`
	Token     string    `json:"token" bun:"token,type:text,notnull,unique"`
	Role      string    `json:"role" bun:"role,type:text,notnull"`
	Name      string    `json:"name" bun:"name,type:text,notnull"`
	ExpiresAt time.Time `json:"expiresAt" bun:"expires_at,notnull,nullzero,type:timestamptz"`
	LastUsed  time.Time `json:"lastUsed" bun:"last_used,notnull,nullzero,type:timestamptz"`
	Revoked   bool      `json:"revoked" bun:"revoked,notnull,default:false"`
	UserID    string    `json:"userId" bun:"user_id,type:text,notnull"`
}

func (migration *migratePATToFactorAPIKey) Up(ctx context.Context, db *bun.DB) error {
	tx, err := db.BeginTx(ctx, nil)
	if err != nil {
		return err
	}

	defer func() {
		_ = tx.Rollback()
	}()

	err = migration.
		store.
		Dialect().
		RenameTableAndModifyModel(ctx, tx, new(existingPersonalAccessToken33), new(newFactorAPIKey33), []string{UserReferenceNoCascade}, func(ctx context.Context) error {
			existingAPIKeys := make([]*existingPersonalAccessToken33, 0)
			err = tx.
				NewSelect().
				Model(&existingAPIKeys).
				Scan(ctx)
			if err != nil && err != sql.ErrNoRows {
				return err
			}

			if err == nil && len(existingAPIKeys) > 0 {
				newAPIKeys, err := migration.
					CopyOldPatToFactorAPIKey(ctx, tx, existingAPIKeys)
				if err != nil {
					return err
				}
				_, err = tx.
					NewInsert().
					Model(&newAPIKeys).
					Exec(ctx)
				if err != nil {
					return err
				}
			}
			return nil
		})
	if err != nil {
		return err
	}

	err = tx.Commit()
	if err != nil {
		return err
	}

	return nil
}

func (migration *migratePATToFactorAPIKey) Down(ctx context.Context, db *bun.DB) error {
	return nil
}

func (migration *migratePATToFactorAPIKey) CopyOldPatToFactorAPIKey(ctx context.Context, tx bun.IDB, existingAPIKeys []*existingPersonalAccessToken33) ([]*newFactorAPIKey33, error) {
	newAPIKeys := make([]*newFactorAPIKey33, 0)
	for _, apiKey := range existingAPIKeys {

		if apiKey.CreatedAt.IsZero() {
			apiKey.CreatedAt = time.Now()
		}
		if apiKey.UpdatedAt.IsZero() {
			apiKey.UpdatedAt = time.Now()
		}

		// convert expiresAt and lastUsed to time.Time
		expiresAt := time.Unix(apiKey.ExpiresAt, 0)
		lastUsed := time.Unix(apiKey.LastUsed, 0)
		if apiKey.LastUsed == 0 {
			lastUsed = apiKey.CreatedAt
		}

		newAPIKeys = append(newAPIKeys, &newFactorAPIKey33{
			Identifiable: apiKey.Identifiable,
			CreatedAt:    apiKey.CreatedAt,
			UpdatedAt:    apiKey.UpdatedAt,
			CreatedBy:    apiKey.UserID,
			UpdatedBy:    apiKey.UpdatedByUserID,
			Token:        apiKey.Token,
			Role:         apiKey.Role,
			Name:         apiKey.Name,
			ExpiresAt:    expiresAt,
			LastUsed:     lastUsed,
			Revoked:      apiKey.Revoked,
			UserID:       apiKey.UserID,
		})
	}
	return newAPIKeys, nil
}