Migrating from 0.1 to 0.2

core, err := corego.New(&corego.Config{
	Auth: &auth.Config{
		Secret:       os.Getenv("AUTH_SECRET"),
		TokenExpiry:  60,
		DatabaseName: "users",
	},
})
if err != nil {
	panic(err)
}
defer core.Close()

r := gin.Default()
// ... routes ...
r.Run(":8080")

core, err := corego.New(&corego.Config{
	Auth: &corego.AuthOptions{
		Service: auth.Config{SessionTTL: 24 * time.Hour}, // optional; default 7 days
	},
})
if err != nil {
	log.Fatal(err)
}
app := core.Server() // /auth/* routes already mounted
// ... routes ...
if err := core.Run(); err != nil { // serves on PORT, graceful shutdown, closes everything
	log.Fatal(err)
}

e := env.LoadEnv()
if e.MONGODB_CONNECTION_URL != nil {
	fmt.Println(*e.MONGODB_CONNECTION_URL)
}
apiKey := os.Getenv("API_KEY") // worked because LoadEnv set it

e, err := env.Load()
if err != nil {
	log.Fatal(err)
}
if e.MongoURL != "" {
	fmt.Println(e.MongoURL)
}
apiKey := e.GetOrDefault("API_KEY", "")

id, err := core.Mongo.InsertOne("tasks", task) // id is a hex string
docs, err := core.Mongo.Find("tasks", bson.M{"done": false})
for _, doc := range docs {
	fmt.Println(doc["title"])
}

id, err := core.Mongo.InsertOne(ctx, "tasks", task)
if err != nil {
	return err
}
taskID := id.(bson.ObjectID) // .Hex() for the old string form

var tasks []Task
if err := core.Mongo.Find(ctx, "tasks", bson.M{"done": false}, &tasks); err != nil {
	return err
}
for _, t := range tasks {
	fmt.Println(t.Title, taskID.Hex())
}

rows, err := core.Postgres.Query("SELECT id, title FROM tasks WHERE done = $1", false)

rows, err := core.Postgres.QueryMaps(ctx, "SELECT id, title FROM tasks WHERE done = $1", false)

// or straight into a struct with `db` tags:
tasks, err := database.QueryAll[Task](ctx, core.Postgres,
	"SELECT id, title FROM tasks WHERE done = $1", false)

user, token, err := core.Auth.Signup(auth.SignupRequest{
	Email:    "ada@example.com",
	Password: "analytical-engine",
	Custom:   map[string]any{"name": "Ada"},
})
userID, err := core.Auth.ValidateToken(token)

out, err := core.Auth.SignUp(ctx, auth.SignUpInput{
	Name:     "Ada",
	Email:    "ada@example.com",
	Password: "analytical-engine",
})
if errors.Is(err, auth.ErrUserAlreadyExists) {
	return web.Conflict("email already registered")
}
if err != nil {
	return err
}
session, user, err := core.Auth.GetSession(ctx, out.SessionToken)

api := r.Group("/api")
api.Use(core.Auth.Middleware())
api.GET("/dashboard", func(c *gin.Context) {
	userID, _ := c.Get("userID")
	c.JSON(200, gin.H{"user_id": userID})
})

api := core.Server().Group("/api", core.RequireAuth())
api.Get("/dashboard", func(c *web.Context) error {
	user := auth.MustUser(c)
	return c.JSON(http.StatusOK, map[string]string{"user_id": user.ID, "name": user.Name})
})

// requireSession adapts the auth middleware (net/http) to Gin. Failed
// checks are answered by the middleware itself (401/403 JSON), exactly
// like core.RequireAuth.
func requireSession(h *authhttp.Handlers) gin.HandlerFunc {
	return func(c *gin.Context) {
		passed := false
		h.Middleware(http.HandlerFunc(func(_ http.ResponseWriter, r *http.Request) {
			passed = true
			c.Request = r // carries the user for auth.MustUser
		})).ServeHTTP(c.Writer, c.Request)
		if !passed {
			c.Abort()
			return
		}
		c.Next()
	}
}

func main() {
	core, err := corego.New(&corego.Config{Auth: &corego.AuthOptions{}})
	if err != nil {
		log.Fatal(err)
	}
	defer core.Close()

	r := gin.Default()
	r.Any("/auth/*path", gin.WrapH(core.Server())) // the 17 auth routes

	api := r.Group("/api", requireSession(core.AuthHandlers()))
	api.GET("/dashboard", func(c *gin.Context) {
		user := auth.MustUser(c.Request.Context())
		c.JSON(http.StatusOK, gin.H{"user_id": user.ID})
	})

	if err := r.Run(":" + core.Env.Port); err != nil {
		log.Print(err)
	}
}

package main

import (
	"context"
	"errors"
	"log"
	"os"
	"strings"
	"time"

	"go.mongodb.org/mongo-driver/v2/bson"

	"github.com/berkkaradalan/CoreGo/auth"
	"github.com/berkkaradalan/CoreGo/auth/mongostore"
	"github.com/berkkaradalan/CoreGo/database"
)

// legacyUser is a document of the 0.1 users collection.
type legacyUser struct {
	ID        bson.ObjectID  `bson:"_id"`
	Email     string         `bson:"email"`
	Password  string         `bson:"password"` // bcrypt hash, reusable as is
	Custom    map[string]any `bson:"custom"`
	CreatedAt time.Time      `bson:"created_at"`
}

func main() {
	ctx := context.Background()
	db, err := database.NewMongoDB(database.MongoConfig{
		URL:      os.Getenv("MONGODB_CONNECTION_URL"),
		Database: "corego", // where 0.1 stored its data unless configured otherwise
	})
	if err != nil {
		log.Fatal(err)
	}
	defer db.Close()

	store, err := mongostore.NewStore(db, mongostore.Options{})
	if err != nil {
		log.Fatal(err)
	}
	if err := store.EnsureIndexes(ctx); err != nil {
		log.Fatal(err)
	}

	var legacy []legacyUser
	if err := db.Find(ctx, "users", nil, &legacy); err != nil { // 0.1 Config.DatabaseName
		log.Fatal(err)
	}

	for _, old := range legacy {
		email := strings.ToLower(strings.TrimSpace(old.Email))
		name, _ := old.Custom["name"].(string)
		if name == "" {
			name, _, _ = strings.Cut(email, "@")
		}

		user := &auth.User{ID: old.ID.Hex(), Name: name, Email: email, CreatedAt: old.CreatedAt}
		err := store.CreateUser(ctx, user)
		if errors.Is(err, auth.ErrDuplicate) {
			existing, getErr := store.GetUserByEmail(ctx, email)
			if getErr != nil {
				log.Fatal(getErr)
			}
			if existing.ID != user.ID {
				log.Printf("skipping %s: registered again after the upgrade", user.ID)
				continue
			}
		} else if err != nil {
			log.Fatal(err)
		}

		account := &auth.Account{
			UserID:            user.ID,
			Provider:          auth.CredentialProvider,
			ProviderAccountID: email,
			Password:          old.Password,
		}
		if err := store.CreateAccount(ctx, account); err != nil && !errors.Is(err, auth.ErrDuplicate) {
			log.Fatal(err)
		}
	}
	log.Printf("migrated %d users", len(legacy))
}