Skip to content

πŸ“š The open-source, offline-first Notion, Obsidian & Confluence alternative. Advanced Markdown, multi-tenant teams, OIDC/SSO, and local S3 backups. Deploy in one command.

New backend layers structure (reduce code size, switch from sql.DB to sqlx.DB)

Smaug6739cc3f8c97dbb1
diff --git a/backend/app/app.go b/backend/app/app.go
index b0c9ee02..8930759c 100644
--- a/backend/app/app.go
+++ b/backend/app/app.go
@@ -4,10 +4,10 @@ import (
"alexandrie/pkg/snowflake"
"alexandrie/repositories"
"alexandrie/services"
- "database/sql"
"log"
_ "github.com/go-sql-driver/mysql"
+ "github.com/jmoiron/sqlx"
"github.com/minio/minio-go/v7"
"github.com/wneessen/go-mail"
)
@@ -33,7 +33,7 @@ type Config struct {
}
type App struct {
- DB *sql.DB
+ DB *sqlx.DB
Snowflake *snowflake.Snowflake
Config Config
MinioClient *minio.Client
diff --git a/backend/app/database.go b/backend/app/database.go
index d9f9e0fc..fe762f74 100644
--- a/backend/app/database.go
+++ b/backend/app/database.go
@@ -1,13 +1,14 @@
package app
import (
- "database/sql"
"fmt"
"os"
"time"
+
+ "github.com/jmoiron/sqlx"
)
-func DBConnection(config Config, multiStatements bool) (conecction *sql.DB) {
+func DBConnection(config Config, multiStatements bool) *sqlx.DB {
Driver := config.Database.Driver
User := os.Getenv("DATABASE_USER")
Password := os.Getenv("DATABASE_PASSWORD")
@@ -33,13 +34,14 @@ func DBConnection(config Config, multiStatements bool) (conecction *sql.DB) {
multiStatementsConfig = "?multiStatements=true"
}
- conection, err := sql.Open(Driver, User+":"+Password+"@tcp("+Host+":"+Port+")/"+Database+multiStatementsConfig)
-
+ dsn := User + ":" + Password + "@tcp(" + Host + ":" + Port + ")/" + Database + multiStatementsConfig
+ db, err := sqlx.Connect(Driver, dsn)
if err != nil {
panic(fmt.Sprintf("failed to connect to database: %v", err))
}
- conection.SetConnMaxLifetime(time.Minute * 3)
- conection.SetMaxOpenConns(10)
- conection.SetMaxIdleConns(10)
- return conection
+
+ db.SetConnMaxLifetime(time.Minute * 3)
+ db.SetMaxOpenConns(10)
+ db.SetMaxIdleConns(10)
+ return db
}
diff --git a/backend/app/migrations.go b/backend/app/migrations.go
index 9a038011..671977ce 100644
--- a/backend/app/migrations.go
+++ b/backend/app/migrations.go
@@ -23,7 +23,7 @@ func Migrate(config *Config) {
panic(fmt.Sprintf("failed to ping database: %v", err))
}
- driver, err := mysql.WithInstance(db, &mysql.Config{
+ driver, err := mysql.WithInstance(db.DB, &mysql.Config{
MigrationsTable: "schema_migrations",
})
if err != nil {
diff --git a/backend/controllers/oidc.controller.go b/backend/controllers/oidc.controller.go
index 7999280e..f22c1ee3 100644
--- a/backend/controllers/oidc.controller.go
+++ b/backend/controllers/oidc.controller.go
@@ -19,7 +19,6 @@ type OIDCController interface {
GetUserProviders(c *gin.Context) (int, any)
}
-// NewOIDCController creates a new OIDC controller
func NewOIDCController(app *app.App) OIDCController {
return &Controller{
app: app,
diff --git a/backend/go.mod b/backend/go.mod
index 74899985..684eb9fd 100644
--- a/backend/go.mod
+++ b/backend/go.mod
@@ -3,6 +3,7 @@ module alexandrie
go 1.24.0
require (
+ github.com/jmoiron/sqlx v1.4.0
github.com/microcosm-cc/bluemonday v1.0.27
github.com/wneessen/go-mail v0.7.2
)
diff --git a/backend/go.sum b/backend/go.sum
index 4a8de390..cbf97676 100644
--- a/backend/go.sum
+++ b/backend/go.sum
@@ -59,6 +59,7 @@ github.com/go-playground/universal-translator v0.18.1 h1:Bcnm0ZwsGyWbCzImXv+pAJn
github.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91TpwSH2VMlDf28Uj24BCp08ZFTUY=
github.com/go-playground/validator/v10 v10.30.1 h1:f3zDSN/zOma+w6+1Wswgd9fLkdwy06ntQJp0BBvFG0w=
github.com/go-playground/validator/v10 v10.30.1/go.mod h1:oSuBIQzuJxL//3MelwSLD5hc2Tu889bF0Idm9Dg26cM=
+github.com/go-sql-driver/mysql v1.8.1/go.mod h1:wEBSXgmK//2ZFJyE+qWnIsVGmvmEKlqwuVSjsCm7DZg=
github.com/go-sql-driver/mysql v1.9.3 h1:U/N249h2WzJ3Ukj8SowVFjdtZKfu9vlLZxjPXV1aweo=
github.com/go-sql-driver/mysql v1.9.3/go.mod h1:qn46aNg1333BRMNU69Lq93t8du/dwxI64Gl8i5p1WMU=
github.com/goccy/go-json v0.10.5 h1:Fq85nIqj+gXn/S5ahsiTlK3TmC85qgirsdTP/+DeaC4=
@@ -78,6 +79,8 @@ github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
github.com/gorilla/css v1.0.1 h1:ntNaBIghp6JmvWnxbZKANoLyuXTPZ4cAMlo6RyhlbO8=
github.com/gorilla/css v1.0.1/go.mod h1:BvnYkspnSzMmwRK+b8/xgNPLiIuNZr6vbZBTPQ2A3b0=
+github.com/jmoiron/sqlx v1.4.0 h1:1PLqN7S1UYp5t4SrVVnt4nUVNemrDAtxlulVe+Qgm3o=
+github.com/jmoiron/sqlx v1.4.0/go.mod h1:ZrZ7UsYB/weZdl2Bxg6jCRO9c3YHl8r3ahlKmRT4JLY=
github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0=
github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4=
github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
@@ -99,6 +102,8 @@ github.com/lib/pq v1.10.9 h1:YXG7RB+JIjhP29X+OtkiDnYaXQwpS4JEWq7dtCCRUEw=
github.com/lib/pq v1.10.9/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/mattn/go-sqlite3 v1.14.22 h1:2gZY6PC6kBnID23Tichd1K+Z0oS6nE/XwU+Vz/5o4kU=
+github.com/mattn/go-sqlite3 v1.14.22/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y=
github.com/microcosm-cc/bluemonday v1.0.27 h1:MpEUotklkwCSLeH+Qdx1VJgNqLlpY2KXwXFM08ygZfk=
github.com/microcosm-cc/bluemonday v1.0.27/go.mod h1:jFi9vgW+H7c3V0lb6nR74Ib/DIB5OBs92Dimizgw2cA=
github.com/minio/crc64nvme v1.1.1 h1:8dwx/Pz49suywbO+auHCBpCtlW1OfpcLN7wYgVR6wAI=
diff --git a/backend/models/log.model.go b/backend/models/log.model.go
index 2f937eab..01e21fac 100644
--- a/backend/models/log.model.go
+++ b/backend/models/log.model.go
@@ -3,11 +3,11 @@ package models
import "alexandrie/types"
type Log struct {
- Id types.Snowflake `json:"id"`
- UserId types.Snowflake `json:"user_id"`
- IpAddr string `json:"ip_address"`
- UserAgent string `json:"user_agent"`
- Location string `json:"location"`
- Type string `json:"type"`
- Timestamp int64 `json:"timestamp"`
+ Id types.Snowflake `json:"id" db:"id"`
+ UserId types.Snowflake `json:"user_id" db:"user_id"`
+ IpAddr string `json:"ip_address" db:"ip_adress"`
+ UserAgent string `json:"user_agent" db:"user_agent"`
+ Location string `json:"location" db:"location"`
+ Type string `json:"type" db:"type"`
+ Timestamp int64 `json:"timestamp" db:"timestamp"`
}
diff --git a/backend/models/node.model.go b/backend/models/node.model.go
index 67cad06e..1b4f16c3 100644
--- a/backend/models/node.model.go
+++ b/backend/models/node.model.go
@@ -4,27 +4,27 @@ import "alexandrie/types"
type Node struct {
// Node
- Id types.Snowflake `json:"id" form:"id" binding:"omitempty"`
- UserId types.Snowflake `json:"user_id" form:"user_id" binding:"omitempty"`
- ParentId *types.Snowflake `json:"parent_id" form:"parent_id" binding:"omitempty"`
- Name string `json:"name" form:"name" binding:"required,max=50"`
- Description *string `json:"description" form:"description" binding:"omitempty,max=250"`
- Tags *string `json:"tags" form:"tags" binding:"omitempty,max=250"`
- Role int `json:"role" form:"role" binding:"omitempty"`
- Color *int `json:"color" form:"color" binding:"omitempty"`
- Icon *string `json:"icon" form:"icon" binding:"omitempty"`
- Thumbnail *string `json:"thumbnail" form:"thumbnail" binding:"omitempty"`
- Theme *string `json:"theme" form:"theme" binding:"omitempty"`
- Accessibility *int `json:"accessibility" form:"accessibility" binding:"omitempty"` // 0: Public; 1: Private; 2: Unlisted;
- Access int `json:"access" form:"access" binding:"omitempty"` // Bit field for access control (0: restricted, 1 view, 2 edit)
- Display *int `json:"display" form:"display" binding:"omitempty"`
- Order *int `json:"order" form:"order" binding:"omitempty"` // -1 for pinned and -2 for bookmark
- Content *string `json:"content" form:"content"`
- ContentCompiled *string `json:"content_compiled" form:"content_compiled"`
- Size *int64 `json:"size" form:"size" binding:"omitempty"`
- Metadata *types.JSONB `json:"metadata" form:"metadata"`
- CreatedTimestamp int64 `json:"created_timestamp" form:"created_timestamp" binding:"omitempty"`
- UpdatedTimestamp int64 `json:"updated_timestamp" form:"updated_timestamp" binding:"omitempty"`
+ Id types.Snowflake `json:"id" form:"id" binding:"omitempty" db:"id"`
+ UserId types.Snowflake `json:"user_id" form:"user_id" binding:"omitempty" db:"user_id"`
+ ParentId *types.Snowflake `json:"parent_id" form:"parent_id" binding:"omitempty" db:"parent_id"`
+ Name string `json:"name" form:"name" binding:"required,max=50" db:"name"`
+ Description *string `json:"description" form:"description" binding:"omitempty,max=250" db:"description"`
+ Tags *string `json:"tags" form:"tags" binding:"omitempty,max=250" db:"tags"`
+ Role int `json:"role" form:"role" binding:"omitempty" db:"role"`
+ Color *int `json:"color" form:"color" binding:"omitempty" db:"color"`
+ Icon *string `json:"icon" form:"icon" binding:"omitempty" db:"icon"`
+ Thumbnail *string `json:"thumbnail" form:"thumbnail" binding:"omitempty" db:"thumbnail"`
+ Theme *string `json:"theme" form:"theme" binding:"omitempty" db:"theme"`
+ Accessibility *int `json:"accessibility" form:"accessibility" binding:"omitempty" db:"accessibility"` // 0: Public; 1: Private; 2: Unlisted;
+ Access int `json:"access" form:"access" binding:"omitempty" db:"access"` // Bit field for access control (0: restricted, 1 view, 2 edit)
+ Display *int `json:"display" form:"display" binding:"omitempty" db:"display"`
+ Order *int `json:"order" form:"order" binding:"omitempty" db:"order"` // -1 for pinned and -2 for bookmark
+ Content *string `json:"content" form:"content" db:"content"`
+ ContentCompiled *string `json:"content_compiled" form:"content_compiled" db:"content_compiled"`
+ Size *int64 `json:"size" form:"size" binding:"omitempty" db:"size"`
+ Metadata *types.JSONB `json:"metadata" form:"metadata" db:"metadata"`
+ CreatedTimestamp int64 `json:"created_timestamp" form:"created_timestamp" binding:"omitempty" db:"created_timestamp"`
+ UpdatedTimestamp int64 `json:"updated_timestamp" form:"updated_timestamp" binding:"omitempty" db:"updated_timestamp"`
// Relations
Permissions []*Permission `json:"permissions" form:"permissions" binding:"omitempty"`
@@ -32,23 +32,23 @@ type Node struct {
// NodeSearchResult represents a search result with relevance score and content snippet
type NodeSearchResult struct {
- Id types.Snowflake `json:"id"`
- UserId types.Snowflake `json:"user_id"`
- ParentId *types.Snowflake `json:"parent_id"`
- Name string `json:"name"`
- Description *string `json:"description"`
- Tags *string `json:"tags"`
- Role int `json:"role"`
- Icon *string `json:"icon"`
- Relevance float64 `json:"relevance"`
- ContentSnippet *string `json:"content_snippet,omitempty"`
- CreatedTimestamp int64 `json:"created_timestamp"`
- UpdatedTimestamp int64 `json:"updated_timestamp"`
+ Id types.Snowflake `json:"id" db:"id"`
+ UserId types.Snowflake `json:"user_id" db:"user_id"`
+ ParentId *types.Snowflake `json:"parent_id" db:"parent_id"`
+ Name string `json:"name" db:"name"`
+ Description *string `json:"description" db:"description"`
+ Tags *string `json:"tags" db:"tags"`
+ Role int `json:"role" db:"role"`
+ Icon *string `json:"icon" db:"icon"`
+ Relevance float64 `json:"relevance" db:"relevance"`
+ ContentSnippet *string `json:"content_snippet,omitempty" db:"content_snippet"`
+ CreatedTimestamp int64 `json:"created_timestamp" db:"created_timestamp"`
+ UpdatedTimestamp int64 `json:"updated_timestamp" db:"updated_timestamp"`
}
// NodeResourceInfo contains minimal info needed to delete a resource file from storage
type NodeResourceInfo struct {
- Id types.Snowflake `json:"id"`
- UserId types.Snowflake `json:"user_id"`
- Metadata *types.JSONB `json:"metadata"`
+ Id types.Snowflake `json:"id" db:"id"`
+ UserId types.Snowflake `json:"user_id" db:"user_id"`
+ Metadata *types.JSONB `json:"metadata" db:"metadata"`
}
diff --git a/backend/models/oidc_provider.model.go b/backend/models/oidc_provider.model.go
index d6c54bbe..22053ff4 100644
--- a/backend/models/oidc_provider.model.go
+++ b/backend/models/oidc_provider.model.go
@@ -4,10 +4,10 @@ import "alexandrie/types"
// UserOIDCProvider represents a link between a user and an external OIDC provider
type UserOIDCProvider struct {
- Id types.Snowflake `json:"id"`
- UserId types.Snowflake `json:"user_id"`
- ProviderName string `json:"provider_name"`
- ProviderUserId string `json:"provider_user_id"`
- CreatedTimestamp int64 `json:"created_timestamp"`
- UpdatedTimestamp int64 `json:"updated_timestamp"`
+ Id types.Snowflake `json:"id" db:"id"`
+ UserId types.Snowflake `json:"user_id" db:"user_id"`
+ ProviderName string `json:"provider_name" db:"provider_name"`
+ ProviderUserId string `json:"provider_user_id" db:"provider_user_id"`
+ CreatedTimestamp int64 `json:"created_timestamp" db:"created_timestamp"`
+ UpdatedTimestamp int64 `json:"updated_timestamp" db:"updated_timestamp"`
}
diff --git a/backend/models/permission.model.go b/backend/models/permission.model.go
index 11d3fcb7..42062726 100644
--- a/backend/models/permission.model.go
+++ b/backend/models/permission.model.go
@@ -3,9 +3,9 @@ package models
import "alexandrie/types"
type Permission struct {
- Id types.Snowflake `json:"id" form:"id" binding:"omitempty"`
- NodeId types.Snowflake `json:"node_id" form:"node_id" binding:"omitempty"`
- UserId types.Snowflake `json:"user_id" form:"user_id"`
- Permission int `json:"permission" form:"permission"`
- CreatedTimestamp int64 `json:"created_timestamp" form:"created_timestamp" binding:"omitempty"`
+ Id types.Snowflake `json:"id" form:"id" binding:"omitempty" db:"id"`
+ NodeId types.Snowflake `json:"node_id" form:"node_id" binding:"omitempty" db:"node_id"`
+ UserId types.Snowflake `json:"user_id" form:"user_id" db:"user_id"`
+ Permission int `json:"permission" form:"permission" db:"permission"`
+ CreatedTimestamp int64 `json:"created_timestamp" form:"created_timestamp" binding:"omitempty" db:"created_timestamp"`
}
diff --git a/backend/models/session.model.go b/backend/models/session.model.go
index 9d21027f..051341ed 100644
--- a/backend/models/session.model.go
+++ b/backend/models/session.model.go
@@ -3,12 +3,12 @@ package models
import "alexandrie/types"
type Session struct {
- Id types.Snowflake `json:"id"`
- UserId types.Snowflake `json:"user_id"`
- RefreshToken string `json:"refresh_token"`
- ExpireToken int64 `json:"expire_token"`
- LastRefreshTimestamp int64 `json:"last_refresh_timestamp"`
- Active int `json:"active"` // 0: No; 1: Yes;
- LoginTimestamp int64 `json:"login_timestamp"`
- LogoutTimestamp int64 `json:"logout_timestamp"`
+ Id types.Snowflake `json:"id" db:"id"`
+ UserId types.Snowflake `json:"user_id" db:"user_id"`
+ RefreshToken string `json:"refresh_token" db:"refresh_token"`
+ ExpireToken int64 `json:"expire_token" db:"expire_token"`
+ LastRefreshTimestamp int64 `json:"last_refresh_timestamp" db:"last_refresh_timestamp"`
+ Active int `json:"active" db:"active"` // 0: No; 1: Yes;
+ LoginTimestamp int64 `json:"login_timestamp" db:"login_timestamp"`
+ LogoutTimestamp int64 `json:"logout_timestamp" db:"logout_timestamp"`
}
diff --git a/backend/models/user.model.go b/backend/models/user.model.go
index 152b6520..41acba29 100644
--- a/backend/models/user.model.go
+++ b/backend/models/user.model.go
@@ -3,14 +3,14 @@ package models
import "alexandrie/types"
type User struct {
- Id types.Snowflake `json:"id" form:"id" binding:"omitempty"`
- Username string `json:"username" form:"username" binding:"required,min=5,max=30"`
- Firstname *string `json:"firstname" form:"firstname" binding:"omitempty"`
- Lastname *string `json:"lastname" form:"lastname" binding:"omitempty"`
- Role int `json:"role" form:"role" binding:"omitempty"` // 1: user, 2: admin
- Avatar *string `json:"avatar" form:"avatar" binding:"omitempty"`
- Email *string `json:"email" form:"email" binding:"required,email"`
- Password *string `json:"password,omitempty" form:"password" binding:"omitempty,min=4,max=50"`
- CreatedTimestamp int64 `json:"created_timestamp" form:"created_timestamp" binding:"omitempty"`
- UpdatedTimestamp int64 `json:"updated_timestamp" form:"updated_timestamp" binding:"omitempty"`
+ Id types.Snowflake `json:"id" form:"id" binding:"omitempty" db:"id"`
+ Username string `json:"username" form:"username" binding:"required,min=5,max=30" db:"username"`
+ Firstname *string `json:"firstname" form:"firstname" binding:"omitempty" db:"firstname"`
+ Lastname *string `json:"lastname" form:"lastname" binding:"omitempty" db:"lastname"`
+ Role int `json:"role" form:"role" binding:"omitempty" db:"role"` // 1: user, 2: admin
+ Avatar *string `json:"avatar" form:"avatar" binding:"omitempty" db:"avatar"`
+ Email *string `json:"email" form:"email" binding:"required,email" db:"email"`
+ Password *string `json:"password,omitempty" form:"password" binding:"omitempty,min=4,max=50" db:"password"`
+ CreatedTimestamp int64 `json:"created_timestamp" form:"created_timestamp" binding:"omitempty" db:"created_timestamp"`
+ UpdatedTimestamp int64 `json:"updated_timestamp" form:"updated_timestamp" binding:"omitempty" db:"updated_timestamp"`
}
diff --git a/backend/repositories/log.repository.go b/backend/repositories/log.repository.go
index 8b2ad8f8..df3b929f 100644
--- a/backend/repositories/log.repository.go
+++ b/backend/repositories/log.repository.go
@@ -10,15 +10,14 @@ import (
"net"
"strings"
"time"
+
+ "github.com/jmoiron/sqlx"
)
-// LogRepositoryImpl implements the LogRepository interface with prepared statements
type LogRepositoryImpl struct {
- db *sql.DB
- manager *RepositoryManager
+ db *sqlx.DB
}
-// LogRepository defines the interface for log data access operations
type LogRepository interface {
GetByUserID(userId types.Snowflake) ([]*models.Log, error)
GetLastByUserID(userId types.Snowflake) (*models.Log, error)
@@ -28,199 +27,76 @@ type LogRepository interface {
getLocationIdFromIP(ip string) (int64, error)
}
-// Prepared statement keys
-const (
- stmtLogGetByUserID = "log_get_by_user_id"
- stmtLogGetLastConnection = "log_get_last_connection"
- stmtLogCreateConnection = "log_create_connection"
- stmtLogDeleteOld = "log_delete_old"
- stmtGetLocationIdFromIpV4 = "log_get_location_id_from_ip_v4"
- stmtGetLocationIdFromIpV6 = "log_get_location_id_from_ip_v6"
- stmtGetLocationFromID = "log_get_location_from_id"
-)
-
-// NewLogRepository creates a new log repository with prepared statements
-func NewLogRepository(db *sql.DB, manager *RepositoryManager) (LogRepository, error) {
- repo := &LogRepositoryImpl{
- db: db,
- manager: manager,
- }
-
- if err := repo.prepareStatements(); err != nil {
- return nil, fmt.Errorf("failed to prepare log statements: %w", err)
- }
-
- return repo, nil
-}
-
-// prepareStatements prepares all SQL statements for the log repository
-func (r *LogRepositoryImpl) prepareStatements() error {
- statements := map[string]string{
- stmtLogGetByUserID: `
- SELECT id, user_id, ip_adress, timestamp, type, location, user_agent
- FROM connections_logs
- WHERE user_id = ?
- ORDER BY timestamp DESC`,
-
- stmtLogGetLastConnection: `
- SELECT id, user_id, ip_adress, timestamp, type, location, user_agent
- FROM connections_logs
- WHERE user_id = ? AND type = 'login'
- ORDER BY timestamp DESC
- LIMIT 1`,
-
- stmtLogCreateConnection: `
- INSERT INTO connections_logs (id, user_id, ip_adress, timestamp, type, location, user_agent)
- VALUES (?, ?, ?, ?, ?, ?, ?)`,
-
- stmtLogDeleteOld: `
- DELETE FROM connections_logs
- WHERE timestamp < ?`,
-
- // Geo IP related statements
- stmtGetLocationIdFromIpV4: `
- SELECT geoname_id
- FROM city_ipv4_complete
- WHERE ? BETWEEN network_start_integer AND network_last_integer
- LIMIT 1`,
-
- stmtGetLocationIdFromIpV6: `
- SELECT geoname_id
- FROM city_ipv6_complete
- WHERE ? BETWEEN network_start_integer AND network_last_integer
- LIMIT 1`,
-
- stmtGetLocationFromID: `
- SELECT city_name, subdivision_1_name, subdivision_2_name, country_name
- FROM city_locations_fr
- WHERE geoname_id = ?
- LIMIT 1`,
- }
-
- // Prepare all statements
- for key, query := range statements {
- if _, err := r.manager.PrepareStatement(key, query); err != nil {
- return err
- }
- }
-
- return nil
+func NewLogRepository(db *sqlx.DB) LogRepository {
+ return &LogRepositoryImpl{db: db}
}
// GetByUserID retrieves all logs for a user
func (r *LogRepositoryImpl) GetByUserID(userId types.Snowflake) ([]*models.Log, error) {
- stmt, err := r.manager.GetStatement(stmtLogGetByUserID)
- if err != nil {
- return nil, err
- }
-
- rows, err := stmt.Query(userId)
+ var logs []*models.Log
+ err := r.db.Select(&logs, `
+ SELECT id, user_id, ip_adress, timestamp, type, location, user_agent
+ FROM connections_logs
+ WHERE user_id = ?
+ ORDER BY timestamp DESC`, userId)
if err != nil {
return nil, fmt.Errorf("failed to query logs: %w", err)
}
- defer rows.Close()
-
- logs := make([]*models.Log, 0)
- for rows.Next() {
- var log models.Log
- err := rows.Scan(
- &log.Id,
- &log.UserId,
- &log.IpAddr,
- &log.Timestamp,
- &log.Type,
- &log.Location,
- &log.UserAgent,
- )
- if err != nil {
- return nil, fmt.Errorf("failed to scan log: %w", err)
- }
- logs = append(logs, &log)
- }
-
- if err = rows.Err(); err != nil {
- return nil, fmt.Errorf("error iterating logs: %w", err)
- }
-
return logs, nil
}
// GetLastByUserID retrieves the last login connection for a user
func (r *LogRepositoryImpl) GetLastByUserID(userId types.Snowflake) (*models.Log, error) {
- stmt, err := r.manager.GetStatement(stmtLogGetLastConnection)
- if err != nil {
- return nil, err
- }
-
var log models.Log
- err = stmt.QueryRow(userId).Scan(
- &log.Id,
- &log.UserId,
- &log.IpAddr,
- &log.Timestamp,
- &log.Type,
- &log.Location,
- &log.UserAgent,
- )
-
+ err := r.db.Get(&log, `
+ SELECT id, user_id, ip_adress, timestamp, type, location, user_agent
+ FROM connections_logs
+ WHERE user_id = ?
+ ORDER BY timestamp DESC
+ LIMIT 1`, userId)
if err == sql.ErrNoRows {
return nil, nil
}
if err != nil {
return nil, fmt.Errorf("failed to get last connection: %w", err)
}
-
return &log, nil
}
// Create creates a new connection log
func (r *LogRepositoryImpl) Create(log *models.Log) error {
- stmt, err := r.manager.GetStatement(stmtLogCreateConnection)
- if err != nil {
- return err
- }
-
- _, err = stmt.Exec(
- log.Id,
- log.UserId,
- log.IpAddr,
- log.Timestamp,
- log.Type,
- log.Location,
- log.UserAgent,
- )
-
+ _, err := r.db.Exec(`
+ INSERT INTO connections_logs (id, user_id, ip_adress, timestamp, type, location, user_agent)
+ VALUES (?, ?, ?, ?, ?, ?, ?)`,
+ log.Id, log.UserId, log.IpAddr, log.Timestamp, log.Type, log.Location, log.UserAgent)
if err != nil {
return fmt.Errorf("failed to create connection log: %w", err)
}
-
return nil
}
// DeleteOld deletes logs older than 90 days
func (r *LogRepositoryImpl) DeleteOld() error {
- stmt, err := r.manager.GetStatement(stmtLogDeleteOld)
- if err != nil {
- return err
- }
-
- // Delete logs older than 90 days
ninetyDaysAgo := time.Now().AddDate(0, 0, -90).UnixMilli()
- _, err = stmt.Exec(ninetyDaysAgo)
+ _, err := r.db.Exec(`DELETE FROM connections_logs WHERE timestamp < ?`, ninetyDaysAgo)
if err != nil {
return fmt.Errorf("failed to delete old logs: %w", err)
}
-
return nil
}
-func (s *LogRepositoryImpl) GetLocationFromIP(ip string) string {
- geonameId, err := s.getLocationIdFromIP(ip)
+// GetLocationFromIP returns the location string from an IP address
+func (r *LogRepositoryImpl) GetLocationFromIP(ip string) string {
+ geonameId, err := r.getLocationIdFromIP(ip)
if err != nil {
return "Unknown location"
}
var res [4]*string
- err = s.db.QueryRow("SELECT city_name, subdivision_1_name, subdivision_2_name, country_name FROM city_Locations_fr WHERE geoname_id = ? LIMIT 1", geonameId).Scan(&res[0], &res[1], &res[2], &res[3])
+ err = r.db.QueryRow(`
+ SELECT city_name, subdivision_1_name, subdivision_2_name, country_name
+ FROM city_locations_fr
+ WHERE geoname_id = ?
+ LIMIT 1`, geonameId).Scan(&res[0], &res[1], &res[2], &res[3])
if err != nil {
return "Unknown location"
}
@@ -233,29 +109,25 @@ func (s *LogRepositoryImpl) GetLocationFromIP(ip string) string {
return strings.Join(parts, ", ")
}
-func (s *LogRepositoryImpl) getLocationIdFromIP(ip string) (int64, error) {
+// getLocationIdFromIP returns the geoname ID for an IP address
+func (r *LogRepositoryImpl) getLocationIdFromIP(ip string) (int64, error) {
ipInt, db, err := ipToDecimal(ip)
if err != nil {
return 0, err
}
var locationId int64
- stmtKey := ""
+ var query string
switch db {
case "ipv4":
- stmtKey = stmtGetLocationIdFromIpV4
+ query = `SELECT geoname_id FROM city_ipv4_complete WHERE ? BETWEEN network_start_integer AND network_last_integer LIMIT 1`
case "ipv6":
- stmtKey = stmtGetLocationIdFromIpV6
+ query = `SELECT geoname_id FROM city_ipv6_complete WHERE ? BETWEEN network_start_integer AND network_last_integer LIMIT 1`
default:
return 0, errors.New("unsupported IP address type")
}
- stmt, err := s.manager.GetStatement(stmtKey)
- if err != nil {
- return 0, err
- }
-
- err = stmt.QueryRow(ipInt).Scan(&locationId)
+ err = r.db.QueryRow(query, ipInt).Scan(&locationId)
if err != nil {
return 0, err
}
@@ -263,6 +135,7 @@ func (s *LogRepositoryImpl) getLocationIdFromIP(ip string) (int64, error) {
return locationId, nil
}
+// ipToDecimal converts an IP address to its decimal representation
func ipToDecimal(ipStr string) (string, string, error) {
ip := net.ParseIP(ipStr)
if ip == nil {
diff --git a/backend/repositories/manager.go b/backend/repositories/manager.go
index 2a19d087..331c1d33 100644
--- a/backend/repositories/manager.go
+++ b/backend/repositories/manager.go
@@ -2,149 +2,47 @@ package repositories
import (
"alexandrie/pkg/logger"
- "database/sql"
- "fmt"
- "sync"
+
+ "github.com/jmoiron/sqlx"
)
-// RepositoryManager manages all repositories and their prepared statements
type RepositoryManager struct {
- db *sql.DB
+ db *sqlx.DB
User UserRepository
Node NodeRepository
Session SessionRepository
Permission PermissionRepository
Log LogRepository
OIDCProvider OIDCProviderRepository
- statements map[string]*sql.Stmt
- stmtMutex sync.RWMutex
initialized bool
}
-// NewRepositoryManager creates a new repository manager and initializes all repositories
-func NewRepositoryManager(db *sql.DB) (*RepositoryManager, error) {
+func NewRepositoryManager(db *sqlx.DB) (*RepositoryManager, error) {
rm := &RepositoryManager{
- db: db,
- statements: make(map[string]*sql.Stmt),
- }
-
- if err := rm.initializeRepositories(); err != nil {
- return nil, fmt.Errorf("failed to initialize repositories: %w", err)
+ db: db,
}
+ rm.initializeRepositories()
rm.initialized = true
- logger.Success("Repository manager initialized successfully with prepared statements")
+ logger.Success("Repository manager initialized successfully")
return rm, nil
}
-// initializeRepositories creates and initializes all repository instances
-func (rm *RepositoryManager) initializeRepositories() error {
- var err error
-
- // Initialize User Repository
- rm.User, err = NewUserRepository(rm.db, rm)
- if err != nil {
- return fmt.Errorf("failed to initialize user repository: %w", err)
- }
-
- // Initialize Node Repository
- rm.Node, err = NewNodeRepository(rm.db, rm)
- if err != nil {
- return fmt.Errorf("failed to initialize node repository: %w", err)
- }
-
- // Initialize Session Repository
- rm.Session, err = NewSessionRepository(rm.db, rm)
- if err != nil {
- return fmt.Errorf("failed to initialize session repository: %w", err)
- }
-
- // Initialize Permission Repository
- rm.Permission, err = NewPermissionRepository(rm.db, rm)
- if err != nil {
- return fmt.Errorf("failed to initialize permission repository: %w", err)
- }
-
- // Initialize Log Repository
- rm.Log, err = NewLogRepository(rm.db, rm)
- if err != nil {
- return fmt.Errorf("failed to initialize log repository: %w", err)
- }
-
- // Initialize OIDC Provider Repository
- rm.OIDCProvider, err = NewOIDCProviderRepository(rm.db, rm)
- if err != nil {
- return fmt.Errorf("failed to initialize OIDC provider repository: %w", err)
- }
-
- return nil
+func (rm *RepositoryManager) initializeRepositories() {
+ rm.User = NewUserRepository(rm.db)
+ rm.Session = NewSessionRepository(rm.db)
+ rm.Node = NewNodeRepository(rm.db)
+ rm.Permission = NewPermissionRepository(rm.db)
+ rm.Log = NewLogRepository(rm.db)
+ rm.OIDCProvider = NewOIDCProviderRepository(rm.db)
}
-// PrepareStatement creates and caches a prepared statement
-func (rm *RepositoryManager) PrepareStatement(key string, query string) (*sql.Stmt, error) {
- rm.stmtMutex.Lock()
- defer rm.stmtMutex.Unlock()
-
- // Check if statement already exists
- if stmt, exists := rm.statements[key]; exists {
- return stmt, nil
- }
-
- // Prepare new statement
- stmt, err := rm.db.Prepare(query)
- if err != nil {
- return nil, fmt.Errorf("failed to prepare statement '%s': %w", key, err)
- }
-
- // Cache the statement
- rm.statements[key] = stmt
- return stmt, nil
-}
-
-// GetStatement retrieves a cached prepared statement
-func (rm *RepositoryManager) GetStatement(key string) (*sql.Stmt, error) {
- rm.stmtMutex.RLock()
- defer rm.stmtMutex.RUnlock()
-
- stmt, exists := rm.statements[key]
- if !exists {
- return nil, fmt.Errorf("prepared statement '%s' not found", key)
- }
- return stmt, nil
-}
-
-// Close closes all prepared statements and cleans up resources
func (rm *RepositoryManager) Close() error {
- rm.stmtMutex.Lock()
- defer rm.stmtMutex.Unlock()
-
- var errors []error
- for key, stmt := range rm.statements {
- if err := stmt.Close(); err != nil {
- errors = append(errors, fmt.Errorf("failed to close statement '%s': %w", key, err))
- }
- }
-
- // Clear the statements map
- rm.statements = make(map[string]*sql.Stmt)
rm.initialized = false
-
- if len(errors) > 0 {
- return fmt.Errorf("errors occurred while closing statements: %v", errors)
- }
-
logger.Success("Repository manager closed successfully")
- return nil
+ return rm.db.Close()
}
-// IsInitialized returns whether the repository manager is initialized
func (rm *RepositoryManager) IsInitialized() bool {
return rm.initialized
}
-
-// GetStatementCount returns the number of prepared statements
-func (rm *RepositoryManager) GetStatementCount() int {
- rm.stmtMutex.RLock()
- defer rm.stmtMutex.RUnlock()
- return len(rm.statements)
-}
diff --git a/backend/repositories/node.repository.go b/backend/repositories/node.repository.go
index f753bc97..7309a0c3 100644
--- a/backend/repositories/node.repository.go
+++ b/backend/repositories/node.repository.go
@@ -6,15 +6,14 @@ import (
"database/sql"
"fmt"
"strings"
+
+ "github.com/jmoiron/sqlx"
)
-// NodeRepositoryImpl implements the NodeRepository interface with prepared statements
type NodeRepositoryImpl struct {
- db *sql.DB
- manager *RepositoryManager
+ db *sqlx.DB
}
-// NodeRepository defines the interface for node data access operations
type NodeRepository interface {
GetAll(userId types.Snowflake) ([]*models.Node, error)
GetShared(userId types.Snowflake) ([]*models.Node, error)
@@ -29,299 +28,66 @@ type NodeRepository interface {
Delete(nodeId types.Snowflake) error
}
-// Prepared statement keys
-const (
- stmNodeGetAll = "node_get_all"
- stmNodeGetShared = "node_get_shared"
- stmNodeGetAllForBackup = "node_get_all_backup"
- stmtNodeGetByID = "node_get_by_id"
- stmtNodeGetPublic = "node_get_public"
- stmtNodeGetUserUploadsSize = "node_get_user_uploads_size"
- stmtNodeGetDescendantResources = "node_get_descendant_resources"
- stmtNodeCreate = "node_create"
- stmtNodeUpdate = "node_update"
- stmtNodeDelete = "node_delete"
- stmtNodeSearchFulltext = "node_search_fulltext"
- stmtNodeSearchContent = "node_search_content"
- // Note: GetAll and GetShared use complex recursive CTEs, prepared separately
-)
-
-// NewNodeRepository creates a new node repository with prepared statements
-func NewNodeRepository(db *sql.DB, manager *RepositoryManager) (NodeRepository, error) {
- repo := &NodeRepositoryImpl{
- db: db,
- manager: manager,
- }
-
- if err := repo.prepareStatements(); err != nil {
- return nil, fmt.Errorf("failed to prepare node statements: %w", err)
- }
-
- return repo, nil
+func NewNodeRepository(db *sqlx.DB) NodeRepository {
+ return &NodeRepositoryImpl{db: db}
}
-// prepareStatements prepares all SQL statements for the node repository
-func (r *NodeRepositoryImpl) prepareStatements() error {
- statements := map[string]string{
-
- stmNodeGetAll: `
+// GetAll retrieves all nodes for a user using recursive CTE
+func (r *NodeRepositoryImpl) GetAll(userId types.Snowflake) ([]*models.Node, error) {
+ var nodes []*models.Node
+ err := r.db.Select(&nodes, `
WITH RECURSIVE user_nodes AS (
- -- 1. Every node owned by the user
- SELECT n.id, n.user_id, n.parent_id, n.name, n.description, n.tags, n.role, n.color, n.icon, n.theme,
- n.accessibility, n.access, n.display, n.order, n.size, n.metadata, n.created_timestamp, n.updated_timestamp
- FROM nodes n
- WHERE n.user_id = ?
-
- UNION
-
- -- 2. Child nodes of owned nodes (even if not owned by the user)
- SELECT c.id, c.user_id, c.parent_id, c.name, c.description, c.tags, c.role, c.color, c.icon, c.theme,
- c.accessibility, c.access, c.display, c.order, c.size, c.metadata, c.created_timestamp, c.updated_timestamp
- FROM nodes c
- JOIN user_nodes un ON un.id = c.parent_id)
- SELECT * FROM user_nodes ORDER BY role, 'order' DESC, name;`,
-
- stmNodeGetShared: `
- WITH RECURSIVE shared_nodes AS (
- SELECT n.id, n.user_id, n.parent_id, n.name, n.description, n.tags, n.role, n.color, n.icon, n.theme,
- n.accessibility, n.access, n.display, n.order, n.size, n.metadata, n.created_timestamp, n.updated_timestamp
- FROM nodes n
- JOIN permissions p ON p.node_id = n.id
- WHERE p.user_id = ?
-
- UNION
-
- SELECT c.id, c.user_id, c.parent_id, c.name, c.description, c.tags, c.role, c.color, c.icon, c.theme,
- c.accessibility, c.access, c.display, c.order, c.size, c.metadata, c.created_timestamp, c.updated_timestamp
- FROM nodes c
- JOIN shared_nodes an ON an.id = c.parent_id
- )
- SELECT * FROM shared_nodes;`,
-
- stmNodeGetAllForBackup: `
- SELECT id, user_id, parent_id, name, description, tags, role, color, icon, thumbnail, theme,
- accessibility, access, display, ` + "`order`" + `, content, content_compiled, size, metadata,
- created_timestamp, updated_timestamp
- FROM nodes
- WHERE user_id = ?`,
-
- stmtNodeGetByID: `
- SELECT id, user_id, parent_id, name, description, tags, role, color, icon, thumbnail, theme,
- accessibility, access, display, ` + "`order`" + `, content, content_compiled, size, metadata,
- created_timestamp, updated_timestamp
- FROM nodes
- WHERE id = ?`,
-
- stmtNodeGetPublic: `
- SELECT id, user_id, parent_id, name, description, tags, role, color, icon, thumbnail, theme,
- accessibility, access, display, ` + "`order`" + `, content, content_compiled, size, metadata,
- created_timestamp, updated_timestamp
- FROM nodes
- WHERE id = ? AND accessibility = 3`,
-
- stmtNodeGetUserUploadsSize: `
- SELECT COALESCE(SUM(size), 0)
- FROM nodes
- WHERE user_id = ?`,
-
- // Get all descendant resource nodes (role=4) for cleanup before deletion
- // This includes the node itself if it's a resource, plus all descendant resources
- stmtNodeGetDescendantResources: `
- WITH RECURSIVE descendants AS (
- SELECT id, user_id, role, metadata
- FROM nodes
- WHERE id = ?
-
- UNION ALL
-
- SELECT n.id, n.user_id, n.role, n.metadata
- FROM nodes n
- JOIN descendants d ON n.parent_id = d.id
- )
- SELECT id, user_id, metadata
- FROM descendants
- WHERE role = 4`,
-
- // FULLTEXT search including content body (for content search)
- stmtNodeSearchContent: `
- SELECT n.id, n.user_id, n.parent_id, n.name, n.description, n.tags, n.role, n.icon,
- MATCH(n.content) AGAINST(? IN NATURAL LANGUAGE MODE) AS relevance,
- SUBSTRING(n.content,
- GREATEST(1, LOCATE(?, LOWER(n.content)) - 50),
- 200) AS content_snippet,
- n.created_timestamp,
- n.updated_timestamp
+ -- 1. Every node owned by the user
+ SELECT n.id, n.user_id, n.parent_id, n.name, n.description, n.tags, n.role, n.color, n.icon, n.theme,
+ n.accessibility, n.access, n.display, n.`+"`order`"+`, n.size, n.metadata, n.created_timestamp, n.updated_timestamp
FROM nodes n
- WHERE n.user_id = ? AND n.role = 3
- AND MATCH(n.content) AGAINST(? IN NATURAL LANGUAGE MODE)
- ORDER BY relevance DESC
- LIMIT ?`,
-
- stmtNodeCreate: `
- INSERT INTO nodes (id, user_id, parent_id, name, description, tags, role, color, icon, thumbnail, theme,
- accessibility, access, display, ` + "`order`" + `, content, content_compiled, size, metadata,
- created_timestamp, updated_timestamp)
- VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-
- stmtNodeUpdate: `
- UPDATE nodes
- SET parent_id = ?, user_id = ?, name = ?, description = ?, tags = ?, role = ?, color = ?,
- icon = ?, thumbnail = ?, theme = ?, accessibility = ?, access = ?, display = ?, ` + "`order`" + ` = ?,
- content = ?, content_compiled = ?, metadata = ?, updated_timestamp = ?
- WHERE id = ?`,
-
- stmtNodeDelete: `
- DELETE FROM nodes
- WHERE id = ?`,
-
- // FULLTEXT search on name, description, tags only (faster, for quick search)
- stmtNodeSearchFulltext: `
- SELECT n.id, n.user_id, n.parent_id, n.name, n.description, n.tags, n.role, n.icon,
- MATCH(n.name, n.description, n.tags, n.content) AGAINST(? IN NATURAL LANGUAGE MODE) AS relevance,
- NULL AS content_snippet,
- n.created_timestamp,
- n.updated_timestamp
- FROM nodes n
- WHERE n.user_id = ? AND n.role = 3
- AND MATCH(n.name, n.description, n.tags, n.content) AGAINST(? IN NATURAL LANGUAGE MODE)
- ORDER BY relevance DESC
- LIMIT ?`,
- }
-
- // Prepare all statements
- for key, query := range statements {
- if _, err := r.manager.PrepareStatement(key, query); err != nil {
- return err
- }
- }
-
- return nil
-}
-
-// scanNode scans a node from a database row
-func (r *NodeRepositoryImpl) scanNode(scanner interface {
- Scan(dest ...interface{}) error
-}) (*models.Node, error) {
- var node models.Node
- err := scanner.Scan(
- &node.Id,
- &node.UserId,
- &node.ParentId,
- &node.Name,
- &node.Description,
- &node.Tags,
- &node.Role,
- &node.Color,
- &node.Icon,
- &node.Thumbnail,
- &node.Theme,
- &node.Accessibility,
- &node.Access,
- &node.Display,
- &node.Order,
- &node.Content,
- &node.ContentCompiled,
- &node.Size,
- &node.Metadata,
- &node.CreatedTimestamp,
- &node.UpdatedTimestamp,
- )
- if err != nil {
- return nil, err
- }
- return &node, nil
-}
+ WHERE n.user_id = ?
-// scanNodePartial scans a node with partial fields from a database row
-func (r *NodeRepositoryImpl) scanNodePartial(scanner interface {
- Scan(dest ...interface{}) error
-}) (*models.Node, error) {
- var node models.Node
- err := scanner.Scan(
- &node.Id,
- &node.UserId,
- &node.ParentId,
- &node.Name,
- &node.Description,
- &node.Tags,
- &node.Role,
- &node.Color,
- &node.Icon,
- &node.Theme,
- &node.Accessibility,
- &node.Access,
- &node.Display,
- &node.Order,
- &node.Size,
- &node.Metadata,
- &node.CreatedTimestamp,
- &node.UpdatedTimestamp,
- )
- if err != nil {
- return nil, err
- }
- return &node, nil
-}
-
-// GetAll retrieves all nodes for a user using recursive CTE
-func (r *NodeRepositoryImpl) GetAll(userId types.Snowflake) ([]*models.Node, error) {
- stmt, err := r.manager.GetStatement("node_get_all")
- if err != nil {
- return nil, err
- }
+ UNION
- rows, err := stmt.Query(userId)
+ -- 2. Child nodes of owned nodes (even if not owned by the user)
+ SELECT c.id, c.user_id, c.parent_id, c.name, c.description, c.tags, c.role, c.color, c.icon, c.theme,
+ c.accessibility, c.access, c.display, c.`+"`order`"+`, c.size, c.metadata, c.created_timestamp, c.updated_timestamp
+ FROM nodes c
+ JOIN user_nodes un ON un.id = c.parent_id
+ )
+ SELECT * FROM user_nodes ORDER BY role, 'order' DESC, name`, userId)
if err != nil {
return nil, fmt.Errorf("failed to query user nodes: %w", err)
}
- defer rows.Close()
-
- nodes := make([]*models.Node, 0)
- for rows.Next() {
- node, err := r.scanNodePartial(rows)
- if err != nil {
- return nil, fmt.Errorf("failed to scan node: %w", err)
- }
- nodes = append(nodes, node)
- }
-
- if err = rows.Err(); err != nil {
- return nil, fmt.Errorf("error iterating nodes: %w", err)
- }
-
return nodes, nil
}
// GetShared retrieves all shared nodes for a user with optimized query
func (r *NodeRepositoryImpl) GetShared(userId types.Snowflake) ([]*models.Node, error) {
- stmt, err := r.manager.GetStatement("node_get_shared")
- if err != nil {
- return nil, err
- }
+ var nodes []*models.Node
+ err := r.db.Select(&nodes, `
+ WITH RECURSIVE shared_nodes AS (
+ SELECT n.id, n.user_id, n.parent_id, n.name, n.description, n.tags, n.role, n.color, n.icon, n.theme,
+ n.accessibility, n.access, n.display, n.`+"`order`"+`, n.size, n.metadata, n.created_timestamp, n.updated_timestamp
+ FROM nodes n
+ JOIN permissions p ON p.node_id = n.id
+ WHERE p.user_id = ?
- rows, err := stmt.Query(userId)
+ UNION
+
+ SELECT c.id, c.user_id, c.parent_id, c.name, c.description, c.tags, c.role, c.color, c.icon, c.theme,
+ c.accessibility, c.access, c.display, c.`+"`order`"+`, c.size, c.metadata, c.created_timestamp, c.updated_timestamp
+ FROM nodes c
+ JOIN shared_nodes an ON an.id = c.parent_id
+ )
+ SELECT * FROM shared_nodes`, userId)
if err != nil {
return nil, fmt.Errorf("failed to query shared nodes: %w", err)
}
- defer rows.Close()
+ // Build node map for permission loading
nodeMap := make(map[types.Snowflake]*models.Node)
- nodes := make([]*models.Node, 0)
-
- for rows.Next() {
- node, err := r.scanNodePartial(rows)
- if err != nil {
- return nil, fmt.Errorf("failed to scan node: %w", err)
- }
+ for _, node := range nodes {
node.Permissions = []*models.Permission{}
- nodes = append(nodes, node)
nodeMap[node.Id] = node
}
- if err = rows.Err(); err != nil {
- return nil, fmt.Errorf("error iterating nodes: %w", err)
- }
-
// Batch fetch permissions for all nodes
if len(nodes) > 0 {
if err := r.loadPermissionsForNodes(userId, nodeMap); err != nil {
@@ -352,15 +118,8 @@ func (r *NodeRepositoryImpl) loadPermissionsForNodes(userId types.Snowflake, nod
WHERE user_id = ? AND node_id IN (%s)`,
strings.Join(placeholders, ","))
- // Prepare this query (it's dynamic so we prepare it on-the-fly)
- stmt, err := r.db.Prepare(query)
- if err != nil {
- return fmt.Errorf("failed to prepare permissions query: %w", err)
- }
- defer stmt.Close()
-
args := append([]interface{}{userId}, nodeIDs...)
- rows, err := stmt.Query(args...)
+ rows, err := r.db.Query(query, args...)
if err != nil {
return fmt.Errorf("failed to query permissions: %w", err)
}
@@ -382,108 +141,87 @@ func (r *NodeRepositoryImpl) loadPermissionsForNodes(userId types.Snowflake, nod
// GetAllForBackup retrieves all nodes for backup (includes full content)
func (r *NodeRepositoryImpl) GetAllForBackup(userId types.Snowflake) ([]*models.Node, error) {
- stmt, err := r.manager.GetStatement("node_get_all_backup")
- if err != nil {
- return nil, err
- }
-
- rows, err := stmt.Query(userId)
+ var nodes []*models.Node
+ err := r.db.Select(&nodes, `
+ SELECT id, user_id, parent_id, name, description, tags, role, color, icon, thumbnail, theme,
+ accessibility, access, display, `+"`order`"+`, content, content_compiled, size, metadata,
+ created_timestamp, updated_timestamp
+ FROM nodes
+ WHERE user_id = ?`, userId)
if err != nil {
return nil, fmt.Errorf("failed to query nodes for backup: %w", err)
}
- defer rows.Close()
-
- nodes := make([]*models.Node, 0)
- for rows.Next() {
- node, err := r.scanNode(rows)
- if err != nil {
- return nil, fmt.Errorf("failed to scan node: %w", err)
- }
- nodes = append(nodes, node)
- }
-
- if err = rows.Err(); err != nil {
- return nil, fmt.Errorf("error iterating nodes: %w", err)
- }
-
return nodes, nil
}
// GetByID retrieves a single node by ID
func (r *NodeRepositoryImpl) GetByID(nodeId types.Snowflake) (*models.Node, error) {
- stmt, err := r.manager.GetStatement(stmtNodeGetByID)
- if err != nil {
- return nil, err
+ var node models.Node
+ err := r.db.Get(&node, `
+ SELECT id, user_id, parent_id, name, description, tags, role, color, icon, thumbnail, theme,
+ accessibility, access, display, `+"`order`"+`, content, content_compiled, size, metadata,
+ created_timestamp, updated_timestamp
+ FROM nodes
+ WHERE id = ?`, nodeId)
+ if err == sql.ErrNoRows {
+ return nil, nil
}
-
- node, err := r.scanNode(stmt.QueryRow(nodeId))
-
if err != nil {
return nil, fmt.Errorf("failed to get node by id: %w", err)
}
-
- return node, nil
+ return &node, nil
}
// GetPublic retrieves a public node by ID
func (r *NodeRepositoryImpl) GetPublic(nodeId types.Snowflake) (*models.Node, error) {
- stmt, err := r.manager.GetStatement(stmtNodeGetPublic)
- if err != nil {
- return nil, err
+ var node models.Node
+ err := r.db.Get(&node, `
+ SELECT id, user_id, parent_id, name, description, tags, role, color, icon, thumbnail, theme,
+ accessibility, access, display, `+"`order`"+`, content, content_compiled, size, metadata,
+ created_timestamp, updated_timestamp
+ FROM nodes
+ WHERE id = ? AND accessibility = 3`, nodeId)
+ if err == sql.ErrNoRows {
+ return nil, nil
}
-
- node, err := r.scanNode(stmt.QueryRow(nodeId))
-
if err != nil {
return nil, fmt.Errorf("failed to get public node: %w", err)
}
-
- return node, nil
+ return &node, nil
}
// GetUserUploadsSize calculates total upload size for a user
func (r *NodeRepositoryImpl) GetUserUploadsSize(userId types.Snowflake) (int64, error) {
- stmt, err := r.manager.GetStatement(stmtNodeGetUserUploadsSize)
- if err != nil {
- return 0, err
- }
-
var totalSize int64
- err = stmt.QueryRow(userId).Scan(&totalSize)
+ err := r.db.Get(&totalSize, `SELECT COALESCE(SUM(size), 0) FROM nodes WHERE user_id = ?`, userId)
if err != nil {
return 0, fmt.Errorf("failed to get user uploads size: %w", err)
}
-
return totalSize, nil
}
// GetDescendantResources retrieves all descendant nodes with role=4 (resources)
// This is used to clean up MinIO files before deleting a node and its children
func (r *NodeRepositoryImpl) GetDescendantResources(nodeId types.Snowflake) ([]*models.NodeResourceInfo, error) {
- stmt, err := r.manager.GetStatement(stmtNodeGetDescendantResources)
- if err != nil {
- return nil, err
- }
-
- rows, err := stmt.Query(nodeId)
+ var resources []*models.NodeResourceInfo
+ err := r.db.Select(&resources, `
+ WITH RECURSIVE descendants AS (
+ SELECT id, user_id, role, metadata
+ FROM nodes
+ WHERE id = ?
+
+ UNION ALL
+
+ SELECT n.id, n.user_id, n.role, n.metadata
+ FROM nodes n
+ JOIN descendants d ON n.parent_id = d.id
+ )
+ SELECT id, user_id, metadata
+ FROM descendants
+ WHERE role = 4`, nodeId)
if err != nil {
return nil, fmt.Errorf("failed to query descendant resources: %w", err)
}
- defer rows.Close()
-
- resources := make([]*models.NodeResourceInfo, 0)
- for rows.Next() {
- var res models.NodeResourceInfo
- if err := rows.Scan(&res.Id, &res.UserId, &res.Metadata); err != nil {
- return nil, fmt.Errorf("failed to scan resource info: %w", err)
- }
- resources = append(resources, &res)
- }
-
- if err = rows.Err(); err != nil {
- return nil, fmt.Errorf("error iterating descendant resources: %w", err)
- }
-
return resources, nil
}
@@ -497,154 +235,90 @@ func (r *NodeRepositoryImpl) SearchFulltext(userId types.Snowflake, query string
limit = 100
}
- // Prepare the search query for MySQL FULLTEXT
// Clean the query for safety
cleanQuery := strings.TrimSpace(query)
if len(cleanQuery) < 2 {
return []*models.NodeSearchResult{}, nil
}
- var stmtKey string
- if includeContent {
- stmtKey = stmtNodeSearchContent
- } else {
- stmtKey = stmtNodeSearchFulltext
- }
+ var results []*models.NodeSearchResult
+ var err error
- stmt, err := r.manager.GetStatement(stmtKey)
- if err != nil {
- return nil, err
- }
-
- var rows *sql.Rows
if includeContent {
- // For content search, we need the query for MATCH, for LOCATE (snippet), userId, and limit
- rows, err = stmt.Query(cleanQuery, strings.ToLower(cleanQuery), userId, cleanQuery, limit)
+ // FULLTEXT search including content body
+ err = r.db.Select(&results, `
+ SELECT n.id, n.user_id, n.parent_id, n.name, n.description, n.tags, n.role, n.icon,
+ MATCH(n.content) AGAINST(? IN NATURAL LANGUAGE MODE) AS relevance,
+ SUBSTRING(n.content,
+ GREATEST(1, LOCATE(?, LOWER(n.content)) - 50),
+ 200) AS content_snippet,
+ n.created_timestamp,
+ n.updated_timestamp
+ FROM nodes n
+ WHERE n.user_id = ? AND n.role = 3
+ AND MATCH(n.content) AGAINST(? IN NATURAL LANGUAGE MODE)
+ ORDER BY relevance DESC
+ LIMIT ?`, cleanQuery, strings.ToLower(cleanQuery), userId, cleanQuery, limit)
} else {
- // For fulltext search: query for MATCH, userId, query for MATCH again, and limit
- rows, err = stmt.Query(cleanQuery, userId, cleanQuery, limit)
+ // FULLTEXT search on name, description, tags only (faster)
+ err = r.db.Select(&results, `
+ SELECT n.id, n.user_id, n.parent_id, n.name, n.description, n.tags, n.role, n.icon,
+ MATCH(n.name, n.description, n.tags, n.content) AGAINST(? IN NATURAL LANGUAGE MODE) AS relevance,
+ NULL AS content_snippet,
+ n.created_timestamp,
+ n.updated_timestamp
+ FROM nodes n
+ WHERE n.user_id = ? AND n.role = 3
+ AND MATCH(n.name, n.description, n.tags, n.content) AGAINST(? IN NATURAL LANGUAGE MODE)
+ ORDER BY relevance DESC
+ LIMIT ?`, cleanQuery, userId, cleanQuery, limit)
}
if err != nil {
return nil, fmt.Errorf("failed to execute fulltext search: %w", err)
}
- defer rows.Close()
-
- results := make([]*models.NodeSearchResult, 0)
- for rows.Next() {
- var result models.NodeSearchResult
- err := rows.Scan(
- &result.Id,
- &result.UserId,
- &result.ParentId,
- &result.Name,
- &result.Description,
- &result.Tags,
- &result.Role,
- &result.Icon,
- &result.Relevance,
- &result.ContentSnippet,
- &result.CreatedTimestamp,
- &result.UpdatedTimestamp,
- )
- if err != nil {
- return nil, fmt.Errorf("failed to scan search result: %w", err)
- }
- results = append(results, &result)
- }
-
- if err = rows.Err(); err != nil {
- return nil, fmt.Errorf("error iterating search results: %w", err)
- }
return results, nil
}
// Create a new node
func (r *NodeRepositoryImpl) Create(node *models.Node) error {
- stmt, err := r.manager.GetStatement(stmtNodeCreate)
- if err != nil {
- return err
- }
-
- _, err = stmt.Exec(
- node.Id,
- node.UserId,
- node.ParentId,
- node.Name,
- node.Description,
- node.Tags,
- node.Role,
- node.Color,
- node.Icon,
- node.Thumbnail,
- node.Theme,
- node.Accessibility,
- node.Access,
- node.Display,
- node.Order,
- node.Content,
- node.ContentCompiled,
- node.Size,
- node.Metadata,
- node.CreatedTimestamp,
- node.UpdatedTimestamp,
- )
-
+ _, err := r.db.Exec(`
+ INSERT INTO nodes (id, user_id, parent_id, name, description, tags, role, color, icon, thumbnail, theme,
+ accessibility, access, display, `+"`order`"+`, content, content_compiled, size, metadata,
+ created_timestamp, updated_timestamp)
+ VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+ node.Id, node.UserId, node.ParentId, node.Name, node.Description, node.Tags, node.Role, node.Color,
+ node.Icon, node.Thumbnail, node.Theme, node.Accessibility, node.Access, node.Display, node.Order,
+ node.Content, node.ContentCompiled, node.Size, node.Metadata, node.CreatedTimestamp, node.UpdatedTimestamp)
if err != nil {
return fmt.Errorf("failed to create node: %w", err)
}
-
return nil
}
// Update an existing node
func (r *NodeRepositoryImpl) Update(node *models.Node) error {
- stmt, err := r.manager.GetStatement(stmtNodeUpdate)
- if err != nil {
- return err
- }
-
- _, err = stmt.Exec(
- node.ParentId,
- node.UserId,
- node.Name,
- node.Description,
- node.Tags,
- node.Role,
- node.Color,
- node.Icon,
- node.Thumbnail,
- node.Theme,
- node.Accessibility,
- node.Access,
- node.Display,
- node.Order,
- node.Content,
- node.ContentCompiled,
- node.Metadata,
- node.UpdatedTimestamp,
- node.Id,
- )
-
+ _, err := r.db.Exec(`
+ UPDATE nodes
+ SET parent_id = ?, user_id = ?, name = ?, description = ?, tags = ?, role = ?, color = ?,
+ icon = ?, thumbnail = ?, theme = ?, accessibility = ?, access = ?, display = ?, `+"`order`"+` = ?,
+ content = ?, content_compiled = ?, metadata = ?, updated_timestamp = ?
+ WHERE id = ?`,
+ node.ParentId, node.UserId, node.Name, node.Description, node.Tags, node.Role, node.Color,
+ node.Icon, node.Thumbnail, node.Theme, node.Accessibility, node.Access, node.Display, node.Order,
+ node.Content, node.ContentCompiled, node.Metadata, node.UpdatedTimestamp, node.Id)
if err != nil {
return fmt.Errorf("failed to update node: %w", err)
}
-
return nil
}
// Delete a node
func (r *NodeRepositoryImpl) Delete(nodeId types.Snowflake) error {
- stmt, err := r.manager.GetStatement(stmtNodeDelete)
- if err != nil {
- return err
- }
-
- _, err = stmt.Exec(nodeId)
+ _, err := r.db.Exec(`DELETE FROM nodes WHERE id = ?`, nodeId)
if err != nil {
return fmt.Errorf("failed to delete node: %w", err)
}
-
return nil
}
diff --git a/backend/repositories/oidc_provider.repository.go b/backend/repositories/oidc_provider.repository.go
index 18f6e0e8..0dc06eb7 100644
--- a/backend/repositories/oidc_provider.repository.go
+++ b/backend/repositories/oidc_provider.repository.go
@@ -5,12 +5,12 @@ import (
"alexandrie/types"
"database/sql"
"fmt"
+
+ "github.com/jmoiron/sqlx"
)
-// OIDCProviderRepositoryImpl implements the OIDCProviderRepository interface
type OIDCProviderRepositoryImpl struct {
- db *sql.DB
- manager *RepositoryManager
+ db *sqlx.DB
}
type OIDCProviderRepository interface {
@@ -21,171 +21,64 @@ type OIDCProviderRepository interface {
DeleteByUserID(userID types.Snowflake) error
}
-// Prepared statement keys
-const (
- stmtOIDCGetByUserID = "oidc_get_by_user_id"
- stmtOIDCGetByProviderAndSubject = "oidc_get_by_provider_and_subject"
- stmtOIDCCreate = "oidc_create"
- stmtOIDCDelete = "oidc_delete"
- stmtOIDCDeleteByUserID = "oidc_delete_by_user_id"
-)
-
-// NewOIDCProviderRepository creates a new OIDC provider repository with prepared statements
-func NewOIDCProviderRepository(db *sql.DB, manager *RepositoryManager) (OIDCProviderRepository, error) {
- repo := &OIDCProviderRepositoryImpl{
- db: db,
- manager: manager,
- }
-
- if err := repo.prepareStatements(); err != nil {
- return nil, fmt.Errorf("failed to prepare OIDC provider statements: %w", err)
- }
-
- return repo, nil
-}
-
-// prepareStatements prepares all SQL statements for the OIDC provider repository
-func (r *OIDCProviderRepositoryImpl) prepareStatements() error {
- statements := map[string]string{
- stmtOIDCGetByUserID: `
- SELECT id, user_id, provider_name, provider_user_id, created_timestamp, updated_timestamp
- FROM user_oidc_providers
- WHERE user_id = ?`,
-
- stmtOIDCGetByProviderAndSubject: `
- SELECT id, user_id, provider_name, provider_user_id, created_timestamp, updated_timestamp
- FROM user_oidc_providers
- WHERE provider_name = ? AND provider_user_id = ?`,
-
- stmtOIDCCreate: `
- INSERT INTO user_oidc_providers (id, user_id, provider_name, provider_user_id, created_timestamp, updated_timestamp)
- VALUES (?, ?, ?, ?, ?, ?)`,
-
- stmtOIDCDelete: `
- DELETE FROM user_oidc_providers
- WHERE id = ?`,
-
- stmtOIDCDeleteByUserID: `
- DELETE FROM user_oidc_providers
- WHERE user_id = ?`,
- }
-
- for key, query := range statements {
- if _, err := r.manager.PrepareStatement(key, query); err != nil {
- return err
- }
- }
-
- return nil
+func NewOIDCProviderRepository(db *sqlx.DB) OIDCProviderRepository {
+ return &OIDCProviderRepositoryImpl{db: db}
}
// GetByUserID retrieves all OIDC provider links for a user
func (r *OIDCProviderRepositoryImpl) GetByUserID(userID types.Snowflake) ([]*models.UserOIDCProvider, error) {
- stmt, err := r.manager.GetStatement(stmtOIDCGetByUserID)
- if err != nil {
- return nil, err
- }
-
- rows, err := stmt.Query(userID)
+ var links []*models.UserOIDCProvider
+ err := r.db.Select(&links, `
+ SELECT id, user_id, provider_name, provider_user_id, created_timestamp, updated_timestamp
+ FROM user_oidc_providers
+ WHERE user_id = ?`, userID)
if err != nil {
return nil, fmt.Errorf("failed to query OIDC providers for user: %w", err)
}
- defer rows.Close()
-
- links := make([]*models.UserOIDCProvider, 0)
- for rows.Next() {
- var link models.UserOIDCProvider
- err := rows.Scan(
- &link.Id,
- &link.UserId,
- &link.ProviderName,
- &link.ProviderUserId,
- &link.CreatedTimestamp,
- &link.UpdatedTimestamp,
- )
- if err != nil {
- return nil, fmt.Errorf("failed to scan OIDC provider link: %w", err)
- }
- links = append(links, &link)
- }
-
return links, nil
}
// GetByProviderAndSubject finds a link by provider name and provider user ID
func (r *OIDCProviderRepositoryImpl) GetByProviderAndSubject(providerName, providerUserID string) (*models.UserOIDCProvider, error) {
- stmt, err := r.manager.GetStatement(stmtOIDCGetByProviderAndSubject)
- if err != nil {
- return nil, err
- }
-
var link models.UserOIDCProvider
- err = stmt.QueryRow(providerName, providerUserID).Scan(
- &link.Id,
- &link.UserId,
- &link.ProviderName,
- &link.ProviderUserId,
- &link.CreatedTimestamp,
- &link.UpdatedTimestamp,
- )
+ err := r.db.Get(&link, `
+ SELECT id, user_id, provider_name, provider_user_id, created_timestamp, updated_timestamp
+ FROM user_oidc_providers
+ WHERE provider_name = ? AND provider_user_id = ?`, providerName, providerUserID)
if err == sql.ErrNoRows {
return nil, nil
}
if err != nil {
return nil, fmt.Errorf("failed to get OIDC provider link: %w", err)
}
-
return &link, nil
}
// Create creates a new user-OIDC provider link
func (r *OIDCProviderRepositoryImpl) Create(link *models.UserOIDCProvider) (*models.UserOIDCProvider, error) {
- stmt, err := r.manager.GetStatement(stmtOIDCCreate)
- if err != nil {
- return nil, err
- }
-
- _, err = stmt.Exec(
- link.Id,
- link.UserId,
- link.ProviderName,
- link.ProviderUserId,
- link.CreatedTimestamp,
- link.UpdatedTimestamp,
- )
+ _, err := r.db.NamedExec(`
+ INSERT INTO user_oidc_providers (id, user_id, provider_name, provider_user_id, created_timestamp, updated_timestamp)
+ VALUES (:id, :user_id, :provider_name, :provider_user_id, :created_timestamp, :updated_timestamp)`, link)
if err != nil {
return nil, fmt.Errorf("failed to create OIDC provider link: %w", err)
}
-
return link, nil
}
// Delete removes a user-OIDC provider link
func (r *OIDCProviderRepositoryImpl) Delete(id types.Snowflake) error {
- stmt, err := r.manager.GetStatement(stmtOIDCDelete)
- if err != nil {
- return err
- }
-
- _, err = stmt.Exec(id)
+ _, err := r.db.Exec(`DELETE FROM user_oidc_providers WHERE id = ?`, id)
if err != nil {
return fmt.Errorf("failed to delete OIDC provider link: %w", err)
}
-
return nil
}
// DeleteByUserID removes all OIDC provider links for a user
func (r *OIDCProviderRepositoryImpl) DeleteByUserID(userID types.Snowflake) error {
- stmt, err := r.manager.GetStatement(stmtOIDCDeleteByUserID)
- if err != nil {
- return err
- }
-
- _, err = stmt.Exec(userID)
+ _, err := r.db.Exec(`DELETE FROM user_oidc_providers WHERE user_id = ?`, userID)
if err != nil {
return fmt.Errorf("failed to delete OIDC provider links for user: %w", err)
}
-
return nil
}
diff --git a/backend/repositories/permission.repository.go b/backend/repositories/permission.repository.go
index 6db2a91c..9ba35416 100644
--- a/backend/repositories/permission.repository.go
+++ b/backend/repositories/permission.repository.go
@@ -5,15 +5,14 @@ import (
"alexandrie/types"
"database/sql"
"fmt"
+
+ "github.com/jmoiron/sqlx"
)
-// PermissionRepositoryImpl implements the PermissionRepository interface with prepared statements
type PermissionRepositoryImpl struct {
- db *sql.DB
- manager *RepositoryManager
+ db *sqlx.DB
}
-// PermissionRepository defines the interface for permission data access operations
type PermissionRepository interface {
GetByID(permissionId types.Snowflake) (*models.Permission, error)
GetByNode(nodeId types.Snowflake) ([]*models.Permission, error)
@@ -24,207 +23,78 @@ type PermissionRepository interface {
Delete(permissionId types.Snowflake) error
}
-// Prepared statement keys
-const (
- stmtPermissionGetByID = "permission_get_by_id"
- stmtPermissionGetByNode = "permission_get_by_node"
- stmtPermissionGetByNodeAndUser = "permission_get_by_node_and_user"
- stmtPermissionCreate = "permission_create"
- stmtPermissionUpdate = "permission_update"
- stmtPermissionDelete = "permission_delete"
-)
-
-// NewPermissionRepository creates a new permission repository with prepared statements
-func NewPermissionRepository(db *sql.DB, manager *RepositoryManager) (PermissionRepository, error) {
- repo := &PermissionRepositoryImpl{
- db: db,
- manager: manager,
- }
-
- if err := repo.prepareStatements(); err != nil {
- return nil, fmt.Errorf("failed to prepare permission statements: %w", err)
- }
-
- return repo, nil
-}
-
-// prepareStatements prepares all SQL statements for the permission repository
-func (r *PermissionRepositoryImpl) prepareStatements() error {
- statements := map[string]string{
- stmtPermissionGetByID: `
- SELECT id, node_id, user_id, permission, created_timestamp
- FROM permissions
- WHERE id = ?`,
-
- stmtPermissionGetByNode: `
- SELECT id, node_id, user_id, permission, created_timestamp
- FROM permissions
- WHERE node_id = ?`,
-
- stmtPermissionGetByNodeAndUser: `
- SELECT id, node_id, user_id, permission, created_timestamp
- FROM permissions
- WHERE node_id = ? AND user_id = ?`,
-
- stmtPermissionCreate: `
- INSERT INTO permissions (id, node_id, user_id, permission, created_timestamp)
- VALUES (?, ?, ?, ?, ?)`,
-
- stmtPermissionUpdate: `
- UPDATE permissions
- SET permission = ?
- WHERE id = ?`,
-
- stmtPermissionDelete: `
- DELETE FROM permissions
- WHERE id = ?`,
- }
-
- // Prepare all statements
- for key, query := range statements {
- if _, err := r.manager.PrepareStatement(key, query); err != nil {
- return err
- }
- }
-
- return nil
+func NewPermissionRepository(db *sqlx.DB) PermissionRepository {
+ return &PermissionRepositoryImpl{db: db}
}
// GetByID retrieves a permission by ID
func (r *PermissionRepositoryImpl) GetByID(permissionId types.Snowflake) (*models.Permission, error) {
- stmt, err := r.manager.GetStatement(stmtPermissionGetByID)
- if err != nil {
- return nil, err
- }
-
var perm models.Permission
- err = stmt.QueryRow(permissionId).Scan(
- &perm.Id,
- &perm.NodeId,
- &perm.UserId,
- &perm.Permission,
- &perm.CreatedTimestamp,
- )
-
+ err := r.db.Get(&perm, `
+ SELECT id, node_id, user_id, permission, created_timestamp
+ FROM permissions
+ WHERE id = ?`, permissionId)
if err != nil {
return nil, fmt.Errorf("failed to get permission: %w", err)
}
-
return &perm, nil
}
// GetByNode retrieves all permissions for a node
func (r *PermissionRepositoryImpl) GetByNode(nodeId types.Snowflake) ([]*models.Permission, error) {
- stmt, err := r.manager.GetStatement(stmtPermissionGetByNode)
- if err != nil {
- return nil, err
- }
-
- rows, err := stmt.Query(nodeId)
+ var permissions []*models.Permission
+ err := r.db.Select(&permissions, `
+ SELECT id, node_id, user_id, permission, created_timestamp
+ FROM permissions
+ WHERE node_id = ?`, nodeId)
if err != nil {
return nil, fmt.Errorf("failed to query permissions: %w", err)
}
- defer rows.Close()
-
- permissions := make([]*models.Permission, 0)
- for rows.Next() {
- var perm models.Permission
- err := rows.Scan(
- &perm.Id,
- &perm.NodeId,
- &perm.UserId,
- &perm.Permission,
- &perm.CreatedTimestamp,
- )
- if err != nil {
- return nil, fmt.Errorf("failed to scan permission: %w", err)
- }
- permissions = append(permissions, &perm)
- }
-
- if err = rows.Err(); err != nil {
- return nil, fmt.Errorf("error iterating permissions: %w", err)
- }
-
return permissions, nil
}
// GetByNodeAndUser retrieves a specific permission for a node and user
func (r *PermissionRepositoryImpl) GetByNodeAndUser(nodeId types.Snowflake, userId types.Snowflake) (*models.Permission, error) {
- stmt, err := r.manager.GetStatement(stmtPermissionGetByNodeAndUser)
- if err != nil {
- return nil, err
- }
-
var perm models.Permission
- err = stmt.QueryRow(nodeId, userId).Scan(
- &perm.Id,
- &perm.NodeId,
- &perm.UserId,
- &perm.Permission,
- &perm.CreatedTimestamp,
- )
-
+ err := r.db.Get(&perm, `
+ SELECT id, node_id, user_id, permission, created_timestamp
+ FROM permissions
+ WHERE node_id = ? AND user_id = ?`, nodeId, userId)
if err != nil {
return nil, fmt.Errorf("failed to get permission: %w", err)
}
-
return &perm, nil
}
// Create creates a new permission
func (r *PermissionRepositoryImpl) Create(permission *models.Permission) (*models.Permission, error) {
- stmt, err := r.manager.GetStatement(stmtPermissionCreate)
- if err != nil {
- return nil, err
- }
-
- _, err = stmt.Exec(
- permission.Id,
- permission.NodeId,
- permission.UserId,
- permission.Permission,
- permission.CreatedTimestamp,
- )
-
+ _, err := r.db.NamedExec(`
+ INSERT INTO permissions (id, node_id, user_id, permission, created_timestamp)
+ VALUES (:id, :node_id, :user_id, :permission, :created_timestamp)`, permission)
if err != nil {
return nil, fmt.Errorf("failed to create permission: %w", err)
}
-
return permission, nil
}
// Update updates an existing permission
func (r *PermissionRepositoryImpl) Update(permission *models.Permission) error {
- stmt, err := r.manager.GetStatement(stmtPermissionUpdate)
- if err != nil {
- return err
- }
-
- _, err = stmt.Exec(
- permission.Permission,
- permission.Id,
- )
-
+ _, err := r.db.Exec(`
+ UPDATE permissions
+ SET permission = ?
+ WHERE id = ?`, permission.Permission, permission.Id)
if err != nil {
return fmt.Errorf("failed to update permission: %w", err)
}
-
return nil
}
// Delete deletes a permission
func (r *PermissionRepositoryImpl) Delete(permissionId types.Snowflake) error {
- stmt, err := r.manager.GetStatement(stmtPermissionDelete)
- if err != nil {
- return err
- }
-
- _, err = stmt.Exec(permissionId)
+ _, err := r.db.Exec(`DELETE FROM permissions WHERE id = ?`, permissionId)
if err != nil {
return fmt.Errorf("failed to delete permission: %w", err)
}
-
return nil
}
diff --git a/backend/repositories/session.repository.go b/backend/repositories/session.repository.go
index 6178e671..102825f2 100644
--- a/backend/repositories/session.repository.go
+++ b/backend/repositories/session.repository.go
@@ -3,18 +3,16 @@ package repositories
import (
"alexandrie/models"
"alexandrie/types"
- "database/sql"
"fmt"
"time"
+
+ "github.com/jmoiron/sqlx"
)
-// SessionRepositoryImpl implements the SessionRepository interface with prepared statements
type SessionRepositoryImpl struct {
- db *sql.DB
- manager *RepositoryManager
+ db *sqlx.DB
}
-// SessionRepository defines the interface for session data access operations
type SessionRepository interface {
GetByRefreshToken(refreshToken string) (*models.Session, error)
Create(session *models.Session) (*models.Session, error)
@@ -24,88 +22,17 @@ type SessionRepository interface {
DeleteOld() error
}
-// Prepared statement keys
-const (
- stmtSessionGetByRefreshToken = "session_get_by_refresh_token"
- stmtSessionCreate = "session_create"
- stmtSessionUpdate = "session_update"
- stmtSessionDelete = "session_delete"
- stmtSessionDeleteAllByUser = "session_delete_all_by_user"
- stmtSessionDeleteOld = "session_delete_old"
-)
-
-// NewSessionRepository creates a new session repository with prepared statements
-func NewSessionRepository(db *sql.DB, manager *RepositoryManager) (SessionRepository, error) {
- repo := &SessionRepositoryImpl{
- db: db,
- manager: manager,
- }
-
- if err := repo.prepareStatements(); err != nil {
- return nil, fmt.Errorf("failed to prepare session statements: %w", err)
- }
-
- return repo, nil
-}
-
-// prepareStatements prepares all SQL statements for the session repository
-func (r *SessionRepositoryImpl) prepareStatements() error {
- statements := map[string]string{
- stmtSessionGetByRefreshToken: `
- SELECT id, user_id, refresh_token, expire_token, last_refresh_timestamp, active, login_timestamp, logout_timestamp
- FROM sessions
- WHERE refresh_token = ? AND active = 1`,
-
- stmtSessionCreate: `
- INSERT INTO sessions (id, user_id, refresh_token, expire_token, last_refresh_timestamp, active, login_timestamp, logout_timestamp)
- VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
-
- stmtSessionUpdate: `
- UPDATE sessions
- SET refresh_token = ?, expire_token = ?, last_refresh_timestamp = ?
- WHERE id = ?`,
-
- stmtSessionDelete: `
- DELETE FROM sessions
- WHERE id = ?`,
-
- stmtSessionDeleteAllByUser: `
- DELETE FROM sessions
- WHERE user_id = ?`,
-
- stmtSessionDeleteOld: `
- DELETE FROM sessions
- WHERE expire_token < ?`,
- }
-
- // Prepare all statements
- for key, query := range statements {
- if _, err := r.manager.PrepareStatement(key, query); err != nil {
- return err
- }
- }
-
- return nil
+func NewSessionRepository(db *sqlx.DB) SessionRepository {
+ return &SessionRepositoryImpl{db: db}
}
// GetByRefreshToken retrieves a session by refresh token
func (r *SessionRepositoryImpl) GetByRefreshToken(refreshToken string) (*models.Session, error) {
- stmt, err := r.manager.GetStatement(stmtSessionGetByRefreshToken)
- if err != nil {
- return nil, err
- }
-
var session models.Session
- err = stmt.QueryRow(refreshToken).Scan(
- &session.Id,
- &session.UserId,
- &session.RefreshToken,
- &session.ExpireToken,
- &session.LastRefreshTimestamp,
- &session.Active,
- &session.LoginTimestamp,
- &session.LogoutTimestamp,
- )
+ err := r.db.Get(&session, `
+ SELECT id, user_id, refresh_token, expire_token, last_refresh_timestamp, active, login_timestamp, logout_timestamp
+ FROM sessions
+ WHERE refresh_token = ? AND active = 1`, refreshToken)
if err != nil {
return nil, fmt.Errorf("failed to get session by refresh token: %w", err)
@@ -116,21 +43,9 @@ func (r *SessionRepositoryImpl) GetByRefreshToken(refreshToken string) (*models.
// Create creates a new session
func (r *SessionRepositoryImpl) Create(session *models.Session) (*models.Session, error) {
- stmt, err := r.manager.GetStatement(stmtSessionCreate)
- if err != nil {
- return nil, err
- }
-
- _, err = stmt.Exec(
- session.Id,
- session.UserId,
- session.RefreshToken,
- session.ExpireToken,
- session.LastRefreshTimestamp,
- session.Active,
- session.LoginTimestamp,
- session.LogoutTimestamp,
- )
+ _, err := r.db.NamedExec(`
+ INSERT INTO sessions (id, user_id, refresh_token, expire_token, last_refresh_timestamp, active, login_timestamp, logout_timestamp)
+ VALUES (:id, :user_id, :refresh_token, :expire_token, :last_refresh_timestamp, :active, :login_timestamp, :logout_timestamp)`, session)
if err != nil {
return nil, fmt.Errorf("failed to create session: %w", err)
@@ -141,18 +56,10 @@ func (r *SessionRepositoryImpl) Create(session *models.Session) (*models.Session
// Update updates an existing session
func (r *SessionRepositoryImpl) Update(session *models.Session) (*models.Session, error) {
- stmt, err := r.manager.GetStatement(stmtSessionUpdate)
- if err != nil {
- return nil, err
- }
-
- _, err = stmt.Exec(
- session.RefreshToken,
- session.ExpireToken,
- session.LastRefreshTimestamp,
- session.Id,
- )
-
+ _, err := r.db.Exec(`
+ UPDATE sessions
+ SET refresh_token = ?, expire_token = ?, last_refresh_timestamp = ?
+ WHERE id = ?`, session.RefreshToken, session.ExpireToken, session.LastRefreshTimestamp, session.Id)
if err != nil {
return nil, fmt.Errorf("failed to update session: %w", err)
}
@@ -162,12 +69,7 @@ func (r *SessionRepositoryImpl) Update(session *models.Session) (*models.Session
// Delete deletes a session
func (r *SessionRepositoryImpl) Delete(sessionId types.Snowflake) error {
- stmt, err := r.manager.GetStatement(stmtSessionDelete)
- if err != nil {
- return err
- }
-
- _, err = stmt.Exec(sessionId)
+ _, err := r.db.Exec(`DELETE FROM sessions WHERE id = ?`, sessionId)
if err != nil {
return fmt.Errorf("failed to delete session: %w", err)
}
@@ -177,31 +79,19 @@ func (r *SessionRepositoryImpl) Delete(sessionId types.Snowflake) error {
// DeleteAllByUser deletes all sessions for a user
func (r *SessionRepositoryImpl) DeleteAllByUser(userId types.Snowflake) error {
- stmt, err := r.manager.GetStatement(stmtSessionDeleteAllByUser)
- if err != nil {
- return err
- }
-
- _, err = stmt.Exec(userId)
+ _, err := r.db.Exec(`DELETE FROM sessions WHERE user_id = ?`, userId)
if err != nil {
return fmt.Errorf("failed to delete all user sessions: %w", err)
}
-
return nil
}
// DeleteOld deletes expired sessions
func (r *SessionRepositoryImpl) DeleteOld() error {
- stmt, err := r.manager.GetStatement(stmtSessionDeleteOld)
- if err != nil {
- return err
- }
-
currentTime := time.Now().UnixMilli()
- _, err = stmt.Exec(currentTime)
+ _, err := r.db.Exec(`DELETE FROM sessions WHERE expire_token < ?`, currentTime)
if err != nil {
return fmt.Errorf("failed to delete old sessions: %w", err)
}
-
return nil
}
diff --git a/backend/repositories/user.repository.go b/backend/repositories/user.repository.go
index 89254b7d..4af861cf 100644
--- a/backend/repositories/user.repository.go
+++ b/backend/repositories/user.repository.go
@@ -5,15 +5,14 @@ import (
"alexandrie/types"
"database/sql"
"fmt"
+
+ "github.com/jmoiron/sqlx"
)
-// UserRepositoryImpl implements the UserRepository interface with prepared statements
type UserRepositoryImpl struct {
- db *sql.DB
- manager *RepositoryManager
+ db *sqlx.DB
}
-// UserRepository defines the interface for user repository operations
type UserRepository interface {
GetAll() ([]*models.User, error)
GetByID(id types.Snowflake) (*models.User, error)
@@ -29,399 +28,153 @@ type UserRepository interface {
Delete(id types.Snowflake) error
}
-// Prepared statement keys
-const (
- stmtUserGetAll = "user_get_all"
- stmtUserGetByID = "user_get_by_id"
- stmtUserGetByUsername = "user_get_by_username"
- stmtUserGetByEmail = "user_get_by_email"
- stmtUserHasPassword = "user_has_password"
- stmtUserSearchPublic = "user_search_public"
- stmtUserCheckUsernameExists = "user_check_username_exists"
- stmtUserCreate = "user_create"
- stmtUserUpdate = "user_update"
- stmtUserUpdatePassword = "user_update_password"
- stmtUserUpdatePasswordResetToken = "user_update_password_reset_token"
- stmtUserDelete = "user_delete"
-)
-
-// NewUserRepository creates a new user repository with prepared statements
-func NewUserRepository(db *sql.DB, manager *RepositoryManager) (UserRepository, error) {
- repo := &UserRepositoryImpl{
- db: db,
- manager: manager,
- }
-
- if err := repo.prepareStatements(); err != nil {
- return nil, fmt.Errorf("failed to prepare user statements: %w", err)
- }
-
- return repo, nil
-}
-
-// prepareStatements prepares all SQL statements for the user repository
-func (r *UserRepositoryImpl) prepareStatements() error {
- statements := map[string]string{
- stmtUserGetAll: `
- SELECT id, username, firstname, lastname, role, avatar, email, created_timestamp, updated_timestamp
- FROM users
- ORDER BY created_timestamp DESC`,
-
- stmtUserGetByID: `
- SELECT id, username, firstname, lastname, role, avatar, email, created_timestamp, updated_timestamp
- FROM users
- WHERE id = ?`,
-
- stmtUserGetByUsername: `
- SELECT id, username, firstname, lastname, role, avatar, email, password, created_timestamp, updated_timestamp
- FROM users
- WHERE username = ?`,
-
- stmtUserGetByEmail: `
- SELECT id, username, firstname, lastname, role, avatar, email, created_timestamp, updated_timestamp
- FROM users
- WHERE email = ?`,
-
- stmtUserHasPassword: `
- SELECT COUNT(*)
- FROM users
- WHERE id = ? AND password IS NOT NULL`,
- stmtUserSearchPublic: `
- SELECT id, username, avatar, created_timestamp, updated_timestamp
- FROM users
- WHERE username = ? OR email = ? OR id = ?
- LIMIT 10`,
-
- stmtUserCheckUsernameExists: `
- SELECT COUNT(*)
- FROM users
- WHERE username = ?`,
-
- stmtUserCreate: `
- INSERT INTO users (id, username, firstname, lastname, role, avatar, email, password, created_timestamp, updated_timestamp)
- VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-
- stmtUserUpdate: `
- UPDATE users
- SET username=?, firstname=?, lastname=?, avatar=?, email=?, updated_timestamp=?
- WHERE id=?`,
-
- stmtUserUpdatePassword: `
- UPDATE users
- SET password=?, password_reset_token=NULL
- WHERE id=?`,
-
- stmtUserUpdatePasswordResetToken: `
- UPDATE users
- SET password_reset_token=?
- WHERE id=?`,
-
- stmtUserDelete: `
- DELETE FROM users
- WHERE id=?`,
- }
-
- // Prepare all statements
- for key, query := range statements {
- if _, err := r.manager.PrepareStatement(key, query); err != nil {
- return err
- }
- }
-
- return nil
+func NewUserRepository(db *sqlx.DB) UserRepository {
+ return &UserRepositoryImpl{db: db}
}
// GetAll retrieves all users
func (r *UserRepositoryImpl) GetAll() ([]*models.User, error) {
- stmt, err := r.manager.GetStatement(stmtUserGetAll)
- if err != nil {
- return nil, err
- }
-
- rows, err := stmt.Query()
+ var users []*models.User
+ err := r.db.Select(&users, `
+ SELECT id, username, firstname, lastname, role, avatar, email, created_timestamp, updated_timestamp
+ FROM users
+ ORDER BY created_timestamp DESC`)
if err != nil {
return nil, fmt.Errorf("failed to query users: %w", err)
}
- defer rows.Close()
-
- users := make([]*models.User, 0)
- for rows.Next() {
- var user models.User
- err := rows.Scan(
- &user.Id,
- &user.Username,
- &user.Firstname,
- &user.Lastname,
- &user.Role,
- &user.Avatar,
- &user.Email,
- &user.CreatedTimestamp,
- &user.UpdatedTimestamp,
- )
- if err != nil {
- return nil, fmt.Errorf("failed to scan user: %w", err)
- }
- users = append(users, &user)
- }
-
- if err = rows.Err(); err != nil {
- return nil, fmt.Errorf("error iterating users: %w", err)
- }
-
return users, nil
}
// GetByID retrieves a user by ID
func (r *UserRepositoryImpl) GetByID(id types.Snowflake) (*models.User, error) {
- stmt, err := r.manager.GetStatement(stmtUserGetByID)
- if err != nil {
- return nil, err
- }
-
var user models.User
- err = stmt.QueryRow(id).Scan(
- &user.Id,
- &user.Username,
- &user.Firstname,
- &user.Lastname,
- &user.Role,
- &user.Avatar,
- &user.Email,
- &user.CreatedTimestamp,
- &user.UpdatedTimestamp,
- )
-
+ err := r.db.Get(&user, `
+ SELECT id, username, firstname, lastname, role, avatar, email, created_timestamp, updated_timestamp
+ FROM users
+ WHERE id = ?`, id)
if err == sql.ErrNoRows {
return nil, nil
}
if err != nil {
return nil, fmt.Errorf("failed to get user by id: %w", err)
}
-
return &user, nil
}
-// GetByUsername retrieves a user by username (includes password)
+// GetByUsername retrieves a user by username (includes password for authentication)
func (r *UserRepositoryImpl) GetByUsername(username string) (*models.User, error) {
- stmt, err := r.manager.GetStatement(stmtUserGetByUsername)
- if err != nil {
- return nil, err
- }
-
var user models.User
- err = stmt.QueryRow(username).Scan(
- &user.Id,
- &user.Username,
- &user.Firstname,
- &user.Lastname,
- &user.Role,
- &user.Avatar,
- &user.Email,
- &user.Password,
- &user.CreatedTimestamp,
- &user.UpdatedTimestamp,
- )
-
+ err := r.db.Get(&user, `
+ SELECT id, username, firstname, lastname, role, avatar, email, password, created_timestamp, updated_timestamp
+ FROM users
+ WHERE username = ?`, username)
if err == sql.ErrNoRows {
return nil, nil
}
if err != nil {
return nil, fmt.Errorf("failed to get user by username: %w", err)
}
-
return &user, nil
}
// GetByEmail retrieves a user by email
func (r *UserRepositoryImpl) GetByEmail(email string) (*models.User, error) {
- stmt, err := r.manager.GetStatement(stmtUserGetByEmail)
- if err != nil {
- return nil, err
- }
-
var user models.User
- err = stmt.QueryRow(email).Scan(
- &user.Id,
- &user.Username,
- &user.Firstname,
- &user.Lastname,
- &user.Role,
- &user.Avatar,
- &user.Email,
- &user.CreatedTimestamp,
- &user.UpdatedTimestamp,
- )
-
+ err := r.db.Get(&user, `
+ SELECT id, username, firstname, lastname, role, avatar, email, created_timestamp, updated_timestamp
+ FROM users
+ WHERE email = ?`, email)
if err == sql.ErrNoRows {
return nil, nil
}
if err != nil {
return nil, fmt.Errorf("failed to get user by email: %w", err)
}
-
return &user, nil
}
// HasPassword checks if a user has a password set
func (r *UserRepositoryImpl) HasPassword(id types.Snowflake) (bool, error) {
- stmt, err := r.manager.GetStatement(stmtUserHasPassword)
- if err != nil {
- return false, err
- }
-
var count int
- err = stmt.QueryRow(id).Scan(&count)
+ err := r.db.Get(&count, `SELECT COUNT(*) FROM users WHERE id = ? AND password IS NOT NULL`, id)
if err != nil {
return false, fmt.Errorf("failed to check if user has password: %w", err)
}
-
return count > 0, nil
}
// SearchPublic searches for public user profiles
func (r *UserRepositoryImpl) SearchPublic(query string) ([]*models.User, error) {
- stmt, err := r.manager.GetStatement(stmtUserSearchPublic)
- if err != nil {
- return nil, err
- }
-
- rows, err := stmt.Query(query, query, query)
+ var users []*models.User
+ err := r.db.Select(&users, `
+ SELECT id, username, avatar, created_timestamp, updated_timestamp
+ FROM users
+ WHERE username = ? OR email = ? OR id = ?
+ LIMIT 10`, query, query, query)
if err != nil {
return nil, fmt.Errorf("failed to search public users: %w", err)
}
- defer rows.Close()
-
- users := make([]*models.User, 0)
- for rows.Next() {
- var user models.User
- err := rows.Scan(
- &user.Id,
- &user.Username,
- &user.Avatar,
- &user.CreatedTimestamp,
- &user.UpdatedTimestamp,
- )
- if err != nil {
- return nil, fmt.Errorf("failed to scan user: %w", err)
- }
- users = append(users, &user)
- }
-
- if err = rows.Err(); err != nil {
- return nil, fmt.Errorf("error iterating users: %w", err)
- }
-
return users, nil
}
// CheckUsernameExists checks if a username already exists
func (r *UserRepositoryImpl) CheckUsernameExists(username string) (bool, error) {
- stmt, err := r.manager.GetStatement(stmtUserCheckUsernameExists)
- if err != nil {
- return false, err
- }
-
var count int
- err = stmt.QueryRow(username).Scan(&count)
+ err := r.db.Get(&count, `SELECT COUNT(*) FROM users WHERE username = ?`, username)
if err != nil {
return false, fmt.Errorf("failed to check username exists: %w", err)
}
-
return count > 0, nil
}
// Create creates a new user
func (r *UserRepositoryImpl) Create(user *models.User) (*models.User, error) {
- stmt, err := r.manager.GetStatement(stmtUserCreate)
- if err != nil {
- return nil, err
- }
-
- _, err = stmt.Exec(
- user.Id,
- user.Username,
- user.Firstname,
- user.Lastname,
- user.Role,
- user.Avatar,
- user.Email,
- user.Password,
- user.CreatedTimestamp,
- user.UpdatedTimestamp,
- )
-
+ _, err := r.db.NamedExec(`
+ INSERT INTO users (id, username, firstname, lastname, role, avatar, email, password, created_timestamp, updated_timestamp)
+ VALUES (:id, :username, :firstname, :lastname, :role, :avatar, :email, :password, :created_timestamp, :updated_timestamp)`,
+ user)
if err != nil {
return nil, fmt.Errorf("failed to create user: %w", err)
}
-
return user, nil
}
// Update updates an existing user
func (r *UserRepositoryImpl) Update(id types.Snowflake, user *models.User) (*models.User, error) {
- stmt, err := r.manager.GetStatement(stmtUserUpdate)
- if err != nil {
- return nil, err
- }
-
- _, err = stmt.Exec(
- user.Username,
- user.Firstname,
- user.Lastname,
- user.Avatar,
- user.Email,
- user.UpdatedTimestamp,
- id,
- )
-
+ _, err := r.db.Exec(`
+ UPDATE users
+ SET username=?, firstname=?, lastname=?, avatar=?, email=?, updated_timestamp=?
+ WHERE id=?`,
+ user.Username, user.Firstname, user.Lastname, user.Avatar, user.Email, user.UpdatedTimestamp, id)
if err != nil {
return nil, fmt.Errorf("failed to update user: %w", err)
}
-
return user, nil
}
// UpdatePassword updates a user's password
func (r *UserRepositoryImpl) UpdatePassword(id types.Snowflake, password string) error {
- stmt, err := r.manager.GetStatement(stmtUserUpdatePassword)
- if err != nil {
- return err
- }
-
- _, err = stmt.Exec(password, id)
+ _, err := r.db.Exec(`UPDATE users SET password=?, password_reset_token=NULL WHERE id=?`, password, id)
if err != nil {
return fmt.Errorf("failed to update password: %w", err)
}
-
return nil
}
// UpdatePasswordResetToken updates a user's password reset token
func (r *UserRepositoryImpl) UpdatePasswordResetToken(id types.Snowflake, resetToken string) error {
- stmt, err := r.manager.GetStatement(stmtUserUpdatePasswordResetToken)
- if err != nil {
- return err
- }
-
- _, err = stmt.Exec(resetToken, id)
+ _, err := r.db.Exec(`UPDATE users SET password_reset_token=? WHERE id=?`, resetToken, id)
if err != nil {
return fmt.Errorf("failed to update password reset token: %w", err)
}
-
return nil
}
// Delete deletes a user
func (r *UserRepositoryImpl) Delete(id types.Snowflake) error {
- stmt, err := r.manager.GetStatement(stmtUserDelete)
- if err != nil {
- return err
- }
-
- _, err = stmt.Exec(id)
+ _, err := r.db.Exec(`DELETE FROM users WHERE id=?`, id)
if err != nil {
return fmt.Errorf("failed to delete user: %w", err)
}
-
return nil
}